@algochad/prisma-core/dist/collections/linq/enumerable.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

import { List as LinqEnumerable } from 'linqts';
import { IEnumerable, IList, IOrderedEnumerable, IAsyncEnumerable, IGrouping } from './interfaces';
export declare class Enumerable<T> implements IEnumerable<T> {
    protected _linqEnumerable: LinqEnumerable<T>;
    constructor(items: Iterable<T>);
    static from<T>(items: Iterable<T>): Enumerable<T>;
    static empty<T>(): Enumerable<T>;
    static range(start: number, count: number): Enumerable<number>;
    static repeat<T>(element: T, count: number): Enumerable<T>;
    [Symbol.iterator](): Iterator<T>;
    ToArray(): T[];
    ToList(): IList<T>;
    Count(): number;
    Count(predicate: (value: T, index?: number, list?: T[]) => boolean): number;
    First(): T;
    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(): T;
    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(): T;
    Single(predicate: (value: T, index?: number, list?: T[]) => boolean): T;
    SingleOrDefault(): T | undefined;
    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>;
}