@algochad/prisma-core/dist/collections/linq/list.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 { IList, IEnumerable, IOrderedEnumerable, IAsyncEnumerable, IGrouping } from './interfaces';
export declare class List<T> implements IList<T> {
    private _linqList;
    constructor(items?: Iterable<T>);
    static from<T>(items: Iterable<T>): List<T>;
    static empty<T>(): List<T>;
    static range(start: number, count: number): List<number>;
    static repeat<T>(element: T, count: number): List<T>;
    [Symbol.iterator](): Iterator<T>;
    ToArray(): T[];
    ToList(): IList<T>;
    Add(item: T): void;
    AddRange(items: Iterable<T>): void;
    Insert(index: number, item: T): void;
    Remove(item: T): boolean;
    RemoveAt(index: number): void;
    RemoveAll(predicate: (value: T, index?: number, list?: T[]) => boolean): IList<T>;
    Clear(): void;
    IndexOf(item: T): number;
    LastIndexOf(item: T): number;
    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;
    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;
    Single(): T;
    Single(predicate: (value: T, index?: number, list?: T[]) => boolean): T;
    SingleOrDefault(): T | undefined;
    SingleOrDefault(defaultValue?: T): T | undefined;
    get length(): number;
    get(index: number): T;
    set(index: number, value: T): void;
    ElementAt(index: number): T;
    ElementAtOrDefault(index: number): T | undefined;
    Where(predicate: (value: T, index?: number, list?: T[]) => boolean): IList<T>;
    Select<TResult>(selector: (element: T, index: number) => TResult): IList<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(): IList<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): IList<T>;
    Skip(amount: number): IList<T>;
    TakeWhile(predicate: (value: T, index?: number, list?: T[]) => boolean): IList<T>;
    SkipWhile(predicate: (value: T, index?: number, list?: T[]) => boolean): IList<T>;
    Reverse(): IList<T>;
    Sort(comparer?: (a: T, b: T) => number): IList<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;
    Concat(list: IEnumerable<T>): IEnumerable<T>;
}