import { HttpErrorResponse } from '@angular/common/http';
import * as _ngrx_effects from '@ngrx/effects';
import { Actions, CreateEffectMetadata } from '@ngrx/effects';
import * as _ngrx_store from '@ngrx/store';
import { ActionCreator, Creator, Action, ActionReducer, on, MemoizedSelector } from '@ngrx/store';
import * as rxjs from 'rxjs';
import { OperatorFunction, Observable } from 'rxjs';
import * as _angular_core from '@angular/core';
import { ProviderToken } from '@angular/core';
import { GenericEditDialogService, GridComponent } from '@sowatech/shared/swt-generic';
import { RefreshResult, RefreshParams } from '@sowatech/shared/ds-datasource';

/**
 * Effect, der als Reaktion auf eine Failure Action den ErrorHandler mit angegebenem ActionText auslöst.
 * ```ts
 * loadListError$ = createErrorHandlerEffect(apiActions.loadListFailure, 'Laden der Liste');
 * ```
 */
declare function createErrorHandlerEffect(action: ActionCreator<string, Creator<[HttpErrorResponse], {
    error: ErrorParams;
}>>, actionText: string, actions$?: Actions<any>): rxjs.Observable<{
    error: ErrorParams;
    actionText: string;
    handling: "messageBox" | "dialog";
} & Action<"[App] Error">> & _ngrx_effects.CreateEffectMetadata;
/**
 * Effect, der als Reaktion auf eine Failure Action den Fehler im Edit Dialog anzeigt.
 * ```ts
 * createError$ = createDialogErrorEffect(apiActions.createFailure);
 * ```
 */
declare function createDialogErrorEffect(action: ActionCreator<string, Creator<[HttpErrorResponse], {
    error: ErrorParams;
}>>, actions$?: Actions<any>): rxjs.Observable<{
    error: ErrorParams;
    actionText: string;
    handling: "messageBox" | "dialog";
} & Action<"[App] Error">> & _ngrx_effects.CreateEffectMetadata;
type HttpStatusCode = number;
type ErrorParams = {
    name: string;
    message: string;
    status: HttpStatusCode;
    error: any;
    trace?: string;
};
type FailureParam = HttpErrorResponse;
type FailurePayload = {
    error: ErrorParams;
};
type FailureAction = ActionCreator<string, Creator<[FailureParam], Action & FailurePayload>>;
/**
 * Kann gesetzt werden, um eine Trace ID aus dem Error zu lesen
 * ```ts
 * errorPropsGetTraceId.set(error => {
 *     if (error instanceof HttpErrorResponse)
 *         return error.headers.get('X-Trace-Id') ?? undefined;
 *     return undefined;
 * });
 * ```
 */
declare const errorPropsGetTraceId: _angular_core.WritableSignal<(error: unknown) => string | undefined>;
/**
 * props für Failure Actions.
 * ```ts
 * createActionGroup({
 *     name: 'My API',
 *     events: {
 *         'Update Success': emptyProps(),
 *         'Update Failure': errorProps(),
 *     },
 * });
 *
 * catchError(err => of(apiActions.updateFailure(err)))
 * ```
 */
declare const errorProps: () => (error: FailureParam) => FailurePayload;
/**
 * Abkürzung fürs Mappen zu einer Failure Action.
 *
 * ohne mapFailure: `catchError(err => of(apiActions.updateFailure(err)))`
 *
 * mit mapFailure: `mapFailure(apiActions.updateFailure)`
 */
declare const mapFailure: (failureAction: FailureAction) => OperatorFunction<unknown, Action & FailurePayload>;
type ErrorOptions = {
    handling: 'messageBox';
    actionText: string;
} | {
    handling: 'dialog';
    actionText: undefined;
};
/**
 * globale Error Action, über die sämtliches ErrorHandling abgehandelt wird
 */
declare const errorAction: _ngrx_store.FunctionWithParametersType<[error: ErrorParams, errorOptions: ErrorOptions], {
    error: ErrorParams;
    actionText: string;
    handling: "messageBox" | "dialog";
} & Action<"[App] Error">> & Action<"[App] Error">;
/**
 * Globaler Effect, der von `createDialogErrorEffect` gemappte Fehler im Dialog anzeigt.
 * Der Effect muss im AppModule registriert werden:
 * ```ts
 * EffectsModule.forRoot({ globalDialogErrorHandlingEffect })
 * ```
 */
declare const globalDialogErrorHandlingEffect: _ngrx_effects.FunctionalEffect<(actions$?: Actions<any>, dialog?: GenericEditDialogService) => rxjs.Observable<string>>;
type ErrorHandlerService = ProviderToken<{
    handleError: (error: any, actionText: string) => any;
}>;
/**
 * Globaler Effect, der von `createErrorHandlerEffect` gemappte Fehler über den ErrorHandler anzeigt
 * Ist eine Factory, weil der ErrorHandler nicht im shared liegt.
 * Der Effect muss im AppModule registriert werden:
 * ```ts
 * EffectsModule.forRoot({ globalErrorHandlingEffect: globalErrorHandlingEffectFactory(ErrorHandlerService) })
 * ```
 */
declare function globalErrorHandlingEffectFactory(errorHandlerType: ErrorHandlerService): _ngrx_effects.FunctionalEffect<(actions$?: Actions<any>, errorHandler?: {
    handleError: (error: any, actionText: string) => any;
}) => rxjs.Observable<unknown>>;

type EffectReturnType = Observable<Action> & CreateEffectMetadata;
/**
 * Abkürzung von `createEffect` für den Standardfall, wenn man auf Actions reagiert
 * ```ts
 * loadList$ = createActionEffect(
 *     [listActions.init, apiActions.createSuccess],
 *     switchMap(() => this.webApi.getList()),
 * );
 * create$ = createActionEffect(
 *     listActions.create,
 *     showDialog(new CreateDialog()),
 *     switchMap(({ dto }) => this.webApi.create(dto)),
 * );
 * ```
 */
declare function createActionEffect<T extends string, P extends Creator>(actions: ActionCreator<T, P> | ActionCreator<T, P>[], op1: OperatorFunction<ReturnType<P>, Action>): EffectReturnType;
declare function createActionEffect<T extends string, P extends Creator, A>(actions: ActionCreator<T, P> | ActionCreator<T, P>[], op1: OperatorFunction<ReturnType<P>, A>, op2: OperatorFunction<A, Action>): EffectReturnType;
declare function createActionEffect<T extends string, P extends Creator, A, B>(actions: ActionCreator<T, P> | ActionCreator<T, P>[], op1: OperatorFunction<ReturnType<P>, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, Action>): EffectReturnType;
declare function createActionEffect<T extends string, P extends Creator, A, B, C>(actions: ActionCreator<T, P> | ActionCreator<T, P>[], op1: OperatorFunction<ReturnType<P>, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, Action>): EffectReturnType;
declare function createActionEffect<T extends string, P extends Creator, A, B, C, D>(actions: ActionCreator<T, P> | ActionCreator<T, P>[], op1: OperatorFunction<ReturnType<P>, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, Action>): EffectReturnType;
declare function createActionEffect<T extends string, P extends Creator, A, B, C, D, E>(actions: ActionCreator<T, P> | ActionCreator<T, P>[], op1: OperatorFunction<ReturnType<P>, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, Action>): EffectReturnType;
declare function createActionEffect<T extends string, P extends Creator, A, B, C, D, E, F>(actions: ActionCreator<T, P> | ActionCreator<T, P>[], op1: OperatorFunction<ReturnType<P>, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, Action>): EffectReturnType;
declare function createActionEffect<T extends string, P extends Creator, A, B, C, D, E, F, G>(actions: ActionCreator<T, P> | ActionCreator<T, P>[], op1: OperatorFunction<ReturnType<P>, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, Action>): EffectReturnType;
declare function createActionEffect<T extends string, P extends Creator, A, B, C, D, E, F, G, H>(actions: ActionCreator<T, P> | ActionCreator<T, P>[], op1: OperatorFunction<ReturnType<P>, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, Action>): EffectReturnType;
declare function createActionEffect<T extends string, P extends Creator, A, B, C, D, E, F, G, H, I>(actions: ActionCreator<T, P> | ActionCreator<T, P>[], op1: OperatorFunction<ReturnType<P>, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>, op10: OperatorFunction<I, Action>): EffectReturnType;
/**
 * @deprecated
 * Benutze `createActionEffect` statt `this.on`,
 * `createErrorHandlerEffect` statt `this.onError`
 * und `createDialogErrorEffect` statt `this.onDialogError`
 */
declare abstract class EffectBase {
    protected readonly actions$: Actions<any>;
    protected on<T extends string, P extends Creator>(actions: ActionCreator<T, P> | ActionCreator<T, P>[], fn: (obs$: Observable<ReturnType<P>>) => Observable<Action>): EffectReturnType;
    protected onError(action: ActionCreator<string, Creator<[HttpErrorResponse], {
        error: ErrorParams;
    }>>, actionText: string): Observable<{
        error: ErrorParams;
        actionText: string;
        handling: "messageBox" | "dialog";
    } & Action<"[App] Error">> & CreateEffectMetadata;
    protected onDialogError(action: ActionCreator<string, Creator<[HttpErrorResponse], {
        error: ErrorParams;
    }>>): Observable<{
        error: ErrorParams;
        actionText: string;
        handling: "messageBox" | "dialog";
    } & Action<"[App] Error">> & CreateEffectMetadata;
}

/**
 * Meta Reducer fürs Loggen der Actions. Wird konfiguriert im AppModule:
 * ```ts
 * StoreModule.forRoot({}, { metaReducers: [loggingMetaReducer] }),
 * ```
 */
declare function loggingMetaReducer(reducer: ActionReducer<unknown>): ActionReducer<unknown>;

interface ExternalRefreshState<T> {
    refreshResult: RefreshResult<T> | null;
    loading: boolean;
}
type Last<T extends readonly unknown[]> = T extends readonly [...infer _, infer L] ? L : never;
type OnFunction<State, Creators extends readonly ActionCreator[]> = typeof on<State, Creators>;
type OnReducer<State, Creators extends readonly ActionCreator[]> = Last<Parameters<OnFunction<State, Creators>>>;
type Id = any;
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>(),
 * ```
 */
declare function createExternalRefreshAdapter<T>(): ExternalRefreshAdapter<T>;
type ExternalRefreshResultProps<T> = {
    refreshResult: RefreshResult<T>;
};
type ExternalRefreshResultAction<T> = ActionCreator<string, Creator<[RefreshResult<T>], ExternalRefreshResultProps<T> & {
    type: string;
}>>;
declare function externalRefreshResultProps<T>(): (refreshResult: RefreshResult<T>) => ExternalRefreshResultProps<T>;
type ExternalRefreshParamsProps = {
    refreshParams: RefreshParams;
};
type ExternalRefreshParamsAction<Type extends string = string> = ActionCreator<Type, Creator<[RefreshParams], ExternalRefreshParamsProps & {
    type: Type;
}>>;
declare function externalRefreshParamsProps(): (refreshParams: RefreshParams) => ExternalRefreshParamsProps;
interface DatasourceCsvExportEffectOptions {
    action: ExternalRefreshResultAction<any>;
    grid: () => GridComponent | null | undefined;
}
/**
 * Ermöglicht CSV-Downloads mit External Refresh über NGRX.
 * ```ts
 * constructor() {
 *     // ...
 *     handleCsvExportAction({ action: myActions.loadSuccess, grid: () => this.grid() });
 * }
 * ```
 */
declare function handleCsvExportAction(options: DatasourceCsvExportEffectOptions): void;

declare class ExternalRefreshActionDirective {
    private readonly datasource;
    private readonly store;
    readonly externalRefreshAction: _angular_core.InputSignal<ExternalRefreshParamsAction>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ExternalRefreshActionDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ExternalRefreshActionDirective, "ds-datasource[externalRefreshAction][externalRefreshResult]", never, { "externalRefreshAction": { "alias": "externalRefreshAction"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

export { EffectBase, ExternalRefreshActionDirective, ExternalRefreshAdapter, createActionEffect, createDialogErrorEffect, createErrorHandlerEffect, createExternalRefreshAdapter, errorAction, errorProps, errorPropsGetTraceId, externalRefreshParamsProps, externalRefreshResultProps, globalDialogErrorHandlingEffect, globalErrorHandlingEffectFactory, handleCsvExportAction, loggingMetaReducer, mapFailure };
export type { DatasourceCsvExportEffectOptions, ErrorParams, ExternalRefreshParamsAction, ExternalRefreshParamsProps, ExternalRefreshResultAction, ExternalRefreshResultProps, ExternalRefreshState };