import dayjs, { Dayjs } from 'dayjs';
import { SelectionModel } from '@angular/cdk/collections';
import * as i0 from '@angular/core';
import { Signal, Injector, InjectionToken, Provider } from '@angular/core';
import { AbstractControl } from '@angular/forms';
import { Observable } from 'rxjs';
import { ActivatedRoute, Params, ParamMap, NavigationExtras, ActivatedRouteSnapshot, RouterStateSnapshot, Routes } from '@angular/router';
import { Type, BaseResolver } from '@nx-ddd/common/domain';
import { DateAdapter, MatDateFormats } from '@angular/material/core';
import { PageEvent } from '@angular/material/paginator';

declare const comma: (n: number | null) => string;
declare const commaStr: (n: number, unit?: string) => string;
declare const abs: (n: number) => number;

type HasId = {
    id: string;
};
declare function compareByIdFactory(key: string): (a: any, b: any) => number;
declare const compareById: (a: any, b: any) => number;

declare const removeComma: (str: string) => string;
declare const DATE_FORMAT = "YYYY-MM-DDTHH:mm:ss";
declare const isDateStr: (str: string | null) => str is string;
declare const isDateTimeStr: (str: string | null) => str is string;
declare const isIsoString: (str: string | null) => str is string;
interface Timestamp {
    toDate: () => Date;
}
declare function timestampToDayjs(timestamp: Timestamp | null): dayjs.Dayjs | null;

declare function diff<T = any>(initial: SelectionModel<T>, current: SelectionModel<T>): {
    selectedIds: T[];
    unselectedIds: T[];
};

declare function getValue$<T>(control: AbstractControl<T>): Observable<T>;
declare function getValue<T>(control: AbstractControl<T>): Signal<T>;
declare function getRawValue$<T>(control: AbstractControl<T>): Observable<T>;
declare function getRawValue<T>(control: AbstractControl<T>): Signal<T>;
declare function computedRawValue<T>(controlFactory: () => AbstractControl<T>): Signal<T>;
declare function getInvalid$<T>(control: AbstractControl<T>): Observable<boolean>;
declare function getInvalid<T>(form: AbstractControl<T>): Signal<boolean>;

type PathKeys<T> = T extends object ? {
    [K in keyof T]-?: K extends string | number ? T[K] extends object ? [K] | [K, ...PathKeys<T[K]>] : [K] : never;
}[keyof T] : [];
type NestedGetType<T, P extends any[]> = P extends [infer F, ...infer R] ? F extends keyof T ? NestedGetType<T[F], R> : never : T;
declare function get<T, P extends PathKeys<T>>(obj: T, path: P): NestedGetType<T, P>;

declare function injectRouterParam$(key: string): Observable<string>;
declare function injectRouterParam(key: string): Signal<string>;
declare function injectRouteParams$({ merge, route, }?: {
    merge?: boolean;
    route?: ActivatedRoute;
}): Observable<Params>;
declare function injectUnflattenRouteParams$({ merge, route, }?: {
    merge?: boolean;
    route?: ActivatedRoute;
}): Observable<any>;
declare function injectUnflattenRouteParam$<T = any>(key?: string): Observable<T>;
declare function injectUnflattenRouteParam<T = any>(key?: string): Signal<T>;
declare function injectUnflattenRouteParams({ merge, }?: {
    merge?: boolean;
}): Signal<any>;
declare function injectRouteParamMap$({ merge, }?: {
    merge?: boolean;
}): Observable<ParamMap>;
declare function injectRouteParamMap({ merge, }?: {
    merge?: boolean;
}): Signal<ParamMap>;
declare function injectRouteParams({ merge, }?: {
    merge?: boolean;
}): Signal<Record<string, string>>;
declare function injectRouteParam$(key: string, { merge, }?: {
    merge?: boolean;
}): Observable<string>;
declare function injectRouteParam(key: string, injector?: i0.Injector): Signal<string>;
declare function injectRouteSkip$(): Observable<boolean>;
declare function injectRouteSkip(): Signal<boolean>;

declare function injectRouteQueryParam$<T extends string = string>(key: string): Observable<T>;
declare function injectRouteQueryParam(key: string): Signal<string>;
declare function injectRouterQueryParam$<T extends string = string>(key: string): Observable<T>;
declare function injectRouterQueryParam<T extends string = string>(key: string): Signal<T>;

declare function injectRouteNavigated$(): Observable<ActivatedRoute>;
declare function injectRouteNavigated(): Signal<ActivatedRoute | undefined>;
declare function injectPrimaryPaths$(): Observable<(string | null)[]>;
declare function injectPrimaryPaths(): Signal<(string | null)[] | undefined>;
declare function injectChildRouteParam$(key: string): Observable<string>;
declare function injectChildRouteParam(key: string): Signal<string>;
declare function injectChildRoute$(): Observable<ActivatedRoute>;
declare function injectChildRoute(): Signal<ActivatedRoute>;
declare function injectHasNext$(): Observable<boolean>;
declare function injectHasNext(): Signal<boolean | undefined>;
declare function injectNavigationExtras(): Signal<NavigationExtras>;

declare function injectRouteData$<T>(path: string): Observable<T>;
declare function injectRouteData<T>(key: string): Signal<T>;
declare function injectRouteDataSnapshot<T>(key: string): Signal<T>;
declare function injectActivatedComponents(injector?: Injector): any[];

interface Resolver<T> {
    resolve(entry: T): T;
    resolveMany(entities: T[]): T[];
}
declare function provideResolver(Entity: Type<{
    id: string;
}>, ResolverType: new (params: Record<string, Observable<any>>) => Resolver<any>): {
    provide: Type<{
        id: string;
    }>;
    deps: never[];
    multi: boolean;
};
declare class ResolverManager {
    protected map: Map<string, Resolver<any>>;
    get(Entity: Type<{
        id: string;
    }>): Resolver<any> | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResolverManager, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ResolverManager>;
}
declare function injectResolver$<T>(ResolverType: Type<BaseResolver<T>>, params: Record<string, Observable<any>>): Observable<BaseResolver<T>>;
declare function getResolver<T>(ResolverType: new (params: Record<string, any>) => Resolver<T>, params: Record<string, any>): Resolver<T>;

interface DayJsDateAdapterOptions {
    useUtc?: boolean;
}
declare const MAT_DAYJS_DATE_ADAPTER_OPTIONS: InjectionToken<DayJsDateAdapterOptions>;
declare function MAT_DAYJS_DATE_ADAPTER_OPTIONS_FACTORY(): DayJsDateAdapterOptions;
declare class DayjsDateAdapter extends DateAdapter<Dayjs> {
    dateLocale: string;
    private options?;
    private localeData;
    constructor(dateLocale: string, options?: DayJsDateAdapterOptions | undefined);
    setLocale(locale: string): void;
    getYear(date: Dayjs): number;
    getMonth(date: Dayjs): number;
    getDate(date: Dayjs): number;
    getDayOfWeek(date: Dayjs): number;
    getMonthNames(style: 'long' | 'short' | 'narrow'): string[];
    getDateNames(): string[];
    getDayOfWeekNames(style: 'long' | 'short' | 'narrow'): string[];
    getYearName(date: Dayjs): string;
    getFirstDayOfWeek(): number;
    getNumDaysInMonth(date: Dayjs): number;
    clone(date: Dayjs): Dayjs;
    createDate(year: number, month: number, date: number): Dayjs;
    today(): Dayjs;
    parse(value: any, parseFormat: string): Dayjs | null;
    format(date: Dayjs, displayFormat: string): string;
    addCalendarYears(date: Dayjs, years: number): Dayjs;
    addCalendarMonths(date: Dayjs, months: number): Dayjs;
    addCalendarDays(date: Dayjs, days: number): Dayjs;
    toIso8601(date: Dayjs): string;
    deserialize(value: any): Dayjs | null;
    isDateInstance(obj: any): boolean;
    isValid(date: Dayjs): boolean;
    invalid(): Dayjs;
    private dayJs;
    private get shouldUseUtc();
    private initializeParser;
}

declare const MAT_DAYJS_DATE_FORMATS: MatDateFormats;

declare const MAT_DAYJS_DATE_FORMATS_FOR_JP: MatDateFormats;
declare const MAT_DAYJS_JP_PROVIDERS: ({
    provide: i0.InjectionToken<{}>;
    useValue: string;
} | {
    provide: i0.InjectionToken<MatDateFormats>;
    useValue: MatDateFormats;
})[];

declare const MAT_DATE_FNS_DATE_FORMATS: MatDateFormats;
declare class DayjsDateModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DayjsDateModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DayjsDateModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DayjsDateModule>;
}
declare function provideDayjsDateAdapter(): Provider[];

interface Page extends PageEvent {
    sortKey: string;
    sortOrder: 'asc' | 'desc';
}
declare class Page {
    static from(event?: Partial<Page>): Page;
    get start(): number;
    get end(): number;
    patch(obj: Partial<Page>): Page;
}

declare function walkActivatedRouteSnapshot(snapshot: ActivatedRouteSnapshot, callback: (snapshot: ActivatedRouteSnapshot) => boolean, target?: 'children' | 'parent'): void;
declare function skippedResolver(outlet?: string): (route: ActivatedRouteSnapshot, snapshot: RouterStateSnapshot) => boolean;
declare function wrapRoutes(routes: Routes): Routes;

declare const yenTransform: (value: number, _unit?: string) => string;
type ExpressionTransformer = (value: string | number | dayjs.Dayjs | any, context?: any) => string;
declare const defaultExpressionTransformer: ExpressionTransformer;
declare const EXPRESSION_TRANSFORMER: InjectionToken<ExpressionTransformer>;
declare function provideExpressionTransformer(useFactory: () => ExpressionTransformer): {
    provide: InjectionToken<ExpressionTransformer>;
    useFactory: () => ExpressionTransformer;
};
declare function injectParentExpressionTransformer(): ExpressionTransformer;
declare const smartExpTransformer: ExpressionTransformer;

declare const toObject: (obj: object) => object;

declare function formatSeconds(seconds: number): string;

export { DATE_FORMAT, DayjsDateAdapter, DayjsDateModule, EXPRESSION_TRANSFORMER, MAT_DATE_FNS_DATE_FORMATS, MAT_DAYJS_DATE_ADAPTER_OPTIONS, MAT_DAYJS_DATE_ADAPTER_OPTIONS_FACTORY, MAT_DAYJS_DATE_FORMATS, MAT_DAYJS_DATE_FORMATS_FOR_JP, MAT_DAYJS_JP_PROVIDERS, Page, ResolverManager, abs, comma, commaStr, compareById, compareByIdFactory, computedRawValue, defaultExpressionTransformer, diff, formatSeconds, get, getInvalid, getInvalid$, getRawValue, getRawValue$, getResolver, getValue, getValue$, injectActivatedComponents, injectChildRoute, injectChildRoute$, injectChildRouteParam, injectChildRouteParam$, injectHasNext, injectHasNext$, injectNavigationExtras, injectParentExpressionTransformer, injectPrimaryPaths, injectPrimaryPaths$, injectResolver$, injectRouteData, injectRouteData$, injectRouteDataSnapshot, injectRouteNavigated, injectRouteNavigated$, injectRouteParam, injectRouteParam$, injectRouteParamMap, injectRouteParamMap$, injectRouteParams, injectRouteParams$, injectRouteQueryParam, injectRouteQueryParam$, injectRouteSkip, injectRouteSkip$, injectRouterParam, injectRouterParam$, injectRouterQueryParam, injectRouterQueryParam$, injectUnflattenRouteParam, injectUnflattenRouteParam$, injectUnflattenRouteParams, injectUnflattenRouteParams$, isDateStr, isDateTimeStr, isIsoString, provideDayjsDateAdapter, provideExpressionTransformer, provideResolver, removeComma, skippedResolver, smartExpTransformer, timestampToDayjs, toObject, walkActivatedRouteSnapshot, wrapRoutes, yenTransform };
export type { DayJsDateAdapterOptions, ExpressionTransformer, HasId, NestedGetType, PathKeys, Resolver, Timestamp };