import { NavigationExtras, Router } from '@angular/router';
import { MessageBoxService } from '@sowatech/shared/dialogs';
import { GenericEditDialogService, GridColumnButtonEvent, IDialogConfiguration, DialogDynamicList, GenericEditDialogResult } from '@sowatech/shared/swt-generic';
import { MonoTypeOperatorFunction, OperatorFunction } from 'rxjs';

type ValueOrFunction<T, Parameters> = T | ((params: Parameters) => T);
/** Wert, der im Fehlerfall verwendet werden kann, um Fehler zu erkennen und im Observable Stream zu ignorieren */
declare const ERROR_VALUE: Readonly<{
    _error: true;
}>;
/**
 * Operator, um im Fehlerfall den Edit Dialog zu öffnen und den Fehler dort anzuzeigen.
 * Beispiel:
 * ```ts
 * create$.pipe(
 *     showDialog(new CreateDialog()),
 *     webApiCall(dto => this.webApi.create(dto), catchAndShowDialogErrors()),
 * );
 * ```
 */
declare function catchAndShowDialogErrors<T>(dialog?: GenericEditDialogService): MonoTypeOperatorFunction<T>;
/**
 * Zur Anzeige eines Confirm Dialogs. Texte können als konstanter String oder als Funktion, die jedes Mal evaluiert wird, angegeben werden.
 * Beispiel:
 * ```ts
 * delete$.pipe(
 *     showConfirm(({ name }) => `Möchten Sie ${name} wirklich löschen?`, 'Löschen?'),
 *     switchMap(dto => this.webApi.delete(dto)),
 * );
 * ```
 */
declare function showConfirm<T>(text: ValueOrFunction<string, T>, title?: ValueOrFunction<string, T>, messageBox?: MessageBoxService): MonoTypeOperatorFunction<T>;
/**
 * @deprecated Nur für debugging
 */
declare function consoleWarn<T>(label?: any): MonoTypeOperatorFunction<T>;
/**
 * @deprecated Nur für debugging
 */
declare function consoleCount<T>(label: string): MonoTypeOperatorFunction<T>;
/**
 * Verkürzt das Mappen aller Items einer Liste.
 *
 * Ohne mapEach: `map(list => list.map(item => new Model(item)))`
 *
 * Mit mapEach: `mapEach(item => new Model(item))`
 */
declare function mapEach<In, Out>(fn: (source: In) => Out): OperatorFunction<In[], Out[]>;
declare function notUndefined<T>(): OperatorFunction<T | undefined, T>;
declare function notNull<T>(): OperatorFunction<T | null, T>;
/**
 * Filtert ein Observable von `GridColumnButtonEvent` nach dem ident.
 * @param ident
 */
declare function filterButtonIdent(ident: string): MonoTypeOperatorFunction<GridColumnButtonEvent>;
type DialogModeType = any;
/**
 * Examples:
 * ```ts
 * showDialog(new MyDialog()) // Dialog anzeigen
 * showDialog(dto => new MyDialog(dto.flag)) // Dialog anhand der Daten modifizieren
 * showDialog(new MyDialog(), dto => ({ value: dto.a, text: dto.b })) // Dialog vorausfüllen
 * showDialog(new MyDialog(), null, () => ({ lookups: [{ key: 'datasource', datasource: this.lookupDatasource }] })) // Datasource für Grid
 * ```
 */
declare function showDialog<Input, Model extends object>(config: ValueOrFunction<IDialogConfiguration<Model>, Input>, dto?: ((input: Input) => Partial<Model> | null) | null, options?: ((input: Input) => {
    mode?: DialogModeType;
    lookups: DialogDynamicList[];
}) | null, dialog?: GenericEditDialogService): OperatorFunction<Input, GenericEditDialogResult<Model, DialogModeType>>;
/**
 * Wrapper für einen WebApi Call, mit dem man Fehler behandeln kann, ohne die äußere Subscription zu beenden.
 * Sollte mit einem Error Handler benutzt werden.
 * ```ts
 * webApiCall(() => this.webApi.getList(), handleError('Laden der Liste'))
 * webApiCall(dto => this.webApi.create(dto), catchAndShowDialogErrors())
 * ```
 */
declare function webApiCall<Input, Response>(fn: (input: Input) => Promise<Response>, ...pipes: [MonoTypeOperatorFunction<Response>, ...MonoTypeOperatorFunction<Response>[]]): OperatorFunction<Input, Response>;
declare function navigateTo<T>(fn: (input: T) => (string | number)[], extrasFn?: (input: T) => NavigationExtras, router?: Router): MonoTypeOperatorFunction<T>;
/**
 * Wenn die Bedingung **nicht** erfüllt ist, wird die angegebene Fehlermeldung im Dialog angezeigt.
 * Beispiel:
 * ```ts
 * pipe(
 *     showDialog(new CreateDialog()),
 *     dialogAssert(({ start, end } => end >= start, 'Das Ende darf nicht vor dem Start liegen'),
 * )
 * ```
 */
declare function dialogAssert<T>(condition: (input: T) => boolean, errorMessage: string, dialog?: GenericEditDialogService): MonoTypeOperatorFunction<T>;

export { ERROR_VALUE, catchAndShowDialogErrors, consoleCount, consoleWarn, dialogAssert, filterButtonIdent, mapEach, navigateTo, notNull, notUndefined, showConfirm, showDialog, webApiCall };