@algochad/prisma-core/dist/collections/linq/interfaces.d.ts

A comprehensive NestJS library that provides EF-Core-like operations using Prisma and GraphQL. Features LINQ-style query builders, advanced data manipulation, GraphQL integration with genql, and a unified API for both Prisma and GraphQL operations. Includ

export interface IEnumerable<T> {
    [Symbol.iterator](): Iterator<T>;
    readonly length?: number;
    ToArray(): T[];
    ToList(): IList<T>;
    Count(predicate?: (value: T, index?: number, list?: T[]) => boolean): number;
    First(predicate?: (value: T, index?: number, list?: T[]) => boolean): T;
    FirstOrDefault(): T | undefined;
    FirstOrDefault(predicate: (value: T, index?: number, list?: T[]) => boolean): T | undefined;
    FirstOrDefault(defaultValue?: T): T | undefined;
    FirstOrDefault(predicate?: (value: T, index?: number, list?: T[]) => boolean, defaultValue?: T): T | undefined;
    Last(predicate?: (value: T, index?: number, list?: T[]) => boolean): T;
    LastOrDefault(): T | undefined;
    LastOrDefault(predicate: (value: T, index?: number, list?: T[]) => boolean): T | undefined;
    LastOrDefault(defaultValue?: T): T | undefined;
    LastOrDefault(predicate?: (value: T, index?: number, list?: T[]) => boolean, defaultValue?: T): T | undefined;
    Single(predicate?: (value: T, index?: number, list?: T[]) => boolean): T;
    SingleOrDefault(defaultValue?: T): T | undefined;
    ElementAt(index: number): T;
    ElementAtOrDefault(index: number): T | undefined;
    Where(predicate: (value: T, index?: number, list?: T[]) => boolean): IEnumerable<T>;
    Select<TResult>(selector: (element: T, index: number) => TResult): IEnumerable<TResult>;
    SelectMany<TResult>(selector: (element: T, index: number) => IEnumerable<TResult>): IEnumerable<TResult>;
    OrderBy(keySelector: (key: T) => any, comparer?: (a: T, b: T) => number): IOrderedEnumerable<T>;
    OrderByDescending(keySelector: (key: T) => any, comparer?: (a: T, b: T) => number): IOrderedEnumerable<T>;
    Distinct(): IEnumerable<T>;
    DistinctBy(keySelector: (key: T) => string | number): IEnumerable<T>;
    Union(list: IEnumerable<T>): IEnumerable<T>;
    Intersect(source: IEnumerable<T>): IEnumerable<T>;
    Except(source: IEnumerable<T>): IEnumerable<T>;
    Take(amount: number): IEnumerable<T>;
    Skip(amount: number): IEnumerable<T>;
    TakeWhile(predicate: (value: T, index?: number, list?: T[]) => boolean): IEnumerable<T>;
    SkipWhile(predicate: (value: T, index?: number, list?: T[]) => boolean): IEnumerable<T>;
    Aggregate<U>(accumulator: (accum: U, value: T, index: number, list?: T[]) => any, initialValue: U): any;
    Sum(transform?: (value?: T, index?: number, list?: T[]) => number): number;
    Average(transform?: (value?: T, index?: number, list?: T[]) => number): number;
    Min(selector?: (element: T, index: number) => number): number;
    Max(selector?: (element: T, index: number) => number): number;
    Any(predicate?: (value: T, index?: number, list?: T[]) => boolean): boolean;
    All(predicate: (value: T, index?: number, list?: T[]) => boolean): boolean;
    Contains(element: T): boolean;
    Join<U, R>(list: IEnumerable<U>, key1: (key: T) => any, key2: (key: U) => any, result: (first: T, second: U) => R): IEnumerable<R>;
    GroupJoin<U, R>(list: IEnumerable<U>, key1: (k: T) => any, key2: (k: U) => any, result: (first: T, second: IEnumerable<U>) => R): IEnumerable<R>;
    GroupBy<TResult = T>(grouper: (key: T) => string | number, mapper?: (element: T) => TResult): IEnumerable<IGrouping<string | number, TResult>>;
    ToAsyncEnumerable(): IAsyncEnumerable<T>;
    ForEach(action: (value?: T, index?: number, list?: T[]) => any): void;
    Reverse(): IEnumerable<T>;
    Concat(list: IEnumerable<T>): IEnumerable<T>;
}
export interface IList<T> extends IEnumerable<T> {
    Add(element: T): void;
    AddRange(elements: T[] | IEnumerable<T>): void;
    Insert(index: number, element: T): void | Error;
    Remove(element: T): boolean;
    RemoveAt(index: number): void;
    RemoveAll(predicate: (value: T, index?: number, list?: T[]) => boolean): IList<T>;
    Clear(): void;
    IndexOf(element: T): number;
    LastIndexOf(element: T): number;
    readonly length: number;
    get(index: number): T;
    set(index: number, value: T): void;
    Where(predicate: (value: T, index?: number, list?: T[]) => boolean): IList<T>;
    Select<TResult>(selector: (element: T, index: number) => TResult): IList<TResult>;
    Reverse(): IList<T>;
    Take(amount: number): IList<T>;
    Skip(amount: number): IList<T>;
    Distinct(): IList<T>;
    Sort(comparer?: (a: T, b: T) => number): IList<T>;
}
export interface IOrderedEnumerable<T> extends IEnumerable<T> {
    ThenBy(keySelector: (key: T) => any): IOrderedEnumerable<T>;
    ThenByDescending(keySelector: (key: T) => any): IOrderedEnumerable<T>;
    Where(predicate: (value: T, index?: number, list?: T[]) => boolean): IOrderedEnumerable<T>;
    Take(amount: number): IOrderedEnumerable<T>;
    Skip(amount: number): IOrderedEnumerable<T>;
}
export interface IAsyncEnumerable<T> {
    [Symbol.asyncIterator](): AsyncIterator<T>;
    ToArrayAsync(): Promise<T[]>;
    ToListAsync(): Promise<IList<T>>;
    CountAsync(): Promise<number>;
    CountAsync(predicate: (item: T) => Promise<boolean> | boolean): Promise<number>;
    FirstAsync(): Promise<T>;
    FirstAsync(predicate: (item: T) => Promise<boolean> | boolean): Promise<T>;
    FirstOrDefaultAsync(): Promise<T | undefined>;
    FirstOrDefaultAsync(predicate: (item: T) => Promise<boolean> | boolean): Promise<T | undefined>;
    LastAsync(): Promise<T>;
    LastAsync(predicate: (item: T) => Promise<boolean> | boolean): Promise<T>;
    LastOrDefaultAsync(): Promise<T | undefined>;
    LastOrDefaultAsync(predicate: (item: T) => Promise<boolean> | boolean): Promise<T | undefined>;
    SingleAsync(): Promise<T>;
    SingleAsync(predicate: (item: T) => Promise<boolean> | boolean): Promise<T>;
    SingleOrDefaultAsync(): Promise<T | undefined>;
    SingleOrDefaultAsync(predicate: (item: T) => Promise<boolean> | boolean): Promise<T | undefined>;
    Where(predicate: (item: T, index?: number) => Promise<boolean> | boolean): IAsyncEnumerable<T>;
    Select<TResult>(selector: (item: T, index?: number) => Promise<TResult> | TResult): IAsyncEnumerable<TResult>;
    SelectMany<TResult>(selector: (item: T) => IAsyncEnumerable<TResult> | IEnumerable<TResult>): IAsyncEnumerable<TResult>;
    OrderBy<TKey>(keySelector: (item: T) => TKey): IOrderedAsyncEnumerable<T>;
    OrderByDescending<TKey>(keySelector: (item: T) => TKey): IOrderedAsyncEnumerable<T>;
    Distinct(): IAsyncEnumerable<T>;
    Distinct<TKey>(keySelector: (item: T) => TKey): IAsyncEnumerable<T>;
    Take(count: number): IAsyncEnumerable<T>;
    Skip(count: number): IAsyncEnumerable<T>;
    TakeWhile(predicate: (item: T) => Promise<boolean> | boolean): IAsyncEnumerable<T>;
    SkipWhile(predicate: (item: T) => Promise<boolean> | boolean): IAsyncEnumerable<T>;
    AggregateAsync<TAccumulate>(seed: TAccumulate, func: (accumulate: TAccumulate, item: T) => Promise<TAccumulate> | TAccumulate): Promise<TAccumulate>;
    SumAsync(selector?: (item: T) => number): Promise<number>;
    AverageAsync(selector?: (item: T) => number): Promise<number>;
    MinAsync(selector?: (item: T) => number): Promise<number>;
    MaxAsync(selector?: (item: T) => number): Promise<number>;
    AnyAsync(): Promise<boolean>;
    AnyAsync(predicate: (item: T) => Promise<boolean> | boolean): Promise<boolean>;
    AllAsync(predicate: (item: T) => Promise<boolean> | boolean): Promise<boolean>;
    ContainsAsync(item: T): Promise<boolean>;
    ToEnumerable(): Promise<IEnumerable<T>>;
}
export interface IOrderedAsyncEnumerable<T> extends IAsyncEnumerable<T> {
    ThenBy<TKey>(keySelector: (item: T) => TKey): IOrderedAsyncEnumerable<T>;
    ThenByDescending<TKey>(keySelector: (item: T) => TKey): IOrderedAsyncEnumerable<T>;
}
export interface IGrouping<TKey, TElement> extends IEnumerable<TElement> {
    readonly Key: TKey;
}