import * as i0 from '@angular/core';
import { PipeTransform } from '@angular/core';

declare class DiffPipe implements PipeTransform {
    transform<T extends any[]>(input: T, ...args: T[]): T;
    transform<T>(input: T, ...args: any[]): T;
    static ɵfac: i0.ɵɵFactoryDeclaration<DiffPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<DiffPipe, "diff", true>;
}

declare class FlattenPipe implements PipeTransform {
    transform<T extends any[]>(input: T, shallow?: boolean): any[];
    transform<T>(input: T, shallow?: boolean): T;
    private flatten;
    static ɵfac: i0.ɵɵFactoryDeclaration<FlattenPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FlattenPipe, "flatten", true>;
}

declare class InitialPipe implements PipeTransform {
    transform<T extends any[]>(input: T, num?: number): T;
    transform<T>(input: T, num?: number): T;
    static ɵfac: i0.ɵɵFactoryDeclaration<InitialPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<InitialPipe, "initial", true>;
}

declare class SlicePipe implements PipeTransform {
    transform<T extends any[]>(input: T, start?: number, end?: number): T;
    transform<T>(input: T, start?: number, end?: number): T;
    static ɵfac: i0.ɵɵFactoryDeclaration<SlicePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SlicePipe, "sliceSafe", true>;
}

declare class IntersectionPipe implements PipeTransform {
    transform<T extends any[]>(input: T, ...args: T): T;
    transform<T>(input: T, ...args: any[]): T;
    static ɵfac: i0.ɵɵFactoryDeclaration<IntersectionPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IntersectionPipe, "intersection", true>;
}

declare class ReversePipe implements PipeTransform {
    transform<T extends any[]>(input: T): T;
    transform<T>(input: T): T;
    static ɵfac: i0.ɵɵFactoryDeclaration<ReversePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ReversePipe, "reverse", true>;
}

declare class TailPipe implements PipeTransform {
    transform<T extends any[]>(input: T, num?: number): T;
    transform<T>(input: T, num?: number): T;
    static ɵfac: i0.ɵɵFactoryDeclaration<TailPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<TailPipe, "tail", true>;
}

declare class TrurthifyPipe implements PipeTransform {
    transform<T extends any[]>(input: T): T;
    transform<T>(input: T): T;
    static ɵfac: i0.ɵɵFactoryDeclaration<TrurthifyPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<TrurthifyPipe, "truthify", true>;
}

declare class UnionPipe implements PipeTransform {
    transform<T extends any[]>(input: T, args: T): T;
    transform<T>(input: T, args?: T): T;
    static ɵfac: i0.ɵɵFactoryDeclaration<UnionPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<UnionPipe, "union", true>;
}

declare class UniquePipe implements PipeTransform {
    transform<T extends any[]>(input: T, propertyName: string): T;
    transform<T>(input: T, propertyName?: string): T;
    static ɵfac: i0.ɵɵFactoryDeclaration<UniquePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<UniquePipe, "unique", true>;
}

declare class WithoutPipe implements PipeTransform {
    transform<T extends any[]>(input: T, args: T): T;
    transform<T>(input: T, args?: T): T;
    static ɵfac: i0.ɵɵFactoryDeclaration<WithoutPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<WithoutPipe, "without", true>;
}

type GenericRecord<T> = Record<string | number | symbol, T>;

declare class PluckPipe implements PipeTransform {
    transform<T extends GenericRecord<any>[]>(input: T, map: string): any[];
    transform<T extends GenericRecord<any>>(input: T, map: string): any;
    transform<T>(input: T, map?: string): T;
    static ɵfac: i0.ɵɵFactoryDeclaration<PluckPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<PluckPipe, "pluck", true>;
}

declare class ShufflePipe implements PipeTransform {
    transform<T extends any[]>(input: T): T;
    transform<T>(input: T): T;
    static ɵfac: i0.ɵɵFactoryDeclaration<ShufflePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ShufflePipe, "shuffle", true>;
}

declare class EveryPipe implements PipeTransform {
    transform<T extends any[]>(input: T, predicate?: Predicate$1): boolean;
    transform<T>(input: T, predicate?: Predicate$1): false;
    static ɵfac: i0.ɵɵFactoryDeclaration<EveryPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<EveryPipe, "every", true>;
}
type Predicate$1 = (value: any, index: number, array: any[]) => boolean;

declare class SomePipe implements PipeTransform {
    transform<T extends any[]>(input: T, predicate?: Predicate): boolean;
    transform<T>(input: T, predicate?: Predicate): T;
    static ɵfac: i0.ɵɵFactoryDeclaration<SomePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SomePipe, "some", true>;
}
type Predicate = (value: any, index: number, array: any[]) => boolean;

declare class SamplePipe implements PipeTransform {
    transform<T extends any[]>(input: T, len?: number): T;
    transform<T>(input: T, len?: number): T;
    static ɵfac: i0.ɵɵFactoryDeclaration<SamplePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SamplePipe, "sample", true>;
}

declare class GroupByPipe implements PipeTransform {
    transform<T extends any[]>(input: T, discriminator?: any, delimiter?: string): GenericRecord<T>;
    transform<T>(input: T, discriminator?: any, delimiter?: string): T;
    private groupBy;
    private extractKeyByDiscriminator;
    static ɵfac: i0.ɵɵFactoryDeclaration<GroupByPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<GroupByPipe, "groupBy", true>;
}

declare class GroupByImpurePipe extends GroupByPipe implements PipeTransform {
    static ɵfac: i0.ɵɵFactoryDeclaration<GroupByImpurePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<GroupByImpurePipe, "groupByImpure", true>;
}

declare class FilterByPipe implements PipeTransform {
    transform<K, T extends K[]>(input: T, props: string[], search?: any, strict?: boolean): T;
    transform<T>(input: T, props?: string[], search?: any, strict?: boolean): T;
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterByPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FilterByPipe, "filterBy", true>;
}

declare class FilterByImpurePipe extends FilterByPipe implements PipeTransform {
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterByImpurePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FilterByImpurePipe, "filterByImpure", true>;
}

declare class OrderByPipe implements PipeTransform {
    transform<T extends any[]>(input: T, config: any): T;
    transform<T>(input: T, config?: any): T;
    private static simpleSort;
    private static orderCompare;
    private static extractFromConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<OrderByPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<OrderByPipe, "orderBy", true>;
}

declare class OrderByImpurePipe extends OrderByPipe implements PipeTransform {
    static ɵfac: i0.ɵɵFactoryDeclaration<OrderByImpurePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<OrderByImpurePipe, "orderByImpure", true>;
}

declare class RangePipe implements PipeTransform {
    transform(start: number, count: number, step?: number): number[];
    transform(start?: number, count?: number, step?: number): [];
    static ɵfac: i0.ɵɵFactoryDeclaration<RangePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<RangePipe, "range", true>;
}

declare class ChunkPipe implements PipeTransform {
    transform<T extends any[]>(input: T, size?: number): T[];
    transform<T extends string>(input: T, size?: number): string[][];
    transform<T>(input: T, size?: number): T;
    private chunk;
    static ɵfac: i0.ɵɵFactoryDeclaration<ChunkPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ChunkPipe, "chunk", true>;
}

declare class FromPairsPipe implements PipeTransform {
    transform<T extends any[]>(input: T): GenericRecord<any>;
    transform<T>(input: T): T;
    static ɵfac: i0.ɵɵFactoryDeclaration<FromPairsPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FromPairsPipe, "fromPairs", true>;
}

declare class NgArrayPipesModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<NgArrayPipesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NgArrayPipesModule, never, [typeof DiffPipe, typeof FlattenPipe, typeof InitialPipe, typeof SlicePipe, typeof IntersectionPipe, typeof ReversePipe, typeof TailPipe, typeof TrurthifyPipe, typeof UnionPipe, typeof UniquePipe, typeof WithoutPipe, typeof PluckPipe, typeof ShufflePipe, typeof EveryPipe, typeof SomePipe, typeof SamplePipe, typeof GroupByPipe, typeof GroupByImpurePipe, typeof FilterByPipe, typeof FilterByImpurePipe, typeof OrderByPipe, typeof OrderByImpurePipe, typeof RangePipe, typeof ChunkPipe, typeof FromPairsPipe], [typeof DiffPipe, typeof FlattenPipe, typeof InitialPipe, typeof SlicePipe, typeof IntersectionPipe, typeof ReversePipe, typeof TailPipe, typeof TrurthifyPipe, typeof UnionPipe, typeof UniquePipe, typeof WithoutPipe, typeof PluckPipe, typeof ShufflePipe, typeof EveryPipe, typeof SomePipe, typeof SamplePipe, typeof GroupByPipe, typeof GroupByImpurePipe, typeof FilterByPipe, typeof FilterByImpurePipe, typeof OrderByPipe, typeof OrderByImpurePipe, typeof RangePipe, typeof ChunkPipe, typeof FromPairsPipe]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NgArrayPipesModule>;
}

declare class ScanPipe implements PipeTransform {
    transform(text: string, args?: string[]): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ScanPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ScanPipe, "scan", true>;
}

declare class ShortenPipe implements PipeTransform {
    transform(text: string, length?: number, suffix?: string, wordBreak?: boolean): string;
    transform<T>(text: T, length?: number, suffix?: string, wordBreak?: boolean): T;
    static ɵfac: i0.ɵɵFactoryDeclaration<ShortenPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ShortenPipe, "shorten", true>;
}

declare class StripTagsPipe implements PipeTransform {
    transform(text: string, ...allowedTags: string[]): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<StripTagsPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<StripTagsPipe, "stripTags", true>;
}

declare class LinesPipe implements PipeTransform {
    transform(text: string, chars?: string): string[];
    transform<T>(text: T, chars?: string): T;
    static ɵfac: i0.ɵɵFactoryDeclaration<LinesPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<LinesPipe, "lines", true>;
}

declare class MatchPipe implements PipeTransform {
    transform(text: string, pattern: string, flags?: string): RegExpMatchArray;
    transform<T>(text: T, pattern?: string, flags?: string): T;
    static ɵfac: i0.ɵɵFactoryDeclaration<MatchPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MatchPipe, "match", true>;
}

declare class TestPipe implements PipeTransform {
    transform(text: string, pattern: string, flags?: string): boolean;
    transform<T>(text: T, pattern?: string, flags?: string): T;
    static ɵfac: i0.ɵɵFactoryDeclaration<TestPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<TestPipe, "test", true>;
}

declare class AorAnPipe implements PipeTransform {
    private irregularMap;
    transform(stringEntity: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<AorAnPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<AorAnPipe, "aOrAn", true>;
}

declare class LeftTrimPipe implements PipeTransform {
    transform(text: string, chars?: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<LeftTrimPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<LeftTrimPipe, "ltrim", true>;
}

declare class RepeatPipe implements PipeTransform {
    transform(str: string, n?: number, separator?: string): string;
    private repeat;
    static ɵfac: i0.ɵɵFactoryDeclaration<RepeatPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<RepeatPipe, "repeat", true>;
}

declare class RightTrimPipe implements PipeTransform {
    transform(text: string, chars?: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<RightTrimPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<RightTrimPipe, "rtrim", true>;
}

declare class TrimPipe implements PipeTransform {
    transform(text: string, chars?: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TrimPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<TrimPipe, "trim", true>;
}

declare class UcFirstPipe implements PipeTransform {
    transform(text: string): string;
    transform<T>(text: T): T;
    static ɵfac: i0.ɵɵFactoryDeclaration<UcFirstPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<UcFirstPipe, "ucfirst", true>;
}

declare class UcWordsPipe implements PipeTransform {
    transform(text: string): string;
    transform<T>(text: T): T;
    static ɵfac: i0.ɵɵFactoryDeclaration<UcWordsPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<UcWordsPipe, "ucwords", true>;
}

declare class SlugifyPipe implements PipeTransform {
    transform(str: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SlugifyPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SlugifyPipe, "slugify", true>;
}

declare class CamelizePipe implements PipeTransform {
    transform(input: string, chars?: string): string;
    transform<T>(input: T, chars?: string): T;
    static ɵfac: i0.ɵɵFactoryDeclaration<CamelizePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<CamelizePipe, "camelize", true>;
}

declare class LatinisePipe implements PipeTransform {
    private latinMap;
    transform(input: string, chars?: string): string;
    transform<T>(input: T, chars?: string): T;
    static ɵfac: i0.ɵɵFactoryDeclaration<LatinisePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<LatinisePipe, "latinise", true>;
}

declare class UnderscorePipe implements PipeTransform {
    transform(text: string, chars?: string): string;
    transform<T>(text: T, chars?: string): T;
    static ɵfac: i0.ɵɵFactoryDeclaration<UnderscorePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<UnderscorePipe, "underscore", true>;
}

declare class LeftPadPipe implements PipeTransform {
    transform(str: string, length: number, padCharacter?: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<LeftPadPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<LeftPadPipe, "lpad", true>;
}

declare class RightPadPipe implements PipeTransform {
    transform(str: string, length?: number, padCharacter?: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<RightPadPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<RightPadPipe, "rpad", true>;
}

declare class MakePluralStringPipe implements PipeTransform {
    private irregularMap;
    transform(singularEntity: string, quantity?: number): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<MakePluralStringPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MakePluralStringPipe, "makePluralString", true>;
}

declare class WrapPipe implements PipeTransform {
    transform(str: string, prefix?: string, suffix?: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<WrapPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<WrapPipe, "wrap", true>;
}

declare class ReplaceRegexPipe implements PipeTransform {
    transform(text: string, pattern?: string, replaceWith?: string): string;
    transform<T>(text: T, pattern?: string, replaceWith?: string): T;
    static ɵfac: i0.ɵɵFactoryDeclaration<ReplaceRegexPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ReplaceRegexPipe, "replaceRegex", true>;
}

declare class SplitPipe implements PipeTransform {
    transform(str: string, separator?: string): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<SplitPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SplitPipe, "split", true>;
}

declare const STRING_PIPES: (typeof ScanPipe | typeof ShortenPipe | typeof StripTagsPipe | typeof LinesPipe | typeof MatchPipe | typeof TestPipe)[];
declare class NgStringPipesModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<NgStringPipesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NgStringPipesModule, never, [typeof AorAnPipe, typeof LeftTrimPipe, typeof RepeatPipe, typeof RightTrimPipe, typeof ScanPipe, typeof ShortenPipe, typeof StripTagsPipe, typeof TrimPipe, typeof UcFirstPipe, typeof UcWordsPipe, typeof SlugifyPipe, typeof CamelizePipe, typeof LatinisePipe, typeof LinesPipe, typeof UnderscorePipe, typeof MatchPipe, typeof TestPipe, typeof LeftPadPipe, typeof RightPadPipe, typeof MakePluralStringPipe, typeof WrapPipe, typeof ReplaceRegexPipe, typeof SplitPipe], [typeof AorAnPipe, typeof LeftTrimPipe, typeof RepeatPipe, typeof RightTrimPipe, typeof ScanPipe, typeof ShortenPipe, typeof StripTagsPipe, typeof TrimPipe, typeof UcFirstPipe, typeof UcWordsPipe, typeof SlugifyPipe, typeof CamelizePipe, typeof LatinisePipe, typeof LinesPipe, typeof UnderscorePipe, typeof MatchPipe, typeof TestPipe, typeof LeftPadPipe, typeof RightPadPipe, typeof MakePluralStringPipe, typeof WrapPipe, typeof ReplaceRegexPipe, typeof SplitPipe]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NgStringPipesModule>;
}

declare class PercentagePipe implements PipeTransform {
    transform(num: number, total?: number, floor?: boolean): number;
    transform<T>(num: T, total?: number, floor?: boolean): T;
    static ɵfac: i0.ɵɵFactoryDeclaration<PercentagePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<PercentagePipe, "percentage", true>;
}

declare class BytesPipe implements PipeTransform {
    private dictionary;
    transform(value: number, precision?: number): string | number;
    static ɵfac: i0.ɵɵFactoryDeclaration<BytesPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<BytesPipe, "bytes", true>;
}

declare class MaxPipe implements PipeTransform {
    transform(arr: number | number[]): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<MaxPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MaxPipe, "max", true>;
}

declare class MinPipe implements PipeTransform {
    transform(arr: number | number[]): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<MinPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MinPipe, "min", true>;
}

declare class SumPipe implements PipeTransform {
    transform(num: number[]): number;
    transform<T>(num: T): T;
    static ɵfac: i0.ɵɵFactoryDeclaration<SumPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SumPipe, "sum", true>;
}

declare class AveragePipe implements PipeTransform {
    transform(arr: number[]): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<AveragePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<AveragePipe, "average", true>;
}

declare class FloorPipe implements PipeTransform {
    transform(num: number, precision?: number): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<FloorPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FloorPipe, "floor", true>;
}

declare class RoundPipe implements PipeTransform {
    transform(num: number, precision?: number): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<RoundPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<RoundPipe, "round", true>;
}

declare class SqrtPipe implements PipeTransform {
    transform(num: number): number;
    transform<T>(num: T): T;
    static ɵfac: i0.ɵɵFactoryDeclaration<SqrtPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SqrtPipe, "sqrt", true>;
}

declare class PowerPipe implements PipeTransform {
    transform(num: number, power?: number): number;
    transform(num: any, power?: number): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<PowerPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<PowerPipe, "pow", true>;
}

declare class CeilPipe implements PipeTransform {
    transform(num: number, precision?: number): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<CeilPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<CeilPipe, "ceil", true>;
}

declare class DegreesPipe implements PipeTransform {
    transform(radians: number): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<DegreesPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<DegreesPipe, "degrees", true>;
}

declare class RadiansPipe implements PipeTransform {
    transform(degrees: number): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<RadiansPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<RadiansPipe, "radians", true>;
}

declare const MATH_PIPES: (typeof PercentagePipe | typeof BytesPipe)[];
declare class NgMathPipesModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<NgMathPipesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NgMathPipesModule, never, [typeof MaxPipe, typeof MinPipe, typeof PercentagePipe, typeof SumPipe, typeof AveragePipe, typeof FloorPipe, typeof RoundPipe, typeof SqrtPipe, typeof PowerPipe, typeof CeilPipe, typeof DegreesPipe, typeof BytesPipe, typeof RadiansPipe], [typeof MaxPipe, typeof MinPipe, typeof PercentagePipe, typeof SumPipe, typeof AveragePipe, typeof FloorPipe, typeof RoundPipe, typeof SqrtPipe, typeof PowerPipe, typeof CeilPipe, typeof DegreesPipe, typeof BytesPipe, typeof RadiansPipe]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NgMathPipesModule>;
}

declare class IsGreaterEqualThanPipe implements PipeTransform {
    transform(input: number, other: number): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<IsGreaterEqualThanPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IsGreaterEqualThanPipe, "isGreaterEqualThan", true>;
}

declare class IsDefinedPipe implements PipeTransform {
    transform(input: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<IsDefinedPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IsDefinedPipe, "isDefined", true>;
}

declare class IsNullPipe implements PipeTransform {
    transform(input: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<IsNullPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IsNullPipe, "isNull", true>;
}

declare class IsUndefinedPipe implements PipeTransform {
    transform(input: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<IsUndefinedPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IsUndefinedPipe, "isUndefined", true>;
}

declare class IsStringPipe implements PipeTransform {
    transform(input: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<IsStringPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IsStringPipe, "isString", true>;
}

declare class IsFunctionPipe implements PipeTransform {
    transform(input: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<IsFunctionPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IsFunctionPipe, "isFunction", true>;
}

declare class IsNumberPipe implements PipeTransform {
    transform(input: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<IsNumberPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IsNumberPipe, "isNumber", true>;
}

declare class IsArrayPipe implements PipeTransform {
    transform(input: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<IsArrayPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IsArrayPipe, "isArray", true>;
}

declare class IsObjectPipe implements PipeTransform {
    transform(input: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<IsObjectPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IsObjectPipe, "isObject", true>;
}

declare class IsGreaterThanPipe implements PipeTransform {
    transform(input: number, other: number): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<IsGreaterThanPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IsGreaterThanPipe, "isGreaterThan", true>;
}

declare class IsLessEqualThanPipe implements PipeTransform {
    transform(input: number, other: number): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<IsLessEqualThanPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IsLessEqualThanPipe, "isLessEqualThan", true>;
}

declare class IsEqualToPipe implements PipeTransform {
    transform(input: any, other: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<IsEqualToPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IsEqualToPipe, "isEqualTo", true>;
}

declare class IsNotEqualToPipe implements PipeTransform {
    transform(input: any, other: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<IsNotEqualToPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IsNotEqualToPipe, "isNotEqualTo", true>;
}

declare class IsIdenticalToPipe implements PipeTransform {
    transform(input: any, other: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<IsIdenticalToPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IsIdenticalToPipe, "isIdenticalTo", true>;
}

declare class IsNotIdenticalToPipe implements PipeTransform {
    transform(input: any, other: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<IsNotIdenticalToPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IsNotIdenticalToPipe, "isNotIdenticalTo", true>;
}

declare class IsLessThanPipe implements PipeTransform {
    transform(input: number, other: number): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<IsLessThanPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IsLessThanPipe, "isLessThan", true>;
}

declare const BOOLEAN_PIPES: (typeof IsGreaterEqualThanPipe)[];
declare class NgBooleanPipesModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<NgBooleanPipesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NgBooleanPipesModule, never, [typeof IsDefinedPipe, typeof IsNullPipe, typeof IsUndefinedPipe, typeof IsStringPipe, typeof IsFunctionPipe, typeof IsNumberPipe, typeof IsArrayPipe, typeof IsObjectPipe, typeof IsGreaterEqualThanPipe, typeof IsGreaterThanPipe, typeof IsLessEqualThanPipe, typeof IsLessEqualThanPipe, typeof IsEqualToPipe, typeof IsNotEqualToPipe, typeof IsIdenticalToPipe, typeof IsNotIdenticalToPipe, typeof IsLessThanPipe], [typeof IsDefinedPipe, typeof IsNullPipe, typeof IsUndefinedPipe, typeof IsStringPipe, typeof IsFunctionPipe, typeof IsNumberPipe, typeof IsArrayPipe, typeof IsObjectPipe, typeof IsGreaterEqualThanPipe, typeof IsGreaterThanPipe, typeof IsLessEqualThanPipe, typeof IsLessEqualThanPipe, typeof IsEqualToPipe, typeof IsNotEqualToPipe, typeof IsIdenticalToPipe, typeof IsNotIdenticalToPipe, typeof IsLessThanPipe]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NgBooleanPipesModule>;
}

declare class KeysPipe implements PipeTransform {
    transform<T extends any[]>(obj: T): T;
    transform<T>(obj: T): T extends any[] ? T : T extends GenericRecord<any> ? string[] : T;
    static ɵfac: i0.ɵɵFactoryDeclaration<KeysPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<KeysPipe, "keys", true>;
}

declare class ValuesPipe implements PipeTransform {
    transform<T extends any[]>(obj: T): T;
    transform<T>(obj: T): T extends GenericRecord<any> ? any[] : T;
    static ɵfac: i0.ɵɵFactoryDeclaration<ValuesPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ValuesPipe, "values", true>;
}

declare class PairsPipe implements PipeTransform {
    transform<T extends any[]>(obj: T): T;
    transform<T>(obj: T): T extends GenericRecord<any> ? [string, any][] : T;
    static ɵfac: i0.ɵɵFactoryDeclaration<PairsPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<PairsPipe, "pairs", true>;
}

declare class PickPipe implements PipeTransform {
    transform<T extends any[]>(obj: T, ...args: any): T;
    transform<T, K extends (T extends GenericRecord<any> ? (keyof T)[] : never)>(obj: T, ...args: K): T extends GenericRecord<any> ? (K extends never ? T : Pick<T, K[number]>) : T;
    static ɵfac: i0.ɵɵFactoryDeclaration<PickPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<PickPipe, "pick", true>;
}

declare class InvertPipe implements PipeTransform {
    transform<T extends any[]>(obj: T): T;
    transform<T>(obj: T): T extends GenericRecord<any> ? GenericRecord<any> : T;
    static ɵfac: i0.ɵɵFactoryDeclaration<InvertPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<InvertPipe, "invert", true>;
}

declare class InvertByPipe implements PipeTransform {
    transform<T extends any[]>(obj: T): T;
    transform<T>(obj: T, cb?: (val: any) => string): T extends GenericRecord<any> ? GenericRecord<any> : T;
    static ɵfac: i0.ɵɵFactoryDeclaration<InvertByPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<InvertByPipe, "invertBy", true>;
}

declare class OmitPipe implements PipeTransform {
    transform<T extends any[]>(obj: T, ...args: any): T;
    transform<T, K extends (T extends GenericRecord<any> ? (keyof T)[] : never)>(obj: T, ...args: K): T extends GenericRecord<any> ? (K extends never ? T : Omit<T, K[number]>) : T;
    static ɵfac: i0.ɵɵFactoryDeclaration<OmitPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<OmitPipe, "omit", true>;
}

declare class DiffObjPipe implements PipeTransform {
    transform<T extends any[]>(obj: T, original: any): GenericRecord<never>;
    transform<T>(obj: T, original: any): T extends GenericRecord<any> ? Partial<T> : GenericRecord<never>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DiffObjPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<DiffObjPipe, "diffObj", true>;
}

declare class NgObjectPipesModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<NgObjectPipesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NgObjectPipesModule, never, [typeof KeysPipe, typeof ValuesPipe, typeof PairsPipe, typeof PickPipe, typeof InvertPipe, typeof InvertByPipe, typeof OmitPipe, typeof DiffObjPipe], [typeof KeysPipe, typeof ValuesPipe, typeof PairsPipe, typeof PickPipe, typeof InvertPipe, typeof InvertByPipe, typeof OmitPipe, typeof DiffObjPipe]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NgObjectPipesModule>;
}

declare class TimeAgoPipe implements PipeTransform {
    private static YEAR_MS;
    private static MAPPER;
    /**
     * @param inputDate: Date | Moment - not included as TypeScript interface,
     * in order to keep `ngx-pipes` "pure" from dependencies!
     */
    transform(inputDate: any): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TimeAgoPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<TimeAgoPipe, "timeAgo", true>;
}

declare const DATE_PIPES: (typeof TimeAgoPipe)[];
declare class NgDatePipesModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<NgDatePipesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NgDatePipesModule, never, [typeof TimeAgoPipe], [typeof TimeAgoPipe]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NgDatePipesModule>;
}

declare class NgPipesModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<NgPipesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NgPipesModule, never, never, [typeof NgArrayPipesModule, typeof NgStringPipesModule, typeof NgMathPipesModule, typeof NgBooleanPipesModule, typeof NgObjectPipesModule, typeof NgDatePipesModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NgPipesModule>;
}

export { AorAnPipe, AveragePipe, BOOLEAN_PIPES, BytesPipe, CamelizePipe, CeilPipe, ChunkPipe, DATE_PIPES, DegreesPipe, DiffObjPipe, DiffPipe, EveryPipe, FilterByImpurePipe, FilterByPipe, FlattenPipe, FloorPipe, FromPairsPipe, GroupByImpurePipe, GroupByPipe, InitialPipe, IntersectionPipe, InvertByPipe, InvertPipe, IsArrayPipe, IsDefinedPipe, IsEqualToPipe, IsFunctionPipe, IsGreaterEqualThanPipe, IsGreaterThanPipe, IsIdenticalToPipe, IsLessEqualThanPipe, IsLessThanPipe, IsNotEqualToPipe, IsNotIdenticalToPipe, IsNullPipe, IsNumberPipe, IsObjectPipe, IsStringPipe, IsUndefinedPipe, KeysPipe, LatinisePipe, LeftPadPipe, LeftTrimPipe, LinesPipe, MATH_PIPES, MakePluralStringPipe, MatchPipe, MaxPipe, MinPipe, NgArrayPipesModule, NgBooleanPipesModule, NgDatePipesModule, NgMathPipesModule, NgObjectPipesModule, NgPipesModule, NgStringPipesModule, OmitPipe, OrderByImpurePipe, OrderByPipe, PairsPipe, PercentagePipe, PickPipe, PluckPipe, PowerPipe, RadiansPipe, RangePipe, RepeatPipe, ReplaceRegexPipe, ReversePipe, RightPadPipe, RightTrimPipe, RoundPipe, STRING_PIPES, SamplePipe, ScanPipe, ShortenPipe, ShufflePipe, SlicePipe, SlugifyPipe, SomePipe, SplitPipe, SqrtPipe, StripTagsPipe, SumPipe, TailPipe, TestPipe, TimeAgoPipe, TrimPipe, TrurthifyPipe, UcFirstPipe, UcWordsPipe, UnderscorePipe, UnionPipe, UniquePipe, ValuesPipe, WithoutPipe, WrapPipe };