import { AnimationTriggerMetadata } from '@angular/animations';
import { ApiDefinition } from '@tstdl/base/api';
import { ApiClient } from '@tstdl/base/api/client';
import * as i0 from '@angular/core';
import { OnInit, OnChanges, OnDestroy, AfterViewInit, AfterContentInit, AfterViewChecked, AfterContentChecked, SimpleChanges, SimpleChange, ElementRef, Renderer2, ChangeDetectorRef, TemplateRef, Signal, ResourceOptions, ResourceRef, ViewContainerRef, EventEmitter, PipeTransform, SecurityContext, ApplicationRef, NgZone, ErrorHandler, WritableSignal, Provider, EnvironmentProviders } from '@angular/core';
import { CancellationSignal } from '@tstdl/base/cancellation';
import { TypedOmit, PropertiesOfType, Record as Record$1, Enumeration, EnumerationValue, SimplifyObject, SimplifiedLiteralUnion } from '@tstdl/base/types';
import * as rxjs from 'rxjs';
import { Observable, ReadableStreamLike, OperatorFunction, MonoTypeOperatorFunction } from 'rxjs';
import { ControlValueAccessor } from '@angular/forms';
import { HttpClientAdapter, HttpClientRequest, HttpClientResponse } from '@tstdl/base/http';
import { DateTime, DateTimeFormatOptions, LocaleOptions, Duration, DurationObjectUnits, DurationOptions, DateTimeJSOptions } from 'luxon';
import { DynamicText, LocalizationKey, LocalizationData } from '@tstdl/base/text';
import { DomSanitizer, SafeHtml, SafeResourceUrl, SafeUrl, SafeValue } from '@angular/platform-browser';
import { SerializationOptions } from '@tstdl/base/serializer';
import { FormatErrorOptions } from '@tstdl/base/utils';
import { InputType, InputMode, InputAttributes, TextAreaAttributes } from '@tstdl/base/web-types';
import { ResolveFn, Router, ActivatedRoute, NavigationExtras } from '@angular/router';
import { Tagged } from 'type-fest';
import { SIGNAL } from '@angular/core/primitives/signals';
export { SIGNAL } from '@angular/core/primitives/signals';

type AnimationOptions = {
    trigger?: string;
    duration?: number | string;
    delay?: number | string;
    ease?: string;
};

type CollapseAnimationOptions = AnimationOptions & {
    width?: boolean;
    height?: boolean;
    opacity?: boolean;
    scale?: boolean;
    /**
     * @default 'void => *, true <=> *'
     */
    stateTransition?: string;
};
declare function collapseAnimation(options?: CollapseAnimationOptions): AnimationTriggerMetadata;

declare function fadeInOutAnimation(options?: AnimationOptions & {
    targetOpacity?: number;
}): AnimationTriggerMetadata;

declare function widthAnimation(options?: AnimationOptions & {
    defaultWidth?: string;
}): AnimationTriggerMetadata;
declare function heightAnimation(options?: AnimationOptions & {
    defaultHeight?: string;
}): AnimationTriggerMetadata;

declare function slideInOutAnimation(options?: AnimationOptions & {
    direction?: 'left' | 'right';
}): AnimationTriggerMetadata;

declare function getAnimateTimings(options?: AnimationOptions): string;

declare function getApiService<T extends ApiDefinition>(baseName: string, apiDefinition: T): ApiClient<T>;

type TypedSimpleChange<T> = TypedOmit<SimpleChange, 'previousValue' | 'currentValue'> & {
    previousValue: T;
    currentValue: T;
};
type ParentProperties<Parent> = Exclude<keyof Parent, keyof LifecycleUtils>;
declare class LifecycleUtils<Parent = any> implements OnInit, OnChanges, OnDestroy, AfterViewInit, AfterContentInit, AfterViewChecked, AfterContentChecked {
    #private;
    private readonly initSubject;
    private readonly destroySubject;
    private readonly changesSubject;
    private readonly viewInitSubject;
    private readonly contentInitSubject;
    private readonly viewCheckedSubject;
    private readonly contentCheckedSubject;
    private readonly ionViewWillEnterSubject;
    private readonly ionViewDidEnterSubject;
    private readonly ionViewWillLeaveSubject;
    private readonly ionViewDidLeaveSubject;
    /**
     * emits on `ngOnInit`. Also emits if subscribed afterwards
     * @see {@link OnInit}
     */
    readonly init$: Observable<void>;
    /**
     * emits on `ngOnChanges`
     * @see {@link OnChanges}
     */
    readonly changes$: Observable<SimpleChanges>;
    /**
     * emits on `ngOnDestroy`. Also emits if subscribed afterwards
     * @see {@link OnDestroy}
     */
    readonly destroy$: Observable<void>;
    /**
     * emits on `ngAfterViewInit`. Also emits if subscribed afterwards
     * @see {@link AfterViewInit}
     */
    readonly viewInit$: Observable<void>;
    /**
     * emits on `ngAfterContentInit`. Also emits if subscribed afterwards
     * @see {@link AfterContentInit}
     */
    readonly contentInit$: Observable<void>;
    /**
     * emits on `ngAfterViewChecked`
     * @see {@link AfterViewChecked}
     */
    readonly viewChecked$: Observable<void>;
    /**
     * emits on `ngAfterContentChecked`
     * @see {@link AfterContentChecked}
     */
    readonly contentChecked$: Observable<void>;
    /**
     * emits on `ionViewWillEnter`
     */
    readonly ionViewWillEnter$: Observable<void>;
    /**
     * emits on `ionViewDidEnter`
     */
    readonly ionViewDidEnter$: Observable<void>;
    /**
     * emits on `ionViewWillLeave`
     */
    readonly ionViewWillLeave$: Observable<void>;
    /**
     * emits on `ionViewDidLeave`
     */
    readonly ionViewDidLeave$: Observable<void>;
    /**
     * {@link CancellationToken} bound to {@link destroy$}
     */
    get destroySignal(): CancellationSignal;
    constructor();
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    ngAfterViewInit(): void;
    ngAfterContentInit(): void;
    ngAfterViewChecked(): void;
    ngAfterContentChecked(): void;
    ionViewWillEnter(): void;
    ionViewDidEnter(): void;
    ionViewWillLeave(): void;
    ionViewDidLeave(): void;
    observeChanges<Property extends ParentProperties<Parent>>(property: Property): Observable<TypedSimpleChange<Parent[Property]>>;
    observe<Property extends ParentProperties<Parent>>(property: Property): Observable<Parent[Property]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LifecycleUtils<any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LifecycleUtils<any>>;
}

declare class TstdlColoredProgressbarComponent extends LifecycleUtils<TstdlColoredProgressbarComponent> {
    progress: number | undefined;
    rounded: boolean;
    get backgroundColor(): string;
    get progressbarColor(): string;
    get width(): string;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<TstdlColoredProgressbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TstdlColoredProgressbarComponent, "tsl-colored-progressbar", never, { "progress": { "alias": "progress"; "required": false; }; "rounded": { "alias": "rounded"; "required": false; }; }, {}, never, never, true, never>;
}

declare class TstdlIndeterminateProgressBarComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<TstdlIndeterminateProgressBarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TstdlIndeterminateProgressBarComponent, "tsl-indeterminate-progress-bar", never, {}, {}, never, never, true, never>;
}

declare class TstdlMarkdownComponent {
    markdown: string | null | undefined;
    get markdownHtml(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TstdlMarkdownComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TstdlMarkdownComponent, "tsl-markdown, [tslMarkdown]", never, { "markdown": { "alias": "markdown"; "required": false; }; }, {}, never, never, true, never>;
}

declare class TstdlSkeletonComponent {
    dark: boolean | undefined;
    get light(): boolean;
    width: string | null | undefined;
    height: string | null | undefined;
    borderRadius: string | null | undefined;
    pulseSize: string | null | undefined;
    pulseScale: number | string | null | undefined;
    pulseDuration: string | null | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<TstdlSkeletonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TstdlSkeletonComponent, "tsl-skeleton", never, { "dark": { "alias": "dark"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "borderRadius": { "alias": "borderRadius"; "required": false; }; "pulseSize": { "alias": "pulseSize"; "required": false; }; "pulseScale": { "alias": "pulseScale"; "required": false; }; "pulseDuration": { "alias": "pulseDuration"; "required": false; }; }, {}, never, never, true, never>;
}

declare class AutoIdDirective {
    private readonly elementRef;
    private readonly renderer;
    get id(): string;
    constructor(elementRef: ElementRef, renderer: Renderer2);
    static ɵfac: i0.ɵɵFactoryDeclaration<AutoIdDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AutoIdDirective, "input, [tslAutoId]", ["autoId"], {}, {}, never, never, true, never>;
}

declare class AutoForDirective implements OnChanges {
    private readonly elementRef;
    private readonly renderer;
    autoFor: AutoIdDirective | null | undefined;
    constructor(elementRef: ElementRef, renderer: Renderer2);
    ngOnChanges(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AutoForDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AutoForDirective, "label, [tslAutoFor]", never, { "autoFor": { "alias": "autoFor"; "required": false; }; }, {}, never, never, true, never>;
}

declare class DateInputControlValueAccessor implements ControlValueAccessor {
    #private;
    private onTouched;
    private onChange;
    readonly valueType: i0.ModelSignal<"value" | "valueAsNumber" | "valueAsDate">;
    onBlur(): void;
    onInputChange(): void;
    registerOnTouched(fn: typeof this.onTouched): void;
    registerOnChange(fn: typeof this.onChange): void;
    writeValue(value: Date | string | number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateInputControlValueAccessor, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DateInputControlValueAccessor, "input[type=date], input[type=datetime-local]", never, { "valueType": { "alias": "valueType"; "required": false; "isSignal": true; }; }, { "valueType": "valueTypeChange"; }, never, never, true, never>;
}

declare class DragDirective {
    readonly clearData: i0.InputSignal<boolean>;
    readonly allowedEffect: i0.InputSignal<"link" | "all" | "none" | "copy" | "copyLink" | "copyMove" | "linkMove" | "move" | "uninitialized">;
    readonly image: i0.InputSignal<Element | undefined>;
    readonly imageCoordinates: i0.InputSignal<[x: number, y: number] | undefined>;
    readonly format: i0.InputSignal<string | undefined>;
    readonly data: i0.InputSignal<string | Record<string, string> | undefined>;
    readonly start: i0.OutputEmitterRef<DragEvent>;
    readonly drag: i0.OutputEmitterRef<DragEvent>;
    readonly end: i0.OutputEmitterRef<DragEvent>;
    readonly dragging: i0.WritableSignal<boolean>;
    onDrag(event: DragEvent): void;
    onDragStart(event: DragEvent): void;
    onDragEnd(event: DragEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DragDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DragDirective, "[tslDrag]", ["drag"], { "clearData": { "alias": "clearData"; "required": false; "isSignal": true; }; "allowedEffect": { "alias": "allowedEffect"; "required": false; "isSignal": true; }; "image": { "alias": "image"; "required": false; "isSignal": true; }; "imageCoordinates": { "alias": "imageCoordinates"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; }, { "start": "start"; "drag": "drag"; "end": "end"; }, never, never, true, never>;
}

declare class DropDirective {
    #private;
    readonly effect: i0.InputSignal<"link" | "none" | "copy" | "move" | undefined>;
    readonly enter: i0.OutputEmitterRef<DragEvent>;
    readonly leave: i0.OutputEmitterRef<DragEvent>;
    readonly over: i0.OutputEmitterRef<DragEvent>;
    readonly dropped: i0.OutputEmitterRef<DragEvent>;
    readonly itemsDropped: i0.OutputEmitterRef<DataTransferItem[]>;
    readonly filesDropped: i0.OutputEmitterRef<File[]>;
    readonly entered: i0.Signal<boolean>;
    readonly isOver: i0.Signal<boolean>;
    onDragEnter(event: DragEvent): void;
    onDragOver(event: DragEvent): void;
    onDragLeave(event: DragEvent): void;
    onDrop(event: DragEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DropDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DropDirective, "[tslDrop]", ["drop"], { "effect": { "alias": "effect"; "required": false; "isSignal": true; }; }, { "enter": "enter"; "leave": "leave"; "over": "over"; "dropped": "dropped"; "itemsDropped": "itemsDropped"; "filesDropped": "filesDropped"; }, never, never, true, never>;
}

declare class FilterHelperDirective<T> {
    readonly filterValues: i0.InputSignal<T[] | null | undefined>;
    readonly filterSelector: i0.InputSignal<PropertiesOfType<T, string> | (() => string) | undefined>;
    readonly filter: i0.ModelSignal<string | null>;
    readonly normalizedFilterValues: i0.Signal<{
        value: T;
        searchValue: string;
    }[]>;
    readonly filteredValues: i0.Signal<T[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterHelperDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FilterHelperDirective<any>, "[tslFilterHelper]", ["filterHelper"], { "filterValues": { "alias": "filterValues"; "required": false; "isSignal": true; }; "filterSelector": { "alias": "filterSelector"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; }, { "filter": "filterChange"; }, never, never, true, never>;
}

declare class InputPatternDirective implements OnInit {
    private readonly element;
    private readonly pattern;
    readonly firstMatchOnly: i0.InputSignalWithTransform<boolean, unknown>;
    readonly tslInputPattern: i0.InputSignal<string | RegExp | null | undefined>;
    lastKnownValue: string;
    ngOnInit(): void;
    onChange(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputPatternDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<InputPatternDirective, "input[tslInputPattern]", never, { "firstMatchOnly": { "alias": "firstMatchOnly"; "required": false; "isSignal": true; }; "tslInputPattern": { "alias": "tslInputPattern"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

type ElementOrElementRef = Element | ElementRef<Element>;
declare class LazyListDirective<T> extends LifecycleUtils<LazyListDirective<T>> implements AfterViewInit {
    private readonly changeDetector;
    private readonly scrollElementSubject;
    private checking;
    private readonly scrollElement$;
    private readonly observeElement$;
    items: T[];
    /**
     * Items to lazily append to {@link items}
     */
    source: T[];
    /**
     * How many items to add at the first tick
     * @default 1
     */
    initialSize: number;
    /**
     * How many items to add at once per tick
     * @default 1
     */
    batchSize: number;
    /**
     * How far to preload items. Percentage of scroll elements client height
     * @default 50
     */
    margin: number;
    /**
     * Element to observe for scrolling and load items when at end
     */
    scrollElement: ElementOrElementRef | undefined;
    /**
     * Element to observe for intersection with the scroll element to trigger at tick
     */
    observeElement: ElementOrElementRef | undefined;
    get thresholdReached(): boolean;
    get hasAll(): boolean;
    constructor(elementRef: ElementRef<Node>, changeDetector: ChangeDetectorRef);
    ngAfterViewInit(): void;
    check(): Promise<void>;
    add(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LazyListDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LazyListDirective<any>, "[tslLazyList]", ["lazyList"], { "source": { "alias": "tslLazyList"; "required": false; }; "initialSize": { "alias": "lazyInitialSize"; "required": false; }; "batchSize": { "alias": "lazyBatchSize"; "required": false; }; "margin": { "alias": "lazyMargin"; "required": false; }; "scrollElement": { "alias": "lazyScrollElement"; "required": false; }; "observeElement": { "alias": "lazyObserveElement"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * Lazily render the element when it intersects the viewport (default) or specified {@link root} element.
 * {@link rootMargin} (default 25%) and {@link threshold} (0) can be specified.
 * Uses a div of size {@link intrinsicWidth} and {@link intrinsicHeight} to track visibility using {@link IntersectionObserver}
 */
declare class LazyDirective implements OnDestroy {
    private readonly destroyRef;
    private readonly templateRef;
    private readonly viewContainer;
    private readonly elementRef;
    private readonly renderer;
    private readonly changeDetector;
    private intersectionTracker;
    private initialTemplateView;
    readonly root: i0.InputSignal<Document | Element | null | undefined>;
    readonly rootMargin: i0.InputSignal<string | undefined>;
    readonly threshold: i0.InputSignalWithTransform<number | number[] | null | undefined, number | `${number}` | number[] | null | undefined>;
    readonly intrinsicWidth: i0.InputSignal<string | null | undefined>;
    readonly intrinsicHeight: i0.InputSignal<string | null | undefined>;
    /**
     * Template to render before actual deferred view. Useful for eg. for skeletons.
     * Should be lightweight/fast to render
     */
    readonly initialTemplate: i0.InputSignal<TemplateRef<any> | null | undefined>;
    /**
     * Insert intersection tracker
     * true: insert even if `initialTemplate` is provided,
     * false: only insert if no initialTemplate is provided (default)
     */
    readonly tracker: i0.InputSignalWithTransform<boolean, boolean | "false" | "true">;
    constructor();
    ngOnDestroy(): void;
    private removeTracker;
    static ɵfac: i0.ɵɵFactoryDeclaration<LazyDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LazyDirective, "[tslLazy]", never, { "root": { "alias": "tslLazyRoot"; "required": false; "isSignal": true; }; "rootMargin": { "alias": "tslLazyRootMargin"; "required": false; "isSignal": true; }; "threshold": { "alias": "tslLazyThreshold"; "required": false; "isSignal": true; }; "intrinsicWidth": { "alias": "tslLazyIntrinsicWidth"; "required": false; "isSignal": true; }; "intrinsicHeight": { "alias": "tslLazyIntrinsicHeight"; "required": false; "isSignal": true; }; "initialTemplate": { "alias": "tslLazyInitialTemplate"; "required": false; "isSignal": true; }; "tracker": { "alias": "tslLazyTracker"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

type LetContext<T> = {
    $implicit: LetOutput<T>;
    tslLet: LetOutput<T>;
    isComplete: boolean;
    hasError: boolean;
    error: any;
};
type LetAsyncInput<T> = Observable<T> | AsyncIterable<T> | PromiseLike<T> | ReadableStreamLike<T> | Signal<T>;
type LetInput<T> = LetAsyncInput<T> | T;
type LetOutput<T> = T extends LetAsyncInput<infer U> ? U : T;
declare class LetDirective<T> implements OnDestroy {
    static ngTemplateGuard_tslLet: 'binding';
    private readonly template;
    private readonly viewContainer;
    private readonly changeDetector;
    private readonly injector;
    private readonly errorHandler;
    private readonly inputSubject;
    private readonly viewContext;
    private readonly subscription;
    private embeddedView;
    set tslLet(observableInput: LetInput<T>);
    static ngTemplateContextGuard<T>(_directive: LetDirective<T>, _context: LetContext<T>): _context is LetContext<T>;
    next(value: LetOutput<T>): void;
    error(error: unknown): void;
    complete(): void;
    updateEmbeddedView(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LetDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LetDirective<any>, "[tslLet]", never, { "tslLet": { "alias": "tslLet"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * Wrapper for angulars {@link resource} which raises errors to {@link ErrorHandler}
 * @param options
 * @returns
 */
declare function errorHandledResource<T, R>(options: ResourceOptions<T, R> & {
    defaultValue: NoInfer<T>;
}): ResourceRef<T>;
declare function errorHandledResource<T, R>(options: ResourceOptions<T, R>): ResourceRef<T | undefined>;

type RouteDataDefinition<T extends Record$1> = {
    [P in keyof T]: T[P] | ResolveFn<T>;
};
declare function routeData<T extends Record$1>(definition: RouteDataDefinition<T>): RouteDataDefinition<T>;

declare function numberTransform(value: any): number | null;
declare function booleanTransform(value: any): boolean | null;
declare function numberTransformWithFallback<F>(fallback: F): (value: any) => number | F;
declare function booleanTransformWithFallback<F>(fallback: F): (value: any) => boolean | F;

interface RepeatContext {
    $implicit: number;
    index: number;
}
declare class RepeatDirective extends LifecycleUtils<RepeatDirective> {
    /** how many times to repeat */
    tslRepeat: number;
    constructor(templateRef: TemplateRef<RepeatContext>, viewContainer: ViewContainerRef, changeDetector: ChangeDetectorRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<RepeatDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RepeatDirective, "[tslRepeat]", never, { "tslRepeat": { "alias": "tslRepeat"; "required": false; }; }, {}, never, never, true, never>;
}

declare class VisibilityObserverDirective implements OnDestroy, OnInit, OnChanges {
    private readonly renderer;
    private readonly isVisibleSubject;
    private readonly visibilitySubject;
    private observer;
    readonly elementRef: ElementRef<HTMLElement>;
    readonly isVisible$: Observable<boolean>;
    readonly visibility$: Observable<number>;
    dataAttribute: string | undefined;
    treshold: number;
    margin: string;
    root: HTMLElement | number | null | undefined;
    visible: EventEmitter<ElementRef>;
    isVisibleChanged: EventEmitter<boolean>;
    visibilityChanged: EventEmitter<number>;
    get isVisible(): boolean;
    get visibility(): number;
    constructor(elementRef: ElementRef, renderer: Renderer2);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    onObserve(entries: IntersectionObserverEntry[]): void;
    ngOnDestroy(): void;
    private setupObserver;
    private unobserve;
    static ɵfac: i0.ɵɵFactoryDeclaration<VisibilityObserverDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<VisibilityObserverDirective, "[visibilityObserver]", ["visibilityObserver"], { "dataAttribute": { "alias": "visibilityObserver"; "required": false; }; "treshold": { "alias": "visibilityTreshold"; "required": false; }; "margin": { "alias": "visibilityMargin"; "required": false; }; "root": { "alias": "visibilityRoot"; "required": false; }; }, { "visible": "visible"; "isVisibleChanged": "isVisibleChanged"; "visibilityChanged": "visibilityChanged"; }, never, never, true, never>;
}

declare class AngularHttpClientAdapter implements HttpClientAdapter {
    private readonly angularHttpClient;
    call(request: HttpClientRequest): Promise<HttpClientResponse>;
}
declare function configureAngularHttpClientAdapter(): void;

declare class DateTimeLocalePipe implements PipeTransform {
    transform(input: Date | DateTime | number | null | undefined, format?: keyof typeof DateTime | DateTimeFormatOptions, options?: LocaleOptions): string | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateTimeLocalePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<DateTimeLocalePipe, "dateTimeLocale", true>;
}

declare class DateTimeToDatePipe implements PipeTransform {
    transform(value: DateTime | null | undefined): Date | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateTimeToDatePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<DateTimeToDatePipe, "dateTimeToDate", true>;
}

declare class DateTimePipe implements PipeTransform {
    transform(input: Date | DateTime | number | null | undefined, format: string, options?: DateTimeFormatOptions): string | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateTimePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<DateTimePipe, "dateTime", true>;
}

declare class DecyclePipe implements PipeTransform {
    transform(value: unknown, replacer?: (value: any) => any): unknown;
    static ɵfac: i0.ɵɵFactoryDeclaration<DecyclePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<DecyclePipe, "decycle", true>;
}

declare class DurationPipe implements PipeTransform {
    transform(millisecondsOrObject: number | Duration | DurationObjectUnits | null | undefined, format: string, options?: DurationOptions, formatOptions?: Parameters<Duration['toFormat']>[1]): string | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<DurationPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<DurationPipe, "duration", true>;
}

declare class DynamicTextPipe implements PipeTransform {
    #private;
    transform(value: DynamicText | null | undefined): string | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicTextPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<DynamicTextPipe, "dynamicText", true>;
}

declare class LocalizeEnumPipe implements PipeTransform {
    #private;
    transform<T extends Enumeration>(enumeration: T, parameters?: unknown): string | null;
    transform<T extends Enumeration>(value: EnumerationValue<T> | null | undefined, enumeration: T, parameters?: unknown): string | null;
    private updateInputs;
    static ɵfac: i0.ɵɵFactoryDeclaration<LocalizeEnumPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<LocalizeEnumPipe, "localizeEnum", true>;
}

declare class LocalizePipe implements PipeTransform {
    #private;
    transform(localizationKey: LocalizationKey | null | undefined): string | null;
    transform<Parameters>(localizationData: LocalizationData<Parameters> | null | undefined): string | null;
    transform<Parameters>(localizationKey: LocalizationKey<Parameters> | null | undefined, parameters: Parameters): string | null;
    private updateInputs;
    static ɵfac: i0.ɵɵFactoryDeclaration<LocalizePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<LocalizePipe, "localize", true>;
}

declare class NumberLocalePipe implements PipeTransform {
    transform(value: number | null | undefined, locales: string | string[], options?: Intl.NumberFormatOptions): string | null;
    transform(value: number | null | undefined, options?: Intl.NumberFormatOptions | null): string | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<NumberLocalePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<NumberLocalePipe, "numberLocale", true>;
}

declare class NumericDateToDateTimePipe implements PipeTransform {
    transform(value: number | null | undefined, options?: DateTimeJSOptions): DateTime | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<NumericDateToDateTimePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<NumericDateToDateTimePipe, "numericDateToDateTime", true>;
}

declare class NumericTimeToDateTimePipe implements PipeTransform {
    transform(numericTime: number | null | undefined, options?: DateTimeJSOptions): DateTime | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<NumericTimeToDateTimePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<NumericTimeToDateTimePipe, "numericTimeToDateTime", true>;
}

declare class OptionalLocalizePipe extends LocalizePipe implements PipeTransform {
    transform(localizationKeyOrString: LocalizationKey | string | null | undefined): string | null;
    transform<Parameters>(localizationDataOrString: LocalizationData<Parameters> | string | null | undefined): string | null;
    transform<Parameters>(localizationKeyOrString: LocalizationKey<Parameters> | string | null | undefined, parameters: Parameters): string | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<OptionalLocalizePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<OptionalLocalizePipe, "optionalLocalize", true>;
}

declare class PadPipe implements PipeTransform {
    transform(input: string | number, length: number, fillString?: string | number, position?: 'start' | 'end'): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<PadPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<PadPipe, "pad", true>;
}

declare class SafeHtmlPipe implements PipeTransform {
    private readonly domSanitizer;
    constructor(domSanitizer: DomSanitizer);
    transform(html: string | null | undefined): SafeHtml | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<SafeHtmlPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SafeHtmlPipe, "safeHtml", true>;
}

declare class SafeResourceUrlPipe implements PipeTransform {
    private readonly domSanitizer;
    constructor(domSanitizer: DomSanitizer);
    transform(url: string | null | undefined): SafeResourceUrl | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<SafeResourceUrlPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SafeResourceUrlPipe, "safeResourceUrl", true>;
}

declare class SafeUrlPipe implements PipeTransform {
    private readonly domSanitizer;
    constructor(domSanitizer: DomSanitizer);
    transform(url: string | null | undefined): SafeUrl | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<SafeUrlPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SafeUrlPipe, "safeUrl", true>;
}

declare class SanitizePipe implements PipeTransform {
    private readonly domSanitizer;
    constructor(domSanitizer: DomSanitizer);
    transform(url: string | SafeValue | null | undefined, context: SecurityContext): string | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<SanitizePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SanitizePipe, "sanitize", true>;
}

declare class SerializePipe implements PipeTransform {
    transform(value: unknown, options?: SerializationOptions): unknown;
    static ɵfac: i0.ɵɵFactoryDeclaration<SerializePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SerializePipe, "serialize", true>;
}

declare class ToObservablePipe implements PipeTransform {
    private readonly injector;
    private source;
    private observable;
    transform<T>(source: Signal<T>): Observable<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToObservablePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ToObservablePipe, "toObservable", true>;
}

declare class AppStabilizationService {
    private readonly applicationRef;
    private readonly ngZone;
    readonly state$: Observable<boolean>;
    constructor(applicationRef: ApplicationRef, ngZone: NgZone);
    wait$(state?: boolean): Observable<void>;
    wait(state?: boolean): Promise<void>;
    private getStateObservable;
    static ɵfac: i0.ɵɵFactoryDeclaration<AppStabilizationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AppStabilizationService>;
}

declare class ApplicationTickService {
    private readonly applicationRef;
    private scheduled;
    schedule(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationTickService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApplicationTickService>;
}

declare class ErrorHandlerServiceOptions {
    format?: FormatErrorOptions;
}
declare abstract class ErrorHandlerMessageService {
    #private;
    private readonly format;
    getErrorMessage(error: unknown): {
        header?: DynamicText;
        message: DynamicText;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorHandlerMessageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ErrorHandlerMessageService>;
}

declare class ErrorHandlerService implements ErrorHandler {
    private readonly notificationService;
    private readonly errorHandlerMessageService;
    private readonly logger;
    private readonly errorSubject;
    private readonly notifiedErrors;
    readonly error$: rxjs.Observable<any>;
    handleError$<T>(): OperatorFunction<T, T>;
    handleError(error: unknown): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorHandlerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ErrorHandlerService>;
}

type MessageBoxInputs = Record$1<string, MessageBoxInput>;
type MessageBoxResult<T = any, I extends MessageBoxInputs = MessageBoxInputs, D = undefined> = {
    dismissed: false;
    actionValue: T;
    inputs: MessageBoxInputsOutput<I>;
} | {
    dismissed: true;
    actionValue: D;
    inputs: MessageBoxInputsOutput<I>;
};
type MessageBoxInputsOutput<T extends MessageBoxInputs> = {
    [P in keyof T]: T[P]['required'] extends true ? MessageBoxInputOutput<T[P]> : (MessageBoxInputOutput<T[P]> | null);
};
type MessageBoxInputOutput<T extends MessageBoxInput> = T extends (MessageBoxTextInput | MessageBoxTextAreaInput) ? string : T extends MessageBoxSelectInput<infer U> ? U : never;
type MessageBoxAction<T = any, I extends MessageBoxInputs = MessageBoxInputs> = {
    text: DynamicText;
    value?: T;
    disableOnInvalidInputs?: boolean;
    handler?: (value: T, inputs: MessageBoxInputsOutput<I>) => any | Promise<any>;
};
type NotificationType = 'info' | 'success' | 'warning' | 'error';
type MessageBoxInputBase<Type extends string> = {
    type: Type;
    enabled?: boolean;
    required?: boolean;
};
type MessageBoxTextInput = MessageBoxInputBase<'text'> & {
    inputType?: InputType;
    mode?: InputMode;
    label?: DynamicText;
    placeholder?: DynamicText;
    initialValue?: any;
    pattern?: string | RegExp;
    attributes?: TypedOmit<InputAttributes, 'type' | 'mode' | 'placeholder' | 'required' | 'value' | 'pattern'>;
    validator?: (value: any) => boolean;
};
type MessageBoxTextAreaInput = MessageBoxInputBase<'text-area'> & {
    label?: DynamicText;
    placeholder?: DynamicText;
    initialValue?: any;
    pattern?: string | RegExp;
    attributes?: TypedOmit<TextAreaAttributes, 'placeholder' | 'required'>;
    validator?: (value: any) => boolean;
};
type MessageBoxSelectInputItem<T> = {
    label: DynamicText;
    value: T;
};
type MessageBoxSelectInput<T> = MessageBoxInputBase<'select'> & {
    items: MessageBoxSelectInputItem<T>[];
    label?: DynamicText;
    initialValue?: T;
};
type MessageBoxInput<T = any> = MessageBoxTextInput | MessageBoxTextAreaInput | MessageBoxSelectInput<T>;
type MessageBoxData<T = any, I extends MessageBoxInputs = MessageBoxInputs, D = undefined> = {
    type?: NotificationType;
    header?: DynamicText;
    subHeader?: DynamicText;
    message?: DynamicText;
    actions?: MessageBoxAction<T, I>[];
    inputs?: I;
    dismiss?: D;
};
type NotifyData = {
    type?: NotificationType;
    header?: DynamicText;
    message: DynamicText;
    duration?: number;
};
declare abstract class NotificationService {
    abstract openMessageBox<T = never, I extends MessageBoxInputs = Record$1<never>, D = undefined>(data: MessageBoxData<T, I, D>): Promise<MessageBoxResult<T, I, D>>;
    abstract notify(data: NotifyData): void;
}
declare function messageBoxTextInput<T extends TypedOmit<MessageBoxTextInput, 'type'>>(input: T): SimplifyObject<{
    type: 'text';
} & T>;
declare function messageBoxTextAreaInput<T extends TypedOmit<MessageBoxTextAreaInput, 'type'>>(input: T): SimplifyObject<{
    type: 'text-area';
} & T>;
declare function messageBoxSelectInput<T, U extends TypedOmit<MessageBoxSelectInput<T>, 'type'>>(input: U): SimplifyObject<{
    type: 'select';
} & U>;
declare function isMessageBoxTextInput(input: MessageBoxInput): input is MessageBoxTextInput;
declare function isMessageBoxTextAreaInput(input: MessageBoxInput): input is MessageBoxTextAreaInput;
declare function isMessageBoxSelectInput<T>(input: MessageBoxInput<T>): input is MessageBoxSelectInput<T>;

type TransformOptions<T extends string | string[] | null, TTransform> = {
    transform?: ((value: T) => TTransform) | {
        fromString: (value: T) => TTransform;
        toString?: (value: TTransform) => T;
    };
};
type WithTransformOptions<T extends string | string[] | null, TTransform> = Required<TransformOptions<T, TTransform>>;
type WithoutTransformOptions = TypedOmit<TransformOptions<string, undefined>, 'transform'> & {
    transform?: undefined;
};
type InjectParameterOptions = {
    optional?: boolean;
};
declare class RoutingService {
    readonly router: Router;
    readonly route: ActivatedRoute;
    setQueryParameter(key: string, value: string | string[] | null): Promise<void>;
    setQueryParameters(parameters: Record$1<string, string | string[] | null>, options?: Pick<NavigationExtras, 'queryParamsHandling'>): Promise<void>;
    setFragment(value: string | null): Promise<void>;
}
declare function injectRoutingService(): RoutingService;
declare function injectParameter<T extends string>(parameter: string, options: InjectParameterOptions & {
    optional: true;
}): Signal<SimplifiedLiteralUnion<T> | null>;
declare function injectParameter<T extends string>(parameter: string, options?: InjectParameterOptions & {
    optional?: false;
}): Signal<SimplifiedLiteralUnion<T>>;
declare function injectParameter$<T extends string>(parameter: string, options: InjectParameterOptions & {
    optional: true;
}): Observable<SimplifiedLiteralUnion<T> | null>;
declare function injectParameter$<T extends string>(parameter: string, options?: InjectParameterOptions & {
    optional?: false;
}): Observable<SimplifiedLiteralUnion<T>>;
declare function injectParameter$<T extends string>(parameter: string, options?: InjectParameterOptions): Observable<SimplifiedLiteralUnion<T> | null>;
declare function injectParameters<T extends string>(parameter: string): Signal<SimplifiedLiteralUnion<T>[]>;
declare function injectParameters$<T extends string>(parameter: string): Observable<SimplifiedLiteralUnion<T>[]>;
declare function injectQueryParameter<T extends string, TTransform>(parameter: string, options: WithTransformOptions<SimplifiedLiteralUnion<T> | null, TTransform>): WritableSignal<TTransform>;
declare function injectQueryParameter<T extends string>(parameter: string, options?: WithoutTransformOptions): WritableSignal<SimplifiedLiteralUnion<T> | null>;
declare function injectQueryParameter$<T extends string>(parameter: string): Observable<SimplifiedLiteralUnion<T> | null>;
declare function injectQueryParameters<T extends string, TTransform>(parameter: string, options: WithTransformOptions<SimplifiedLiteralUnion<T>[], TTransform>): WritableSignal<TTransform>;
declare function injectQueryParameters<T extends string>(parameter: string, options?: WithoutTransformOptions): WritableSignal<SimplifiedLiteralUnion<T>[]>;
declare function injectQueryParameters$<T extends string>(parameter: string): Observable<SimplifiedLiteralUnion<T>[]>;
declare function injectFragmet(): WritableSignal<string | null>;
declare function injectFragmet$(): Observable<string | null>;
declare function injectRouteData<T extends Record$1 = Record$1>(): Signal<T>;
declare function injectRouteData$<T extends Record$1 = Record$1>(): Observable<T>;

declare class TstdlBridgeServiceOptions {
    debugInjectorWrapper?: boolean;
}
declare class TstdlAngularModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TstdlAngularModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TstdlAngularModule, never, [typeof DateTimeLocalePipe, typeof DateTimePipe, typeof DateTimeToDatePipe, typeof DecyclePipe, typeof DurationPipe, typeof DynamicTextPipe, typeof LocalizeEnumPipe, typeof LocalizePipe, typeof NumberLocalePipe, typeof NumericDateToDateTimePipe, typeof NumericTimeToDateTimePipe, typeof OptionalLocalizePipe, typeof PadPipe, typeof SafeHtmlPipe, typeof SafeResourceUrlPipe, typeof SafeUrlPipe, typeof SerializePipe, typeof AutoForDirective, typeof AutoIdDirective, typeof InputPatternDirective, typeof LazyDirective, typeof LazyListDirective, typeof LetDirective, typeof RepeatDirective, typeof VisibilityObserverDirective, typeof TstdlSkeletonComponent, typeof TstdlIndeterminateProgressBarComponent, typeof TstdlColoredProgressbarComponent], [typeof DateTimeLocalePipe, typeof DateTimePipe, typeof DateTimeToDatePipe, typeof DecyclePipe, typeof DurationPipe, typeof DynamicTextPipe, typeof LocalizeEnumPipe, typeof LocalizePipe, typeof NumberLocalePipe, typeof NumericDateToDateTimePipe, typeof NumericTimeToDateTimePipe, typeof OptionalLocalizePipe, typeof PadPipe, typeof SafeHtmlPipe, typeof SafeResourceUrlPipe, typeof SafeUrlPipe, typeof SerializePipe, typeof AutoForDirective, typeof AutoIdDirective, typeof InputPatternDirective, typeof LazyDirective, typeof LazyListDirective, typeof LetDirective, typeof RepeatDirective, typeof VisibilityObserverDirective, typeof TstdlSkeletonComponent, typeof TstdlIndeterminateProgressBarComponent, typeof TstdlColoredProgressbarComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TstdlAngularModule>;
}
declare function provideTstdlAngular(...providers: Tagged<Provider, 'tstdl-angular'>[][]): EnvironmentProviders;
declare function withTstdlBridgeServiceOptions(options: TstdlBridgeServiceOptions): Tagged<Provider, 'tstdl-angular'>[];

declare module '@tstdl/base/signals' {
    interface Signal<T> {
        (): T;
        [SIGNAL]: unknown;
    }
}

declare function waitForAppStabilization<T>(appStabilizationService: AppStabilizationService): MonoTypeOperatorFunction<T>;

declare function runInZone<T>(zone: NgZone): MonoTypeOperatorFunction<T>;
declare function runOutsideAngular<T>(zone: NgZone): MonoTypeOperatorFunction<T>;
declare function runTaskInZone<T>(zone: NgZone): MonoTypeOperatorFunction<T>;
declare function runGuardedInZone<T>(zone: NgZone): MonoTypeOperatorFunction<T>;

export { AngularHttpClientAdapter, AppStabilizationService, ApplicationTickService, AutoForDirective, AutoIdDirective, DateInputControlValueAccessor, DateTimeLocalePipe, DateTimePipe, DateTimeToDatePipe, DecyclePipe, DragDirective, DropDirective, DurationPipe, DynamicTextPipe, ErrorHandlerMessageService, ErrorHandlerService, ErrorHandlerServiceOptions, FilterHelperDirective, InputPatternDirective, LazyDirective, LazyListDirective, LetDirective, LifecycleUtils, LocalizeEnumPipe, LocalizePipe, NotificationService, NumberLocalePipe, NumericDateToDateTimePipe, NumericTimeToDateTimePipe, OptionalLocalizePipe, PadPipe, RepeatDirective, RoutingService, SafeHtmlPipe, SafeResourceUrlPipe, SafeUrlPipe, SanitizePipe, SerializePipe, ToObservablePipe, TstdlAngularModule, TstdlBridgeServiceOptions, TstdlColoredProgressbarComponent, TstdlIndeterminateProgressBarComponent, TstdlMarkdownComponent, TstdlSkeletonComponent, VisibilityObserverDirective, booleanTransform, booleanTransformWithFallback, collapseAnimation, configureAngularHttpClientAdapter, fadeInOutAnimation, getAnimateTimings, getApiService, heightAnimation, injectFragmet, injectFragmet$, injectParameter, injectParameter$, injectParameters, injectParameters$, injectQueryParameter, injectQueryParameter$, injectQueryParameters, injectQueryParameters$, injectRouteData, injectRouteData$, injectRoutingService, isMessageBoxSelectInput, isMessageBoxTextAreaInput, isMessageBoxTextInput, messageBoxSelectInput, messageBoxTextAreaInput, messageBoxTextInput, numberTransform, numberTransformWithFallback, provideTstdlAngular, errorHandledResource as resource, routeData, runGuardedInZone, runInZone, runOutsideAngular, runTaskInZone, slideInOutAnimation, waitForAppStabilization, widthAnimation, withTstdlBridgeServiceOptions };
export type { AnimationOptions, CollapseAnimationOptions, InjectParameterOptions, LetContext, MessageBoxAction, MessageBoxData, MessageBoxInput, MessageBoxInputOutput, MessageBoxInputs, MessageBoxInputsOutput, MessageBoxResult, MessageBoxSelectInput, MessageBoxSelectInputItem, MessageBoxTextAreaInput, MessageBoxTextInput, NotificationType, NotifyData, RepeatContext, RouteDataDefinition, TransformOptions, TypedSimpleChange };