@clickview/lite 0.0.17-rc.0 → 0.0.18-dev.0

package/dist/libs/common/src/backbone/services/data-providers/SignalRDataProvider.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="jquery" />
+import * as Marionette from 'backbone.marionette';
+import { DataProvider, DataProviderResponseOptions } from "../../interfaces/DataProvider";
+import { DataServiceError } from "../../interfaces/DataServiceError";
+export interface SignalRDataProviderOptions {
+    hubName: string;
+    endpoint: string;
+    authEndpoint: string;
+    subscribeEvent?: string;
+    logging?: boolean;
+    lazy?: boolean;
+    reconnectTimeout?: number;
+    reconnectAttempts?: number;
+}
+export interface SocketToken {
+    Token: string;
+}
+export declare abstract class SignalRDataProvider extends Marionette.Object implements DataProvider {
+    private connection;
+    private hub;
+    private connectionState;
+    private authEndpoint;
+    private subscribeEvent;
+    private reconnectTimeout;
+    private reconnectAttempts;
+    private reconnectTries;
+    constructor(options: SignalRDataProviderOptions);
+    private setProviderOptions;
+    openConnection(): JQueryPromise<any>;
+    connect(): JQueryPromise<any>;
+    start(data: any): JQueryPromise<any>;
+    stop(async?: boolean, notifyServer?: boolean): any;
+    private attachSocketEvents;
+    private onReconnect;
+    private onConnectionError;
+    private getConnectionToken;
+    private setConnectionState;
+    private isConnectedOrConnecting;
+    create<T>(resource: string, obj: T, options: DataProviderResponseOptions): void;
+    read<T>(resource: string, options: DataProviderResponseOptions): void;
+    update<T>(resource: string, obj: T, options: DataProviderResponseOptions): void;
+    delete(resource: string, options: DataProviderResponseOptions): void;
+    parseError(...args: any[]): DataServiceError;
+    private rpc;
+    private subscribe;
+}

package/dist/libs/common/src/backbone/utils/ConcurrencyHelper.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Not really for concurrency 😂
+ * But useful in circumstances where we need to manually wait for
+ * a sequence of callbacks or other resources to execute and don't
+ * want the overhead of promises.
+ */
+export declare class ConcurrencyHelper {
+    private value;
+    constructor(initialValue: number);
+    increment(): void;
+    decrement(): void;
+    getValue(): number;
+}

package/dist/libs/common/src/backbone/utils/DataServiceErrorHelper.d.ts

@@ -0,0 +1,2 @@
+import { ObjectHash } from 'backbone';
+export declare const DataServiceErrorHelper: ObjectHash;

package/dist/libs/common/src/backbone/utils/FunctionHelper.d.ts

@@ -0,0 +1,8 @@
+import * as _ from 'underscore';
+export declare const FunctionHelper: {
+    debounce<T extends Function>(fn: T, wait: number, immediate?: boolean): T & _.Cancelable;
+    throttle<T_1 extends Function>(fn: T_1, wait: number, options?: _.ThrottleSettings): T_1 & _.Cancelable;
+    isFunction(object: any): object is Function;
+    useIdentity<T_2>(): (...args: any[]) => T_2;
+    memoize<T_3 = Function>(fn: T_3, hashFn?: (...args: any[]) => string): T_3;
+};

package/dist/libs/common/src/backbone/utils/LocalStorageHelper.d.ts

@@ -0,0 +1,58 @@
+export declare enum StorageType {
+    LocalStorage = "localStorage",
+    SessionStorage = "sesstionStorage"
+}
+export interface StorageHelper {
+    get(key: string): any;
+    set(key: string, data: any): boolean;
+    remove(key: string): any;
+    length(): number;
+    clear(): any;
+    cacheSet(key: string, data: any, expire?: number): any;
+    cacheGet(key: string): any;
+    cacheExists(key: string): boolean;
+    cacheRemove(key: string): any;
+    cacheFlush(): void;
+}
+interface StaticBaseStorageHelperOptions {
+    type: StorageType;
+}
+declare abstract class StaticBaseStorageHelper implements StorageHelper {
+    private cachePrefix;
+    private expireTime;
+    private hasSupport;
+    private storage;
+    protected type: StorageType;
+    protected constructor(options: StaticBaseStorageHelperOptions);
+    get(key: string): any;
+    set(key: string, data: any): boolean;
+    remove(key: string): void;
+    length(): number;
+    clear(): void;
+    /**
+     * Caching Ops
+     */
+    cacheSet(key: string, data: any, expire?: number): boolean;
+    cacheGet(key: string): any;
+    cacheExists(key: string): boolean;
+    cacheRemove(key: string): void;
+    cacheFlush(): void;
+    /**
+     * Privates
+     */
+    private cacheClean;
+    private isExpired;
+    private getCurrentTime;
+    private hasBrowserSupport;
+}
+declare class StaticLocalStorageHelper extends StaticBaseStorageHelper {
+    protected static instance: StaticLocalStorageHelper;
+    static get Instance(): StaticLocalStorageHelper;
+}
+declare class StaticSessionStorageHelper extends StaticBaseStorageHelper {
+    protected static instance: StaticSessionStorageHelper;
+    static get Instance(): StaticSessionStorageHelper;
+}
+export declare const LocalStorageHelper: StaticLocalStorageHelper;
+export declare const SessionStorageHelper: StaticSessionStorageHelper;
+export {};

package/dist/libs/common/src/backbone/utils/UrlHelper.d.ts

@@ -0,0 +1,13 @@
+import { ObjectHash } from 'backbone';
+interface FilterParams {
+    limit?: number;
+    cursor?: string;
+    before?: string;
+}
+export declare const UrlHelper: {
+    urlBuilder(base: string, queryStringObj: ObjectHash): string;
+    buildFilter(params: FilterParams): string;
+    makeHttps(url: string): string;
+    safeUrlConcat(baseUrl: string, path: string): string;
+};
+export {};

package/dist/libs/common/src/backbone/utils/UserAgentHelper.d.ts

@@ -0,0 +1,7 @@
+import { ObjectHash } from 'backbone';
+export declare const UserAgentHelper: {
+    getDeviceType(): string;
+    getOperatingSystem(): ObjectHash;
+    getBrowser(): ObjectHash;
+    isTouchScreen(): boolean;
+};

package/dist/libs/common/src/react/components/BackboneViewWrapper.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { BaseView } from "../../backbone/core/BaseView";
+import { HashObject } from "../interfaces/HashObject";
+interface BackboneViewWrapperProps {
+    view: new (options: HashObject) => BaseView;
+    options?: HashObject;
+    className?: string;
+}
+export declare function BackboneViewWrapper({ view, options, className }: BackboneViewWrapperProps): JSX.Element;
+export {};

package/dist/libs/common/src/react/core/ReactApplication.d.ts

@@ -0,0 +1,9 @@
+import { ObjectHash } from 'backbone';
+import { BaseApplication } from "../../backbone/core/BaseApplication";
+import { LayoutOptions } from "../../backbone/core/LayoutService";
+import { ReactLayoutView, ReactLayoutViewOptions } from './ReactLayoutView';
+export declare class ReactApplication extends BaseApplication {
+    protected layout: ReactLayoutView;
+    protected layoutOptions: LayoutOptions<ReactLayoutViewOptions>;
+    protected onShowAlert(options: ObjectHash): void;
+}

package/dist/libs/common/src/react/core/ReactLayoutView.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import { BaseLayoutViewOptions, BaseLayoutView } from "../../backbone/core/BaseLayoutView";
+export interface ReactLayoutViewOptions extends BaseLayoutViewOptions {
+    alertRegion?: string;
+}
+export declare class ReactLayoutView extends BaseLayoutView {
+    protected options: ReactLayoutViewOptions;
+    private isReactComponent;
+    showChildView(regionName: string, component: any): void;
+    private showChildReactComponent;
+    private renderChildReactComponent;
+    protected wrapWithStore(child: React.ReactElement): React.ReactElement;
+}

package/dist/libs/common/src/react/flight/FlightHelpers.d.ts

@@ -0,0 +1,13 @@
+import { ApplicationState } from "../interfaces/ApplicationState";
+import { Request, Response, Dispatch } from './interfaces';
+export declare function emptyResponse<T>(): Response<T>;
+export declare function getResponse<T>(state: ApplicationState, key: string): Response<T>;
+export declare function getFetch(dispatch: Dispatch, request: Request): () => void;
+export declare function fetch(dispatch: Dispatch, request: Request): void;
+export declare function useGetFetch(request: Request): () => void;
+interface GetResponseOptions {
+    optimize: boolean;
+}
+export declare function useGetResponse<T>(key: string, options?: GetResponseOptions): Response<T>;
+export declare function useBasicFetch<T>(request: Request, options?: GetResponseOptions): Response<T>;
+export {};

package/dist/libs/common/src/react/flight/FlightMiddleware.d.ts

@@ -0,0 +1,11 @@
+import { Dispatch, Middleware, AnyAction } from 'redux';
+import { HashObject } from "../interfaces/HashObject";
+import { ApplicationState } from "../interfaces/ApplicationState";
+import { HttpRequest } from './interfaces';
+interface MiddlewareOptions {
+    fetchData: HttpRequest;
+    bootstrappedData?: HashObject;
+    defaultExpiryTime?: number;
+}
+export declare function createMiddleware(options: MiddlewareOptions): Middleware<{}, ApplicationState, Dispatch<AnyAction>>;
+export {};

package/dist/libs/common/src/react/flight/FlightReducer.d.ts

@@ -0,0 +1,2 @@
+import { FlightState, Action } from './interfaces';
+export declare function FlightReducer(state: FlightState, action: Action): FlightState;

package/dist/libs/common/src/react/flight/FlightSimulator.d.ts

@@ -0,0 +1,24 @@
+import { HashObject } from "../interfaces/HashObject";
+/**
+ * This is a very basic implementation and we almost definitely will
+ * need to extend upon this, so please don't be afraid to add to it.
+ */
+export declare const Simulator: {
+    getAll(name: string, init?: HashObject<any>[]): HashObject<any>[];
+    get(name: string, id: string): HashObject<any>;
+    create(name: string, item: HashObject<any>): HashObject<any>;
+    update(name: string, item: HashObject<any>): HashObject<any>;
+    delete(name: string, ids: string | string[]): void;
+    /**
+     *
+     * @param objectName - the name your object can be found under in local storage (e.g. `classrooms`).
+     * @param objectId - the id of the object you want to associate something to.
+     * @param assocName - the field name of your assoc, which will go on your object (e.g. `students`).
+     * @param flightSimName - the name your assoc objects will be created under (e.g. `school:students`).
+     * @param assocObject - the object you're creating and associating.
+     *
+     * Having a difficult time coming up with good param names here. Feel free to update, ty
+     */
+    assoc(objectName: string, objectId: string, assocName: string, flightSimName: string, assocObjects: any): any;
+    dissoc(objectName: string, objectId: string, assocName: string, ids: string | string[]): HashObject<any>[];
+};

package/dist/libs/common/src/react/flight/constants/Actions.d.ts

@@ -0,0 +1,7 @@
+export declare const Actions: {
+    API_REQUEST: string;
+    API_REPONSE: string;
+    API_ERROR: string;
+    INVALIDATE: string;
+    UPDATE: string;
+};

package/dist/libs/common/src/react/flight/constants/index.d.ts

@@ -0,0 +1 @@
+export * from './Actions';

package/dist/libs/common/src/react/flight/data-layers/AjaxRequest.d.ts

@@ -0,0 +1,2 @@
+import { HttpRequestOptions } from '../interfaces';
+export declare function ajaxRequest(options: HttpRequestOptions): void;

package/dist/libs/common/src/react/flight/data-layers/index.d.ts

@@ -0,0 +1 @@
+export * from './AjaxRequest';

package/dist/libs/common/src/react/flight/enums/RequestStatus.d.ts

@@ -0,0 +1,6 @@
+export declare enum RequestStatus {
+    None = "None",
+    Fetching = "Fetching",
+    Success = "Success",
+    Error = "Error"
+}

package/dist/libs/common/src/react/flight/enums/index.d.ts

@@ -0,0 +1 @@
+export * from './RequestStatus';

package/dist/libs/common/src/react/flight/index.d.ts

@@ -0,0 +1,9 @@
+export * from './constants';
+export * from './enums';
+export * from './interfaces';
+export * from './data-layers';
+export * from './normalizer';
+export * from './FlightHelpers';
+export * from './FlightMiddleware';
+export * from './FlightReducer';
+export * from './FlightSimulator';

package/dist/libs/common/src/react/flight/interfaces/Action.d.ts

@@ -0,0 +1,28 @@
+import { NormalizedEntities, Request, Normalized } from '..';
+import { Xhr } from "../../../backbone/interfaces/Xhr";
+interface BaseAction {
+    type: string;
+    request: Request;
+}
+export interface RequestAction extends BaseAction {
+}
+interface BaseResponseAction extends BaseAction {
+    timestamp: number;
+    xhr?: Xhr;
+}
+export interface ResponseAction extends BaseResponseAction {
+    result: Normalized;
+    entities: NormalizedEntities;
+}
+export interface ErrorAction extends BaseResponseAction {
+    errorResponse?: any;
+}
+export interface InvalidateAction extends BaseAction {
+    keys?: string | string[];
+}
+export interface UpdateAction extends BaseAction {
+    result: Normalized;
+    entities: NormalizedEntities;
+}
+export declare type Action = RequestAction | ResponseAction | ErrorAction | InvalidateAction;
+export {};

package/dist/libs/common/src/react/flight/interfaces/Dispatch.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { RequestAction } from './Action';
+export declare type Dispatch = React.Dispatch<RequestAction>;

package/dist/libs/common/src/react/flight/interfaces/FlightState.d.ts

@@ -0,0 +1,22 @@
+import { RequestStatus } from '../enums';
+import { Request } from './Request';
+import { HashObject } from "../../interfaces/HashObject";
+export interface FlightState {
+    readonly entities: NormalizedEntities;
+    readonly resources: Resources;
+}
+export interface NormalizedEntities {
+    readonly [key: string]: object;
+}
+export interface Resource {
+    readonly request: Request;
+    readonly status: RequestStatus;
+    readonly response?: string | string[] | HashObject | HashObject[];
+    readonly errorResponse?: any;
+    readonly timestamp?: number;
+    readonly statusCode?: number;
+    readonly entityIds?: string[];
+}
+export interface Resources {
+    readonly [key: string]: Resource;
+}

package/dist/libs/common/src/react/flight/interfaces/HttpRequest.d.ts

@@ -0,0 +1,24 @@
+import { HttpVerbs } from "../../../backbone/enums/HttpVerbs";
+import { HashObject } from "../../interfaces/HashObject";
+import { Xhr } from "../../../backbone/interfaces/Xhr";
+interface SuccessFunction {
+    (data: HashObject, xhr: Xhr): void;
+}
+interface ErrorFunction {
+    (xhr: Xhr): void;
+}
+interface AlwaysFunction {
+    (): void;
+}
+export interface HttpRequestOptions {
+    resource: string;
+    type: HttpVerbs;
+    data?: HashObject;
+    success: SuccessFunction;
+    error: ErrorFunction;
+    always?: AlwaysFunction;
+}
+export interface HttpRequest {
+    (options: HttpRequestOptions): void;
+}
+export {};

package/dist/libs/common/src/react/flight/interfaces/NormalizeOptions.d.ts

@@ -0,0 +1,4 @@
+export interface NormalizeOptions {
+    namespace?: string;
+    idAttribute?: string;
+}

package/dist/libs/common/src/react/flight/interfaces/NormalizedData.d.ts

@@ -0,0 +1,7 @@
+import { NormalizedEntities } from './FlightState';
+import { HashObject } from "../../interfaces/HashObject";
+export declare type Normalized = string | string[] | HashObject | HashObject[];
+export interface NormalizedData {
+    result: Normalized;
+    entities: NormalizedEntities;
+}

package/dist/libs/common/src/react/flight/interfaces/Request.d.ts

@@ -0,0 +1,29 @@
+import { HttpVerbs } from "../../../backbone/enums/HttpVerbs";
+import { HashObject } from "../../interfaces/HashObject";
+import { Xhr, SimulatedXhr } from "../../../backbone/interfaces/Xhr";
+import { NormalizeOptions } from './NormalizeOptions';
+import { Resources } from './FlightState';
+import { UpdateStateOptions } from './UpdateStateOptions';
+export interface Request {
+    key: string;
+    url: string;
+    type?: HttpVerbs;
+    expiryTime?: number;
+    data?: HashObject | HashObject[];
+    normalize?: boolean;
+    normalizeOptions?: NormalizeOptions;
+    formatData?: (data: HashObject | HashObject[]) => HashObject | HashObject[];
+    bootstrapName?: string;
+    invalidationKeys?: string | string[];
+    updateState?: UpdateStateOptions | UpdateStateOptions[];
+    success?: (data: HashObject | HashObject[] | number) => void;
+    error?: (Xhr: Xhr) => void;
+    always?: () => void;
+    maintainState?: (resources: Resources) => Resources;
+}
+export interface SimulatedRequest extends Request {
+    successResponse?: () => (HashObject | HashObject[]);
+    errorResponse?: () => SimulatedXhr;
+    timeout?: number;
+    noResponse?: boolean;
+}

package/dist/libs/common/src/react/flight/interfaces/Response.d.ts

@@ -0,0 +1,9 @@
+import { HttpStatus } from "../../../backbone/enums/HttpStatus";
+export interface Response<T> {
+    data?: T;
+    statusCode?: HttpStatus;
+    shouldFetch: boolean;
+    isFetching: boolean;
+    hasError: boolean;
+    isComplete: boolean;
+}

package/dist/libs/common/src/react/flight/interfaces/UpdateStateOptions.d.ts

@@ -0,0 +1,15 @@
+import { HashObject } from "../../interfaces/HashObject";
+export interface UpdateStateOptions {
+    keys: string | string[];
+    /**
+     * updateData takes a hash where the keys are keys for resources
+     * from the application state that match the keys above.
+     * The value is the denormalized (where applicable) data corresponding
+     * to that resource.
+     */
+    updateData: (data: {
+        [key: string]: HashObject;
+    }) => {
+        [key: string]: HashObject;
+    };
+}

package/dist/libs/common/src/react/flight/interfaces/index.d.ts

@@ -0,0 +1,9 @@
+export * from './Request';
+export * from './Action';
+export * from './FlightState';
+export * from './HttpRequest';
+export * from './NormalizedData';
+export * from './Response';
+export * from './NormalizeOptions';
+export * from './Dispatch';
+export * from './UpdateStateOptions';

package/dist/libs/common/src/react/flight/normalizer/Denormalizer.d.ts

@@ -0,0 +1,3 @@
+import { HashObject } from "../../interfaces/HashObject";
+import { NormalizedEntities, Normalized } from '../interfaces';
+export declare function denormalize(ids: Normalized, collection: NormalizedEntities): HashObject | HashObject[];

package/dist/libs/common/src/react/flight/normalizer/Normalizer.d.ts

@@ -0,0 +1,8 @@
+import { HashObject } from "../../interfaces/HashObject";
+import { NormalizeOptions, NormalizedData } from '../interfaces';
+/**
+ * This is a pure function, while normalize() above is not.
+ * normalize() manipulates it's parameters. If we ever write unit tests for this
+ * only test this function, not the above ones.
+ */
+export declare function normalize(data: HashObject | HashObject[], options?: NormalizeOptions): NormalizedData;

package/dist/libs/common/src/react/flight/normalizer/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Normalizer';
+export * from './Denormalizer';

package/dist/libs/common/src/react/flight/utils/SimulatorHelper.d.ts

@@ -0,0 +1,5 @@
+import { Request, HttpRequestOptions } from '../interfaces';
+export declare const SimulatorHelper: {
+    isSimulated(request: Request): boolean;
+    simulateFetchData(options: HttpRequestOptions, request: Request): void;
+};

package/dist/libs/common/src/react/flight/utils/StateHelper.d.ts

@@ -0,0 +1,11 @@
+import { FlightState } from '../interfaces';
+export declare const StateHelper: {
+    /**
+     * Returns a map of keys state.resources which match the keys param.
+     *
+     * @param state FlightState.
+     * @param keys a key or array of keys to match on.
+     * @param requestKey optionally include the current request key to exclude it from the map.
+     */
+    getMatchingKeyMap(state: FlightState, keys: string | string[], requestKey?: string): any;
+};

package/dist/libs/common/src/react/flight/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './StateHelper';
+export * from './SimulatorHelper';

package/dist/libs/common/src/react/hooks/UseInstance.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Hook to retrieve an instance from InstanceManager.
+ * It handles releasing the instance in the cleanup function.
+ * @param instanceName
+ */
+export declare function useInstance<T>(instanceName: string): T;

package/dist/libs/common/src/react/hooks/UseRenderBackboneView.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+/**
+ * The ref returned from useRenderBackboneView must be
+ * set on the element that the view is to be rendered
+ * into, e.g. <div ref={ref} />.
+ * The ref allows us to access to the DOM (https://reactjs.org/docs/refs-and-the-dom.html)
+ *
+ * @param view an instance of a Backbone view
+ */
+export declare function useRenderBackboneView(view: any, dependencies?: any[]): React.MutableRefObject<any>;

package/dist/libs/common/src/react/hooks/UseService.d.ts

@@ -0,0 +1,2 @@
+import { BaseService } from "../../backbone/core/BaseService";
+export declare function useService<T extends BaseService>(serviceName: string): T;

package/dist/libs/common/src/react/index.d.ts

@@ -0,0 +1,2 @@
+import * as Flight from './flight';
+export { Flight };

package/dist/libs/common/src/react/interfaces/ApplicationData.d.ts

@@ -0,0 +1,3 @@
+export interface ApplicationData {
+    version: string;
+}

package/dist/libs/common/src/react/interfaces/ApplicationState.d.ts

@@ -0,0 +1,6 @@
+import { ApplicationData } from "./ApplicationData";
+import { FlightState } from '../flight/interfaces/FlightState';
+export interface ApplicationState {
+    readonly flightData: FlightState;
+    readonly applicationData: ApplicationData;
+}

package/dist/libs/common/src/react/interfaces/BaseReducerActions.d.ts

@@ -0,0 +1,4 @@
+export interface ReducerActions<TActionType, TPayloadType = any> {
+    type: TActionType;
+    payload?: TPayloadType;
+}

package/dist/libs/common/src/react/interfaces/HashObject.d.ts

@@ -0,0 +1,3 @@
+export interface HashObject<T = any> {
+    [key: string]: T;
+}

package/dist/libs/common/src/react/interfaces/index.d.ts

@@ -0,0 +1,4 @@
+export * from './ApplicationData';
+export * from './ApplicationState';
+export * from './BaseReducerActions';
+export * from './HashObject';

package/dist/libs/common/src/react/middleware/ApplicationMiddleware.d.ts

@@ -0,0 +1,9 @@
+import { Dispatch, Middleware, AnyAction } from 'redux';
+import { ApplicationState } from "../interfaces/ApplicationState";
+import { BaseError } from "../../backbone/core/BaseError";
+interface MiddlewareOptions {
+    oldVersionError?: BaseError;
+    authenticationError?: BaseError;
+}
+export declare function createApplicationMiddleware(options: MiddlewareOptions): Middleware<{}, ApplicationState, Dispatch<AnyAction>>;
+export {};

package/dist/libs/common/src/react/reducers/ApplicationDataReducer.d.ts

@@ -0,0 +1,3 @@
+import { ApplicationData } from "../interfaces/ApplicationData";
+import { Action } from "../flight/interfaces";
+export declare function ApplicationDataReducer(state: ApplicationData, action: Action): ApplicationData;

package/dist/libs/common/src/react/utils/ArrayHelper.d.ts

@@ -0,0 +1,39 @@
+/// <reference types="react" />
+import * as _ from 'underscore';
+declare type Iterator<T, TResult = T> = (value: T, index: number, list: T[]) => TResult;
+export declare const ArrayHelper: {
+    first<T>(arr: T[]): T;
+    firstFew<T_1>(arr: T_1[], count: number): T_1[];
+    last<T_2>(arr: T_2[]): T_2;
+    lastFew<T_3>(arr: T_3[], count: number): T_3[];
+    max<T_4, TResult = T_4>(arr: T_4[], iterator?: Iterator<T_4, TResult>): T_4;
+    cloneAndReplaceAtIdx<T_5>(arr: T_5[], idx: number, newVal: T_5, defaultValue?: any): T_5[];
+    moveItem<T_6>(arr: T_6[], fromIdx: number, toIdx: number): T_6[];
+    isEmpty<T_7>(arr: T_7[]): boolean;
+    findIndex<T_8>(arr: T_8[], predicate: (item: T_8) => boolean): number;
+    where<T_9, U extends {}>(arr: T_9[], properties: U): T_9[];
+    groupBy<T_10>(arr: T_10[], property: string): {
+        [index: string]: T_10[];
+    };
+    flatten<T_11>(arr: T_11[], shallow?: boolean): T_11[];
+    intersection<T_12>(...arrays: T_12[][]): T_12[];
+    /**
+     * Add a value to an array, or if it is already in the array, remove it.
+     *
+     * @param arr array of values
+     * @param value value to be added or removed.
+     */
+    addOrRemove<T_13 = import("react").Key>(arr: T_13[], value: T_13): T_13[];
+    addOrRemoveImmutable<T_14>(arr: T_14[], value: T_14): T_14[];
+    /**
+     * Returns a (stably) sorted copy of list, ranked in ascending order
+     * by the results of running each value through iteratee.
+     *
+     * @param arr array of values
+     * @param iteratee an iterator function or a string name of the property to sort by.
+     */
+    sortBy<T_15 extends {}, TSort = T_15>(arr: T_15[], iteratee?: Iterator<T_15, TSort> | keyof T_15): T_15[];
+    chunk<T_16>(array: _.Collection<T_16>, count: number): T_16[][];
+    uniq<T_17>(array: _.List<T_17>): T_17[];
+};
+export {};