linqx 0.2.1 → 0.3.2

package/dist/operators/chunk.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function chunk<T>(this: IEnumerable<T>, size: number): IEnumerable<T[]>;

package/dist/operators/concat.d.ts

@@ -0,0 +1,2 @@
+import type { EnumerableInput, IEnumerable } from '../types.js';
+export declare function concat<T>(this: IEnumerable<T>, ...sequences: EnumerableInput<T>[]): IEnumerable<T>;

package/dist/operators/contains.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function contains<T, TCompare>(this: IEnumerable<T>, value: T, compareSelector?: (element: T) => TCompare): boolean;

package/dist/operators/count-by.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable, KeyValuePair } from '../types.js';
+export declare function countBy<T, TKey>(this: IEnumerable<T>, keySelector: (element: T) => TKey, compareSelector?: (key: TKey) => unknown): IEnumerable<KeyValuePair<TKey, number>>;

package/dist/operators/count.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function count<T>(this: IEnumerable<T>, predicate?: (element: T, index: number) => boolean): number;

package/dist/operators/create-ordered-enumerable.d.ts

@@ -0,0 +1,2 @@
+import type { Comparer, IOrderedEnumerable } from '../types.js';
+export declare function createOrderedEnumerable<T, TKey>(this: IOrderedEnumerable<T>, keySelector: (element: T) => TKey, comparer?: Comparer<TKey>, descending?: boolean): IOrderedEnumerable<T>;

package/dist/operators/default-if-empty.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function defaultIfEmpty<T>(this: IEnumerable<T>, defaultValue?: T): IEnumerable<T>;

package/dist/operators/distinct-by.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function distinctBy<T, TKey, TCompare = TKey>(this: IEnumerable<T>, keySelector: (element: T) => TKey, compareSelector?: (key: TKey) => TCompare): IEnumerable<T>;

package/dist/operators/distinct-until-changed.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function distinctUntilChanged<T, TCompare>(this: IEnumerable<T>, compareSelector?: (element: T) => TCompare): IEnumerable<T>;

package/dist/operators/distinct.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function distinct<T, TCompare>(this: IEnumerable<T>, compareSelector?: (element: T) => TCompare): IEnumerable<T>;

package/dist/operators/do-action.d.ts

@@ -0,0 +1,3 @@
+import type { IEnumerable } from '../types.js';
+export declare function doAction<T>(this: IEnumerable<T>, action: (element: T, index: number) => void): IEnumerable<T>;
+export declare function doAction<T>(this: IEnumerable<T>, action: (element: T, index: number) => boolean): IEnumerable<T>;

package/dist/operators/element-at-or-default.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function elementAtOrDefault<T>(this: IEnumerable<T>, index: number, defaultValue?: T): T | undefined;

package/dist/operators/element-at.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function elementAt<T>(this: IEnumerable<T>, index: number): T;

package/dist/operators/except-by.d.ts

@@ -0,0 +1,2 @@
+import type { EnumerableInput, IEnumerable } from '../types.js';
+export declare function exceptBy<T, TKey, TCompare = TKey>(this: IEnumerable<T>, second: EnumerableInput<TKey>, keySelector: (element: T) => TKey, compareSelector?: (key: TKey) => TCompare): IEnumerable<T>;

package/dist/operators/except.d.ts

@@ -0,0 +1,2 @@
+import type { EnumerableInput, IEnumerable } from '../types.js';
+export declare function except<T, TCompare>(this: IEnumerable<T>, second: EnumerableInput<T>, compareSelector?: (element: T) => TCompare): IEnumerable<T>;

package/dist/operators/finally-action.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function finallyAction<T>(this: IEnumerable<T>, action: () => void): IEnumerable<T>;

package/dist/operators/first-or-default.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function firstOrDefault<T, TDefault>(this: IEnumerable<T>, predicateOrDefault?: ((element: T, index: number) => boolean) | TDefault, defaultValue?: TDefault): T | TDefault | undefined;

package/dist/operators/first.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function first<T>(this: IEnumerable<T>, predicate?: (element: T, index: number) => boolean): T;

package/dist/operators/flatten.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function flatten<T>(this: IEnumerable<T>): IEnumerable<unknown>;

package/dist/operators/for-each.d.ts

@@ -0,0 +1,3 @@
+import type { IEnumerable } from '../types.js';
+export declare function forEach<T>(this: IEnumerable<T>, action: (element: T, index: number) => void): void;
+export declare function forEach<T>(this: IEnumerable<T>, action: (element: T, index: number) => boolean): void;

package/dist/operators/force.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function force<T>(this: IEnumerable<T>): void;

package/dist/operators/group-by.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable, IGrouping } from '../types.js';
+export declare function groupBy<T, TKey, TElement = T, TResult = IGrouping<TKey, TElement>>(this: IEnumerable<T>, keySelector: (element: T) => TKey, elementSelector?: (element: T) => TElement, resultSelector?: ((key: TKey, elements: IEnumerable<TElement>) => TResult) | undefined, compareSelector?: (key: TKey) => unknown): IEnumerable<TResult>;

package/dist/operators/group-join.d.ts

@@ -0,0 +1,2 @@
+import type { EnumerableInput, IEnumerable } from '../types.js';
+export declare function groupJoin<TOuter, TInner, TKey, TResult>(this: IEnumerable<TOuter>, inner: EnumerableInput<TInner>, outerKeySelector: (outer: TOuter) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: TOuter, inner: IEnumerable<TInner>) => TResult, compareSelector?: (key: TKey) => unknown): IEnumerable<TResult>;

package/dist/operators/index-of.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function indexOf<T>(this: IEnumerable<T>, itemOrPredicate: T | ((element: T, index: number) => boolean)): number;

package/dist/operators/index.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable, Indexed } from '../types.js';
+export declare function index<T>(this: IEnumerable<T>): IEnumerable<Indexed<T>>;

package/dist/operators/insert.d.ts

@@ -0,0 +1,2 @@
+import type { EnumerableInput, IEnumerable } from '../types.js';
+export declare function insert<T>(this: IEnumerable<T>, index: number, second: EnumerableInput<T>): IEnumerable<T>;

package/dist/operators/intersect-by.d.ts

@@ -0,0 +1,2 @@
+import type { EnumerableInput, IEnumerable } from '../types.js';
+export declare function intersectBy<T, TKey, TCompare = TKey>(this: IEnumerable<T>, second: EnumerableInput<TKey>, keySelector: (element: T) => TKey, compareSelector?: (key: TKey) => TCompare): IEnumerable<T>;

package/dist/operators/intersect.d.ts

@@ -0,0 +1,2 @@
+import type { EnumerableInput, IEnumerable } from '../types.js';
+export declare function intersect<T, TCompare>(this: IEnumerable<T>, second: EnumerableInput<T>, compareSelector?: (element: T) => TCompare): IEnumerable<T>;

package/dist/operators/is-empty.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function isEmpty<T>(this: IEnumerable<T>): boolean;

package/dist/operators/join-with.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function joinWith<T>(this: IEnumerable<T>, separator: string | ((element: T) => T)): string | IEnumerable<T>;

package/dist/operators/join.d.ts

@@ -0,0 +1,2 @@
+import type { EnumerableInput, IEnumerable } from '../types.js';
+export declare function join<TOuter, TInner, TKey, TResult>(this: IEnumerable<TOuter>, inner: EnumerableInput<TInner>, outerKeySelector: (outer: TOuter) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: TOuter, inner: TInner) => TResult, compareSelector?: (key: TKey) => unknown): IEnumerable<TResult>;

package/dist/operators/last-index-of.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function lastIndexOf<T>(this: IEnumerable<T>, itemOrPredicate: T | ((element: T, index: number) => boolean)): number;

package/dist/operators/last-or-default.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function lastOrDefault<T, TDefault>(this: IEnumerable<T>, predicateOrDefault?: ((element: T, index: number) => boolean) | TDefault, defaultValue?: TDefault): T | TDefault | undefined;

package/dist/operators/last.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function last<T>(this: IEnumerable<T>, predicate?: (element: T, index: number) => boolean): T;

package/dist/operators/left-join.d.ts

@@ -0,0 +1,2 @@
+import type { EnumerableInput, IEnumerable } from '../types.js';
+export declare function leftJoin<TOuter, TInner, TKey, TResult>(this: IEnumerable<TOuter>, inner: EnumerableInput<TInner>, outerKeySelector: (outer: TOuter) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: TOuter, inner: TInner | null) => TResult, compareSelector?: (key: TKey) => unknown): IEnumerable<TResult>;

package/dist/operators/let-bind.d.ts

@@ -0,0 +1,2 @@
+import type { EnumerableInput, IEnumerable } from '../types.js';
+export declare function letBind<T, TResult>(this: IEnumerable<T>, func: (source: IEnumerable<T>) => EnumerableInput<TResult>): IEnumerable<TResult>;

package/dist/operators/log.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function log<T, TValue = T>(this: IEnumerable<T>, selector?: (element: T) => TValue): IEnumerable<T>;

package/dist/operators/map.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function map<T, TResult>(this: IEnumerable<T>, selector: (element: T, index: number) => TResult): TResult[];

package/dist/operators/max-by.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function maxBy<T, TKey>(this: IEnumerable<T>, keySelector: (element: T) => TKey): T;

package/dist/operators/max.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function max<T>(this: IEnumerable<T>, selector?: (element: T) => number): number;

package/dist/operators/memoize.d.ts

@@ -0,0 +1,2 @@
+import type { IDisposableEnumerable, IEnumerable } from '../types.js';
+export declare function memoize<T>(this: IEnumerable<T>): IDisposableEnumerable<T>;

package/dist/operators/merge.d.ts

@@ -0,0 +1,2 @@
+import type { EnumerableInput, IEnumerable } from '../types.js';
+export declare function merge<T>(this: IEnumerable<T>, ...others: EnumerableInput<T>[]): IEnumerable<T>;

package/dist/operators/min-by.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function minBy<T, TKey>(this: IEnumerable<T>, keySelector: (element: T) => TKey): T;

package/dist/operators/min.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function min<T>(this: IEnumerable<T>, selector?: (element: T) => number): number;

package/dist/operators/of-type.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function ofType<T, TResult>(this: IEnumerable<T>, type: unknown): IEnumerable<TResult>;

package/dist/operators/operators.d.ts

@@ -0,0 +1,208 @@
+import { aggregate } from './aggregate.js';
+import { aggregateBy } from './aggregate-by.js';
+import { all } from './all.js';
+import { alternate } from './alternate.js';
+import { any } from './any.js';
+import { append } from './append.js';
+import { asEnumerable } from './as-enumerable.js';
+import { average } from './average.js';
+import { buffer } from './buffer.js';
+import { cast } from './cast.js';
+import { catchError } from './catch-error.js';
+import { choose } from './choose.js';
+import { chunk } from './chunk.js';
+import { concat } from './concat.js';
+import { contains } from './contains.js';
+import { count } from './count.js';
+import { countBy } from './count-by.js';
+import { createOrderedEnumerable } from './create-ordered-enumerable.js';
+import { defaultIfEmpty } from './default-if-empty.js';
+import { distinct } from './distinct.js';
+import { distinctBy } from './distinct-by.js';
+import { distinctUntilChanged } from './distinct-until-changed.js';
+import { doAction } from './do-action.js';
+import { elementAt } from './element-at.js';
+import { elementAtOrDefault } from './element-at-or-default.js';
+import { except } from './except.js';
+import { exceptBy } from './except-by.js';
+import { finallyAction } from './finally-action.js';
+import { first } from './first.js';
+import { firstOrDefault } from './first-or-default.js';
+import { flatten } from './flatten.js';
+import { force } from './force.js';
+import { forEach } from './for-each.js';
+import { groupBy } from './group-by.js';
+import { groupJoin } from './group-join.js';
+import { index } from './index.js';
+import { indexOf } from './index-of.js';
+import { insert } from './insert.js';
+import { intersect } from './intersect.js';
+import { intersectBy } from './intersect-by.js';
+import { isEmpty } from './is-empty.js';
+import { join } from './join.js';
+import { joinWith } from './join-with.js';
+import { last } from './last.js';
+import { lastIndexOf } from './last-index-of.js';
+import { lastOrDefault } from './last-or-default.js';
+import { leftJoin } from './left-join.js';
+import { letBind } from './let-bind.js';
+import { log } from './log.js';
+import { map } from './map.js';
+import { max } from './max.js';
+import { maxBy } from './max-by.js';
+import { memoize } from './memoize.js';
+import { merge } from './merge.js';
+import { min } from './min.js';
+import { minBy } from './min-by.js';
+import { ofType } from './of-type.js';
+import { orderBy } from './order-by.js';
+import { orderByDescending } from './order-by-descending.js';
+import { page } from './page.js';
+import { pairwise } from './pairwise.js';
+import { partitionBy } from './partition-by.js';
+import { position } from './position.js';
+import { prepend } from './prepend.js';
+import { reverse } from './reverse.js';
+import { rightJoin } from './right-join.js';
+import { scan } from './scan.js';
+import { select } from './select.js';
+import { selectMany } from './select-many.js';
+import { sequenceEqual } from './sequence-equal.js';
+import { share } from './share.js';
+import { shuffle } from './shuffle.js';
+import { single } from './single.js';
+import { singleOrDefault } from './single-or-default.js';
+import { skip } from './skip.js';
+import { skipLast } from './skip-last.js';
+import { skipWhile } from './skip-while.js';
+import { sum } from './sum.js';
+import { take } from './take.js';
+import { takeExceptLast } from './take-except-last.js';
+import { takeFromLast } from './take-from-last.js';
+import { takeLast } from './take-last.js';
+import { takeWhile } from './take-while.js';
+import { thenBy } from './then-by.js';
+import { thenByDescending } from './then-by-descending.js';
+import { toArray } from './to-array.js';
+import { toDictionary } from './to-dictionary.js';
+import { toJoinedString } from './to-joined-string.js';
+import { toJSONString } from './to-json-string.js';
+import { toLookup } from './to-lookup.js';
+import { toMap } from './to-map.js';
+import { toObject } from './to-object.js';
+import { toSet } from './to-set.js';
+import { trace } from './trace.js';
+import { traverseBreadthFirst } from './traverse-breadth-first.js';
+import { traverseDepthFirst } from './traverse-depth-first.js';
+import { union } from './union.js';
+import { unionBy } from './union-by.js';
+import { weightedSample } from './weighted-sample.js';
+import { where } from './where.js';
+import { whereIf } from './where-if.js';
+import { withNeighbors } from './with-neighbors.js';
+import { zip } from './zip.js';
+export declare const instanceOperators: {
+    aggregate: typeof aggregate;
+    aggregateBy: typeof aggregateBy;
+    all: typeof all;
+    alternate: typeof alternate;
+    any: typeof any;
+    append: typeof append;
+    asEnumerable: typeof asEnumerable;
+    average: typeof average;
+    buffer: typeof buffer;
+    cast: typeof cast;
+    catchError: typeof catchError;
+    choose: typeof choose;
+    chunk: typeof chunk;
+    concat: typeof concat;
+    contains: typeof contains;
+    count: typeof count;
+    countBy: typeof countBy;
+    createOrderedEnumerable: typeof createOrderedEnumerable;
+    defaultIfEmpty: typeof defaultIfEmpty;
+    distinct: typeof distinct;
+    distinctBy: typeof distinctBy;
+    distinctUntilChanged: typeof distinctUntilChanged;
+    doAction: typeof doAction;
+    elementAt: typeof elementAt;
+    elementAtOrDefault: typeof elementAtOrDefault;
+    except: typeof except;
+    exceptBy: typeof exceptBy;
+    finallyAction: typeof finallyAction;
+    first: typeof first;
+    firstOrDefault: typeof firstOrDefault;
+    flatten: typeof flatten;
+    force: typeof force;
+    forEach: typeof forEach;
+    groupBy: typeof groupBy;
+    groupJoin: typeof groupJoin;
+    index: typeof index;
+    indexOf: typeof indexOf;
+    insert: typeof insert;
+    intersect: typeof intersect;
+    intersectBy: typeof intersectBy;
+    isEmpty: typeof isEmpty;
+    join: typeof join;
+    joinWith: typeof joinWith;
+    last: typeof last;
+    lastIndexOf: typeof lastIndexOf;
+    lastOrDefault: typeof lastOrDefault;
+    leftJoin: typeof leftJoin;
+    letBind: typeof letBind;
+    log: typeof log;
+    map: typeof map;
+    max: typeof max;
+    maxBy: typeof maxBy;
+    memoize: typeof memoize;
+    merge: typeof merge;
+    min: typeof min;
+    minBy: typeof minBy;
+    ofType: typeof ofType;
+    orderBy: typeof orderBy;
+    orderByDescending: typeof orderByDescending;
+    page: typeof page;
+    pairwise: typeof pairwise;
+    partitionBy: typeof partitionBy;
+    position: typeof position;
+    prepend: typeof prepend;
+    reverse: typeof reverse;
+    rightJoin: typeof rightJoin;
+    scan: typeof scan;
+    select: typeof select;
+    selectMany: typeof selectMany;
+    sequenceEqual: typeof sequenceEqual;
+    share: typeof share;
+    shuffle: typeof shuffle;
+    single: typeof single;
+    singleOrDefault: typeof singleOrDefault;
+    skip: typeof skip;
+    skipLast: typeof skipLast;
+    skipWhile: typeof skipWhile;
+    sum: typeof sum;
+    take: typeof take;
+    takeExceptLast: typeof takeExceptLast;
+    takeFromLast: typeof takeFromLast;
+    takeLast: typeof takeLast;
+    takeWhile: typeof takeWhile;
+    thenBy: typeof thenBy;
+    thenByDescending: typeof thenByDescending;
+    toArray: typeof toArray;
+    toDictionary: typeof toDictionary;
+    toJoinedString: typeof toJoinedString;
+    toJSONString: typeof toJSONString;
+    toLookup: typeof toLookup;
+    toMap: typeof toMap;
+    toObject: typeof toObject;
+    toSet: typeof toSet;
+    trace: typeof trace;
+    traverseBreadthFirst: typeof traverseBreadthFirst;
+    traverseDepthFirst: typeof traverseDepthFirst;
+    union: typeof union;
+    unionBy: typeof unionBy;
+    weightedSample: typeof weightedSample;
+    where: typeof where;
+    whereIf: typeof whereIf;
+    withNeighbors: typeof withNeighbors;
+    zip: typeof zip;
+};

package/dist/operators/order-by-descending.d.ts

@@ -0,0 +1,2 @@
+import type { Comparer, IEnumerable, IOrderedEnumerable } from '../types.js';
+export declare function orderByDescending<T, TKey>(this: IEnumerable<T>, keySelector: (element: T) => TKey, comparer?: Comparer<TKey>): IOrderedEnumerable<T>;

package/dist/operators/order-by.d.ts

@@ -0,0 +1,2 @@
+import type { Comparer, IEnumerable, IOrderedEnumerable } from '../types.js';
+export declare function orderBy<T, TKey>(this: IEnumerable<T>, keySelector: (element: T) => TKey, comparer?: Comparer<TKey>): IOrderedEnumerable<T>;

package/dist/operators/page.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable, IPageInfo } from '../types.js';
+export declare function page<T>(this: IEnumerable<T>, pageNumberOrInfo: number | IPageInfo, pageSize?: number): IEnumerable<T>;

package/dist/operators/pairwise.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function pairwise<T, TResult>(this: IEnumerable<T>, selector: (prev: T, current: T) => TResult): IEnumerable<TResult>;

package/dist/operators/partition-by.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable, IGrouping } from '../types.js';
+export declare function partitionBy<T, TKey, TElement = T, TResult = IGrouping<TKey, TElement>>(this: IEnumerable<T>, keySelector: (element: T) => TKey, elementSelector?: (element: T) => TElement, resultSelector?: ((key: TKey, elements: IEnumerable<TElement>) => TResult) | undefined, compareSelector?: (key: TKey) => unknown): IEnumerable<TResult>;

package/dist/operators/position.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable, Positioned } from '../types.js';
+export declare function position<T>(this: IEnumerable<T>): IEnumerable<Positioned<T>>;

package/dist/operators/prepend.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function prepend<T>(this: IEnumerable<T>, element: T): IEnumerable<T>;

package/dist/operators/reverse.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function reverse<T>(this: IEnumerable<T>): IEnumerable<T>;

package/dist/operators/right-join.d.ts

@@ -0,0 +1,2 @@
+import type { EnumerableInput, IEnumerable } from '../types.js';
+export declare function rightJoin<TOuter, TInner, TKey, TResult>(this: IEnumerable<TOuter>, inner: EnumerableInput<TInner>, outerKeySelector: (outer: TOuter) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: TOuter | null, inner: TInner) => TResult, compareSelector?: (key: TKey) => unknown): IEnumerable<TResult>;

package/dist/operators/scan.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function scan<T, TAccumulate>(this: IEnumerable<T>, seedOrFunc: TAccumulate | ((prev: T, current: T) => T), optionalFunc?: (prev: TAccumulate, current: T) => TAccumulate): IEnumerable<T | TAccumulate>;

package/dist/operators/select-many.d.ts

@@ -0,0 +1,2 @@
+import type { EnumerableInput, IEnumerable } from '../types.js';
+export declare function selectMany<T, TCollection, TResult = TCollection>(this: IEnumerable<T>, collectionSelector: (element: T, index: number) => EnumerableInput<TCollection>, resultSelector?: (outer: T, inner: TCollection) => TResult): IEnumerable<TCollection | TResult>;

package/dist/operators/select.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function select<T, TResult>(this: IEnumerable<T>, selector: (element: T, index: number) => TResult): IEnumerable<TResult>;

package/dist/operators/sequence-equal.d.ts

@@ -0,0 +1,2 @@
+import type { EnumerableInput, IEnumerable } from '../types.js';
+export declare function sequenceEqual<T, TCompare>(this: IEnumerable<T>, second: EnumerableInput<T>, compareSelector?: (element: T) => TCompare): boolean;

package/dist/operators/share.d.ts

@@ -0,0 +1,2 @@
+import type { IDisposableEnumerable, IEnumerable } from '../types.js';
+export declare function share<T>(this: IEnumerable<T>): IDisposableEnumerable<T>;

package/dist/operators/shuffle.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function shuffle<T>(this: IEnumerable<T>): IEnumerable<T>;

package/dist/operators/single-or-default.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function singleOrDefault<T, TDefault>(this: IEnumerable<T>, predicateOrDefault?: ((element: T, index: number) => boolean) | TDefault, defaultValue?: TDefault): T | TDefault | undefined;

package/dist/operators/single.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function single<T>(this: IEnumerable<T>, predicate?: (element: T, index: number) => boolean): T;

package/dist/operators/skip-last.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function skipLast<T>(this: IEnumerable<T>, count: number): IEnumerable<T>;

package/dist/operators/skip-while.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function skipWhile<T>(this: IEnumerable<T>, predicate: (element: T, index: number) => boolean): IEnumerable<T>;

package/dist/operators/skip.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function skip<T>(this: IEnumerable<T>, count: number): IEnumerable<T>;

package/dist/operators/sum.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function sum<T>(this: IEnumerable<T>, selector?: (element: T) => number): number;

package/dist/operators/take-except-last.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function takeExceptLast<T>(this: IEnumerable<T>, count?: number): IEnumerable<T>;

package/dist/operators/take-from-last.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function takeFromLast<T>(this: IEnumerable<T>, count: number): IEnumerable<T>;

package/dist/operators/take-last.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function takeLast<T>(this: IEnumerable<T>, count: number): IEnumerable<T>;

package/dist/operators/take-while.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function takeWhile<T>(this: IEnumerable<T>, predicate: (element: T, index: number) => boolean): IEnumerable<T>;

package/dist/operators/take.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function take<T>(this: IEnumerable<T>, count: number): IEnumerable<T>;

package/dist/operators/then-by-descending.d.ts

@@ -0,0 +1,2 @@
+import type { Comparer, IOrderedEnumerable } from '../types.js';
+export declare function thenByDescending<T, TKey>(this: IOrderedEnumerable<T>, keySelector: (element: T) => TKey, comparer?: Comparer<TKey>): IOrderedEnumerable<T>;

package/dist/operators/then-by.d.ts

@@ -0,0 +1,2 @@
+import type { Comparer, IOrderedEnumerable } from '../types.js';
+export declare function thenBy<T, TKey>(this: IOrderedEnumerable<T>, keySelector: (element: T) => TKey, comparer?: Comparer<TKey>): IOrderedEnumerable<T>;

package/dist/operators/to-array.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function toArray<T>(this: IEnumerable<T>): T[];

package/dist/operators/to-dictionary.d.ts

@@ -0,0 +1,2 @@
+import type { IDictionary, IEnumerable } from '../types.js';
+export declare function toDictionary<T, TKey, TValue = T>(this: IEnumerable<T>, keySelector: (element: T) => TKey, elementSelector?: (element: T) => TValue, compareSelector?: (key: TKey) => unknown): IDictionary<TKey, TValue>;

package/dist/operators/to-joined-string.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function toJoinedString<T, TResult = T>(this: IEnumerable<T>, separator?: string, selector?: (element: T, index: number) => TResult): string;

package/dist/operators/to-json-string.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function toJSONString<T>(this: IEnumerable<T>, replacer?: ((key: string, value: unknown) => unknown) | (string | number)[], space?: string | number): string;

package/dist/operators/to-lookup.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable, ILookup } from '../types.js';
+export declare function toLookup<T, TKey, TElement = T>(this: IEnumerable<T>, keySelector: (element: T) => TKey, elementSelector?: (element: T) => TElement, compareSelector?: (key: TKey) => unknown): ILookup<TKey, TElement>;

package/dist/operators/to-map.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function toMap<T, TKey, TValue>(this: IEnumerable<T>, keySelector: (element: T) => TKey, valueSelector: (element: T) => TValue): Map<TKey, TValue>;

package/dist/operators/to-object.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function toObject<T, TKey extends PropertyKey, TElement = T>(this: IEnumerable<T>, keySelector: (element: T) => TKey, elementSelector?: (element: T) => TElement): Record<TKey, TElement>;

package/dist/operators/to-set.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function toSet<T>(this: IEnumerable<T>): Set<T>;

package/dist/operators/trace.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function trace<T, TValue = T>(this: IEnumerable<T>, message?: string, selector?: (element: T) => TValue): IEnumerable<T>;

package/dist/operators/traverse-breadth-first.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function traverseBreadthFirst<T, TResult = T>(this: IEnumerable<T>, childrenSelector: (element: T) => IEnumerable<T>, resultSelector?: (element: T, nestLevel: number) => TResult): IEnumerable<TResult>;

package/dist/operators/traverse-depth-first.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function traverseDepthFirst<T, TResult = T>(this: IEnumerable<T>, childrenSelector: (element: T) => IEnumerable<T>, resultSelector?: (element: T, nestLevel: number) => TResult): IEnumerable<TResult>;

package/dist/operators/union-by.d.ts

@@ -0,0 +1,2 @@
+import type { EnumerableInput, IEnumerable } from '../types.js';
+export declare function unionBy<T, TKey, TCompare = TKey>(this: IEnumerable<T>, second: EnumerableInput<T>, keySelector: (element: T) => TKey, compareSelector?: (key: TKey) => TCompare): IEnumerable<T>;

package/dist/operators/union.d.ts

@@ -0,0 +1,2 @@
+import type { EnumerableInput, IEnumerable } from '../types.js';
+export declare function union<T, TCompare>(this: IEnumerable<T>, second: EnumerableInput<T>, compareSelector?: (element: T) => TCompare): IEnumerable<T>;

package/dist/operators/weighted-sample.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function weightedSample<T>(this: IEnumerable<T>, weightSelector: (element: T) => number): IEnumerable<T>;

package/dist/operators/where-if.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function whereIf<T>(this: IEnumerable<T>, flag: boolean | string | undefined | null, filter: (element: T) => boolean): IEnumerable<T>;

package/dist/operators/where.d.ts

@@ -0,0 +1,2 @@
+import type { IEnumerable } from '../types.js';
+export declare function where<T>(this: IEnumerable<T>, predicate: (element: T, index: number) => boolean): IEnumerable<T>;