@aurigma/design-atoms-model/Collection.d.ts

Design Atoms is a part of Customer's Canvas SDK which allows for manipulating individual design elements through your code.

import Enumerable from "linq";
import { IEnumerable } from "linq";
import "linq-iterator";
import { AnyFunction } from "./Utils/Types/index";
import { Type } from "./typings/ex_linq";
export declare class Collection<T> implements Iterable<T>, IEnumerable<T> {
    protected _collection: T[];
    ["constructor"]: (getEnumerator: () => Enumerable.IEnumerator<T>) => never;
    constructor(items?: T[]);
    constructor(items?: Collection<T>);
    constructor(...items: T[]);
    setRange(items: T[] | Collection<T> | Enumerable.IEnumerable<T>): void;
    /** Adds the specified items to the end of the collection.*/
    addRange(items: T[] | Collection<T> | Enumerable.IEnumerable<T>): void;
    add(...items: T[]): void;
    push(item: T): number;
    /**
     * Inserts the specified item into the collection at the specified index.
     */
    insertAt(index: number, items: T | T[]): void;
    remove(item: T): T;
    /**
     * Removes the item at the specified index of the collection.
     */
    removeAt(index: number): T;
    removeRange(from: number, to: number): T[];
    move(oldIndex: any, newIndex: any, supressEvent?: boolean): T;
    /** Removes all items from the collection */
    clear(): void;
    replaceAt(item: T, index: number): void;
    get length(): number;
    get empty(): boolean;
    get(index: number): T;
    set(index: number, value: T): void;
    getItem(index: any): T;
    private _checkIfItemExists;
    private _itemAddedEvent;
    private _onItemAdded;
    add_itemAdded(h: (data?: {
        item: T;
        index: number;
    }) => any): void;
    remove_itemAdded(h: any): void;
    private _itemRemovedEvent;
    private _onItemRemoved;
    add_itemRemoved(h: (data?: {
        item: T;
        index: number;
    }) => any): void;
    remove_itemRemoved(h: any): void;
    private _itemMovedEvent;
    private _onItemMoved;
    add_itemMoved(h: (data?: {
        oldIndex: number;
        newIndex: number;
    }) => any): void;
    remove_itemMoved(h: (data?: {
        oldIndex: number;
        newIndex: number;
    }) => any): void;
    add_collectionChanged(h: AnyFunction): void;
    remove_collectionChanged(h: AnyFunction): void;
    [Symbol.iterator](): IterableIterator<T>;
    toArray(): T[];
    private readonly _enumerable;
    getEnumerator(): Enumerable.IEnumerator<T>;
    traverseBreadthFirst(childrenSelector: (element: T) => IEnumerable<T>): IEnumerable<T>;
    traverseBreadthFirst<TResult>(childrenSelector: (element: T) => IEnumerable<T>, resultSelector: (element: T, nestLevel: number) => TResult): IEnumerable<TResult>;
    traverseDepthFirst<TResult>(childrenSelector: (element: T) => IEnumerable<T>): IEnumerable<T>;
    traverseDepthFirst<TResult>(childrenSelector: (element: T) => IEnumerable<T>, resultSelector?: (element: T, nestLevel: number) => TResult): IEnumerable<TResult>;
    flatten(): IEnumerable<any>;
    pairwise<TResult>(selector: (prev: T, current: T) => TResult): IEnumerable<TResult>;
    scan(func: (prev: T, current: T) => T): IEnumerable<T>;
    scan<TAccumulate>(seed: TAccumulate, func: (prev: TAccumulate, current: T) => TAccumulate): IEnumerable<TAccumulate>;
    select<TResult>(selector: (element: T, index: number) => TResult): IEnumerable<TResult>;
    selectMany<TOther>(collectionSelector: (element: T, index: number) => IEnumerable<TOther>): IEnumerable<TOther>;
    selectMany<TCollection, TResult>(collectionSelector: (element: T, index: number) => IEnumerable<TCollection>, resultSelector: (outer: T, inner: TCollection) => TResult): IEnumerable<TResult>;
    selectMany<TOther>(collectionSelector: (element: T, index: number) => TOther[]): IEnumerable<TOther>;
    selectMany<TCollection, TResult>(collectionSelector: (element: T, index: number) => TCollection[], resultSelector: (outer: T, inner: TCollection) => TResult): IEnumerable<TResult>;
    selectMany<TOther>(collectionSelector: (element: T, index: number) => {
        [x: number]: TOther;
        length: number;
    }): IEnumerable<TOther>;
    selectMany<TCollection, TResult>(collectionSelector: (element: T, index: number) => {
        [x: number]: TCollection;
        length: number;
    }, resultSelector: (outer: T, inner: TCollection) => TResult): IEnumerable<TResult>;
    where(predicate: (element: T, index: number) => boolean): IEnumerable<T>;
    choose(selector: (element: T, index: number) => T): IEnumerable<T>;
    ofType<TOf>(type: Type<TOf>): IEnumerable<TOf>;
    zip<TResult>(second: IEnumerable<T>, resultSelector: (first: T, second: T, index: number) => TResult): IEnumerable<TResult>;
    zip<TResult>(second: {
        [x: number]: T;
        length: number;
    }, resultSelector: (first: T, second: T, index: number) => TResult): IEnumerable<TResult>;
    zip<TResult>(second: T[], resultSelector: (first: T, second: T, index: number) => TResult): IEnumerable<TResult>;
    zip<TResult>(...params: any[]): IEnumerable<TResult>;
    merge<TResult>(...params: IEnumerable<T>[]): IEnumerable<T>;
    merge<TResult>(...params: {
        [x: number]: T;
        length: number;
    }[]): IEnumerable<T>;
    merge<TResult>(...params: T[][]): IEnumerable<T>;
    join<TInner, TKey, TResult>(inner: IEnumerable<TInner>, outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: TInner) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>;
    join<TInner, TKey, TResult>(inner: {
        [x: number]: TInner;
        length: number;
    }, outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: TInner) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>;
    join<TInner, TKey, TResult>(inner: TInner[], outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: TInner) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>;
    groupJoin<TInner, TKey, TResult>(inner: IEnumerable<TInner>, outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: TInner) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>;
    groupJoin<TInner, TKey, TResult>(inner: {
        [x: number]: TInner;
        length: number;
    }, outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: TInner) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>;
    groupJoin<TInner, TKey, TResult>(inner: TInner[], outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: TInner) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>;
    all(predicate: (element: T) => boolean): boolean;
    any(predicate?: (element: T) => boolean): boolean;
    isEmpty(): boolean;
    concat(...sequences: IEnumerable<T>[]): IEnumerable<T>;
    concat(...sequences: {
        [x: number]: T;
        length: number;
    }[]): IEnumerable<T>;
    concat(...sequences: T[]): IEnumerable<T>;
    alternate(alternateValue: T): IEnumerable<T>;
    alternate(alternateSequence: {
        [x: number]: T;
        length: number;
    }): IEnumerable<T>;
    alternate(alternateSequence: IEnumerable<T>): IEnumerable<T>;
    alternate(alternateSequence: T[]): IEnumerable<T>;
    defaultIfEmpty(defaultValue?: T): IEnumerable<T>;
    distinct(): IEnumerable<T>;
    distinct<TCompare>(compareSelector: (element: T) => TCompare): IEnumerable<T>;
    distinctUntilChanged(): IEnumerable<T>;
    distinctUntilChanged<TCompare>(compareSelector: (element: T) => TCompare): IEnumerable<T>;
    except(second: {
        [x: number]: T;
        length: number;
    }): IEnumerable<T>;
    except<TCompare>(second: {
        [x: number]: T;
        length: number;
    }, compareSelector: (element: T) => TCompare): IEnumerable<T>;
    except(second: IEnumerable<T>): IEnumerable<T>;
    except<TCompare>(second: IEnumerable<T>, compareSelector: (element: T) => TCompare): IEnumerable<T>;
    except(second: T[]): IEnumerable<T>;
    except<TCompare>(second: T[], compareSelector: (element: T) => TCompare): IEnumerable<T>;
    intersect(second: {
        [x: number]: T;
        length: number;
    }): IEnumerable<T>;
    intersect<TCompare>(second: {
        [x: number]: T;
        length: number;
    }, compareSelector: (element: T) => TCompare): IEnumerable<T>;
    intersect(second: IEnumerable<T>): IEnumerable<T>;
    intersect<TCompare>(second: IEnumerable<T>, compareSelector: (element: T) => TCompare): IEnumerable<T>;
    intersect(second: T[]): IEnumerable<T>;
    intersect<TCompare>(second: T[], compareSelector: (element: T) => TCompare): IEnumerable<T>;
    union(second: {
        [x: number]: T;
        length: number;
    }): IEnumerable<T>;
    union<TCompare>(second: {
        [x: number]: T;
        length: number;
    }, compareSelector: (element: T) => TCompare): IEnumerable<T>;
    union(second: IEnumerable<T>): IEnumerable<T>;
    union<TCompare>(second: IEnumerable<T>, compareSelector: (element: T) => TCompare): IEnumerable<T>;
    union(second: T[]): IEnumerable<T>;
    union<TCompare>(second: T[], compareSelector: (element: T) => TCompare): IEnumerable<T>;
    sequenceEqual(second: {
        [x: number]: T;
        length: number;
    }): boolean;
    sequenceEqual<TCompare>(second: {
        [x: number]: T;
        length: number;
    }, compareSelector: (element: T) => TCompare): boolean;
    sequenceEqual(second: IEnumerable<T>): boolean;
    sequenceEqual<TCompare>(second: IEnumerable<T>, compareSelector: (element: T) => TCompare): boolean;
    sequenceEqual(second: T[]): boolean;
    sequenceEqual<TCompare>(second: T[], compareSelector: (element: T) => TCompare): boolean;
    orderBy<TKey>(keySelector: (element: T) => TKey): Enumerable.IOrderedEnumerable<T>;
    orderByDescending<TKey>(keySelector: (element: T) => TKey): Enumerable.IOrderedEnumerable<T>;
    reverse(): IEnumerable<T>;
    shuffle(): IEnumerable<T>;
    weightedSample(weightSelector: (element: T) => number): IEnumerable<T>;
    groupBy<TKey>(keySelector: (element: T) => TKey): IEnumerable<Enumerable.IGrouping<TKey, T>>;
    groupBy<TKey, TElement>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement): IEnumerable<Enumerable.IGrouping<TKey, TElement>>;
    groupBy<TKey, TElement, TResult>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement, resultSelector: (key: TKey, element: IEnumerable<TElement>) => TResult): IEnumerable<TResult>;
    groupBy<TKey, TElement, TResult, TCompare>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement, resultSelector: (key: TKey, element: IEnumerable<TElement>) => TResult, compareSelector: (element: T) => TCompare): IEnumerable<TResult>;
    partitionBy<TKey>(keySelector: (element: T) => TKey): IEnumerable<Enumerable.IGrouping<TKey, any>>;
    partitionBy<TKey, TElement>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement): IEnumerable<Enumerable.IGrouping<TKey, TElement>>;
    partitionBy<TKey, TElement, TResult>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement, resultSelector: (key: TKey, element: IEnumerable<TElement>) => TResult): IEnumerable<TResult>;
    partitionBy<TKey, TElement, TResult, TCompare>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement, resultSelector: (key: TKey, element: IEnumerable<TElement>) => TResult, compareSelector: (element: T) => TCompare): IEnumerable<TResult>;
    buffer(count: number): IEnumerable<T[]>;
    aggregate(func: (prev: T, current: T) => T): T;
    aggregate<TAccumulate>(seed: TAccumulate, func: (prev: TAccumulate, current: T) => TAccumulate): TAccumulate;
    aggregate<TAccumulate, TResult>(seed: TAccumulate, func: (prev: TAccumulate, current: T) => TAccumulate, resultSelector: (last: TAccumulate) => TResult): TResult;
    average(selector?: (element: T) => number): number;
    count(predicate?: (element: T, index: number) => boolean): number;
    max(selector?: (element: T) => number): number;
    min(selector?: (element: T) => number): number;
    maxBy<TKey>(keySelector: (element: T) => TKey): T;
    minBy<TKey>(keySelector: (element: T) => TKey): T;
    sum(selector?: (element: T) => number): number;
    elementAt(index: number): T;
    elementAtOrDefault(index: number, defaultValue?: T): T;
    first(predicate?: (element: T, index: number) => boolean): T;
    firstOrDefault(predicate?: ((element: T, index: number) => boolean) | T, defaultValue?: T): T;
    last(predicate?: (element: T, index: number) => boolean): T;
    lastOrDefault(predicate?: ((element: T, index: number) => boolean) | T, defaultValue?: T): T;
    single(predicate?: (element: T, index: number) => boolean): T;
    singleOrDefault(predicate?: (element: T, index: number) => boolean, defaultValue?: T): T;
    skip(count: number): IEnumerable<T>;
    skipWhile(predicate: (element: T, index: number) => boolean): IEnumerable<T>;
    take(count: number): IEnumerable<T>;
    takeWhile(predicate: (element: T, index: number) => boolean): IEnumerable<T>;
    takeExceptLast(count?: number): IEnumerable<T>;
    takeFromLast(count: number): IEnumerable<T>;
    indexOf(item: T): number;
    indexOf(predicate: (element: T, index: number) => boolean): number;
    lastIndexOf(item: T): number;
    lastIndexOf(predicate: (element: T, index: number) => boolean): number;
    asEnumerable(): IEnumerable<T>;
    cast<TResult>(): IEnumerable<TResult>;
    toLookup<TKey>(keySelector: (element: T) => TKey): Enumerable.ILookup<TKey, T>;
    toLookup<TKey, TElement>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement): Enumerable.ILookup<TKey, TElement>;
    toLookup<TKey, TElement, TCompare>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement, compareSelector: (key: TKey) => TCompare): Enumerable.ILookup<TKey, TElement>;
    toObject(keySelector: (element: T) => any, elementSelector?: (element: T) => any): Object;
    toDictionary<TKey>(keySelector: (element: T) => TKey): Enumerable.IDictionary<TKey, any>;
    toDictionary<TKey, TValue>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TValue): Enumerable.IDictionary<TKey, TValue>;
    toDictionary<TKey, TValue, TCompare>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TValue, compareSelector: (key: TKey) => TCompare): Enumerable.IDictionary<TKey, TValue>;
    toJSONString(replacer: (key: string, value: any) => any): string;
    toJSONString(replacer: any[]): string;
    toJSONString(replacer: (key: string, value: any) => any, space: any): string;
    toJSONString(replacer: any[], space: any): string;
    toJoinedString(separator?: string): string;
    toJoinedString<TResult>(separator: string, selector: (element: T, index: number) => TResult): string;
    doAction(action: (element: T, index: number) => void): IEnumerable<T>;
    doAction(action: (element: T, index: number) => boolean): IEnumerable<T>;
    forEach(action: (element: T, index: number) => void): void;
    forEach(action: (element: T, index: number) => boolean): void;
    write(separator?: string): void;
    write<TResult>(separator: string, selector: (element: T) => TResult): void;
    writeLine(): void;
    writeLine<TResult>(selector: (element: T) => TResult): void;
    force(): void;
    letBind<TResult>(func: (source: IEnumerable<T>) => {
        [x: number]: TResult;
        length: number;
    }): IEnumerable<TResult>;
    letBind<TResult>(func: (source: IEnumerable<T>) => TResult[]): IEnumerable<TResult>;
    letBind<TResult>(func: (source: IEnumerable<T>) => IEnumerable<TResult>): IEnumerable<TResult>;
    share(): Enumerable.IDisposableEnumerable<T>;
    memoize(): Enumerable.IDisposableEnumerable<T>;
    catchError(handler: (exception: any) => void): IEnumerable<T>;
    finallyAction(finallyAction: () => void): IEnumerable<T>;
    log(): IEnumerable<T>;
    log<TValue>(selector: (element: T) => TValue): IEnumerable<T>;
    trace(message?: string): IEnumerable<T>;
    trace<TValue>(message: string, selector: (element: T) => TValue): IEnumerable<T>;
    insert(index: number, second: Enumerable.IEnumerable<T>): Enumerable.IEnumerable<T>;
    insert(index: number, second: {
        [x: number]: T;
        length: number;
    }): Enumerable.IEnumerable<T>;
    contains(value: T): boolean;
    contains<TCompare>(value: T, compareSelector?: (element: T) => TCompare): boolean;
}