diff options
Diffstat (limited to 'catalog-ui/typings')
18 files changed, 36473 insertions, 0 deletions
diff --git a/catalog-ui/typings/angular-ui-bootstrap/angular-ui-bootstrap.d.ts b/catalog-ui/typings/angular-ui-bootstrap/angular-ui-bootstrap.d.ts new file mode 100644 index 0000000000..4062f141f1 --- /dev/null +++ b/catalog-ui/typings/angular-ui-bootstrap/angular-ui-bootstrap.d.ts @@ -0,0 +1,658 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ +// Type definitions for Angular UI Bootstrap 0.11.0 +// Project: https://github.com/angular-ui/bootstrap +// Definitions by: Brian Surowiec <https://github.com/xt0rted> +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +/// <reference path="../angularjs/angular.d.ts" /> + +declare module angular.ui.bootstrap { + + interface IAccordionConfig { + /** + * Controls whether expanding an item will cause the other items to close. + * + * @default true + */ + closeOthers?: boolean; + } + + + interface IButtonConfig { + /** + * @default: 'active' + */ + activeClass?: string; + + /** + * @default: 'Click' + */ + toggleEvent?: string; + } + + + interface IDatepickerConfig { + /** + * Format of day in month. + * + * @default 'dd' + */ + dayFormat?: string; + + /** + * Format of month in year. + * + * @default 'MMM' + */ + monthFormat?: string; + + /** + * Format of year in year range. + * + * @default 'yyyy' + */ + yearFormat?: string; + + /** + * Format of day in week header. + * + * @default 'EEE' + */ + dayHeaderFormat?: string; + + /** + * Format of title when selecting day. + * + * @default 'MMM yyyy' + */ + dayTitleFormat?: string; + + /** + * Format of title when selecting month. + * + * @default 'yyyy' + */ + monthTitleFormat?: string; + + /** + * Whether to display week numbers. + * + * @default true + */ + showWeeks?: boolean; + + /** + * Starting day of the week from 0-6 where 0=Sunday and 6=Saturday. + * + * @default 0 + */ + startingDay?: number; + + /** + * Number of years displayed in year selection. + * + * @default 20 + */ + yearRange?: number; + + /** + * Defines the minimum available date. + * + * @default null + */ + minDate?: any; + + /** + * Defines the maximum available date. + * + * @default null + */ + maxDate?: any; + } + + interface IDatepickerPopupConfig { + /** + * The format for displayed dates. + * + * @default 'yyyy-MM-dd' + */ + dateFormat?: string; + + /** + * The text to display for the current day button. + * + * @default 'Today' + */ + currentText?: string; + + /** + * The text to display for the toggling week numbers button. + * + * @default 'Weeks' + */ + toggleWeeksText?: string; + + /** + * The text to display for the clear button. + * + * @default 'Clear' + */ + clearText?: string; + + /** + * The text to display for the close button. + * + * @default 'Done' + */ + closeText?: string; + + /** + * Whether to close calendar when a date is chosen. + * + * @default true + */ + closeOnDateSelection?: boolean; + + /** + * Append the datepicker popup element to `body`, rather than inserting after `datepicker-popup`. + * + * @default false + */ + appendToBody?: boolean; + + /** + * Whether to display a button bar underneath the datepicker. + * + * @default true + */ + showButtonBar?: boolean; + } + + + interface IModalService { + /** + * @param {IModalSettings} options + * @returns {IModalServiceInstance} + */ + open(options: IModalSettings): IModalServiceInstance; + } + + interface IModalServiceInstance { + /** + * a method that can be used to close a modal, passing a result + */ + close(result?: any): void; + + /** + * a method that can be used to dismiss a modal, passing a reason + */ + dismiss(reason?: any): void; + + /** + * a promise that is resolved when a modal is closed and rejected when a modal is dismissed + */ + result: angular.IPromise<any>; + + /** + * a promise that is resolved when a modal gets opened after downloading content's template and resolving all variables + */ + opened: angular.IPromise<any>; + } + + interface IModalScope extends angular.IScope { + /** + * Those methods make it easy to close a modal window without a need to create a dedicated controller + */ + + /** + * Dismiss the dialog without assigning a value to the promise output + */ + $dismiss(reason?: any): void; + + /** + * Close the dialog resolving the promise to the given value + */ + $close(result?: any): void; + } + + interface IModalSettings { + /** + * a path to a template representing modal's content + */ + templateUrl?: string; + + /** + * inline template representing the modal's content + */ + template?: string; + + /** + * a scope instance to be used for the modal's content (actually the $modal service is going to create a child scope of a provided scope). + * Defaults to `$rootScope`. + */ + scope?: angular.IScope|IModalScope; + + /** + * a controller for a modal instance - it can initialize scope used by modal. + * A controller can be injected with `$modalInstance` + */ + controller?: any; + + /** + * an alternative to the controller-as syntax, matching the API of directive definitions. + * Requires the controller option to be provided as well + */ + controllerAs?: string; + + /** + * members that will be resolved and passed to the controller as locals; it is equivalent of the `resolve` property for AngularJS routes + */ + resolve?: any; + + /** + * controls the presence of a backdrop + * Allowed values: + * - true (default) + * - false (no backdrop) + * - 'static' backdrop is present but modal window is not closed when clicking outside of the modal window + * + * @default true + */ + backdrop?: any; + + /** + * indicates whether the dialog should be closable by hitting the ESC key, defaults to true + */ + keyboard?: boolean; + + /** + * additional CSS class(es) to be added to a modal window template + */ + windowClass?: string; + + /** + * optional size of modal window. Allowed values: 'sm' (small) or 'lg' (large). Requires Bootstrap 3.1.0 or later + */ + size?: string; + + /** + * a path to a template overriding modal's window template + */ + windowTemplateUrl?: string; + } + + interface IModalStackService { + /** + * Opens a new modal instance. + */ + open(modalInstance: IModalServiceInstance, modal: any): void; + + /** + * Closes a modal instance with an optional result. + */ + close(modalInstance: IModalServiceInstance, result?: any): void; + + /** + * Dismisses a modal instance with an optional reason. + */ + dismiss(modalInstance: IModalServiceInstance, reason?: any): void; + + /** + * Dismiss all open modal instances with an optional reason that will be passed to each instance. + */ + dismissAll(reason?: any): void; + + /** + * Gets the topmost modal instance that is open. + */ + getTop(): IModalStackedMapKeyValuePair; + } + + interface IModalStackedMapKeyValuePair { + key: IModalServiceInstance; + value: any; + } + + + interface IPaginationConfig { + /** + * Current page number. First page is 1. + */ + page?: number; + + /** + * Total number of items in all pages. + */ + totalItems?: number; + + /** + * Maximum number of items per page. A value less than one indicates all items on one page. + * + * @default 10 + */ + itemsPerPage?: number; + + /** + * Limit number for pagination size. + * + * @default: null + */ + maxSize?: number; + + /** + * An optional expression assigned the total number of pages to display. + * + * @default angular.noop + */ + numPages?: number; + + /** + * Whether to keep current page in the middle of the visible ones. + * + * @default true + */ + rotate?: boolean; + + /** + * An optional expression called when a page is selected having the page number as argument. + * + * @default null + */ + onSelectPage?(page: number): void; + + /** + * Whether to display Previous / Next buttons. + * + * @default true + */ + directionLinks?: boolean; + + /** + * Text for Previous button. + * + * @default 'Previous' + */ + previousText?: string; + + /** + * Text for Next button. + * + * @default 'Next' + */ + nextText?: string; + + /** + * Whether to display First / Last buttons. + * + * @default false + */ + boundaryLinks?: boolean; + + /** + * Text for First button. + * + * @default 'First' + */ + firstText?: string; + + /** + * Text for Last button. + * + * @default 'Last' + */ + lastText?: string; + } + + interface IPagerConfig { + /** + * Whether to align each link to the sides. + * + * @default true + */ + align?: boolean; + + /** + * Current page number. First page is 1. + */ + page?: number; + + /** + * Total number of items in all pages. + */ + totalItems?: number; + + /** + * Maximum number of items per page. A value less than one indicates all items on one page. + * + * @default 10 + */ + itemsPerPage?: number; + + /** + * An optional expression assigned the total number of pages to display. + * + * @default angular.noop + */ + numPages?: number; + + /** + * An optional expression called when a page is selected having the page number as argument. + * + * @default null + */ + onSelectPage?(page: number): void; + + /** + * Text for Previous button. + * + * @default '« Previous' + */ + previousText?: string; + + /** + * Text for Next button. + * + * @default 'Next »' + */ + nextText?: string; + } + + + interface IPositionCoordinates { + width?: number; + height?: number; + top?: number; + left?: number; + } + + interface IPositionService { + /** + * Provides a read-only equivalent of jQuery's position function. + */ + position(element: JQuery): IPositionCoordinates; + + /** + * Provides a read-only equivalent of jQuery's offset function. + */ + offset(element: JQuery): IPositionCoordinates; + } + + + interface IProgressConfig { + /** + * Whether bars use transitions to achieve the width change. + * + * @default: true + */ + animate?: boolean; + + /** + * A number that specifies the total value of bars that is required. + * + * @default: 100 + */ + max?: number; + } + + + interface IRatingConfig { + /** + * Changes the number of icons. + * + * @default: 5 + */ + max?: number; + + /** + * A variable used in the template to specify the state for selected icons. + * + * @default: null + */ + stateOn?: string; + + /** + * A variable used in the template to specify the state for unselected icons. + * + * @default: null + */ + stateOff?: string; + } + + + interface ITimepickerConfig { + /** + * Number of hours to increase or decrease when using a button. + * + * @default 1 + */ + hourStep?: number; + + /** + * Number of minutes to increase or decrease when using a button. + * + * @default 1 + */ + minuteStep?: number; + + /** + * Whether to display 12H or 24H mode. + * + * @default true + */ + showMeridian?: boolean; + + /** + * Meridian labels based on locale. To override you must supply an array like ['AM', 'PM']. + * + * @default null + */ + meridians?: Array<string>; + + /** + * Whether the user can type inside the hours & minutes input. + * + * @default false + */ + readonlyInput?: boolean; + + /** + * Whether the user can scroll inside the hours & minutes input to increase or decrease it's values. + * + * @default true + */ + mousewheel?: boolean; + } + + + interface ITooltipOptions { + /** + * Where to place it? Defaults to 'top', but also accepts 'right', 'bottom', or 'left'. + * + * @default 'top' + */ + placement?: string; + + /** + * Should it fade in and out? + * + * @default true + */ + animation?: boolean; + + /** + * For how long should the user have to have the mouse over the element before the tooltip shows (in milliseconds)? + * + * @default 0 + */ + popupDelay?: number; + + /** + * Should the tooltip be appended to `$body` instead of the parent element? + * + * @default false + */ + appendtoBody?: boolean; + } + + interface ITooltipProvider { + /** + * Provide a set of defaults for certain tooltip and popover attributes. + */ + options(value: ITooltipOptions): void; + + /** + * Extends the default trigger mappings with mappings of your own. E.g. `{ 'openTrigger': 'closeTrigger' }`. + */ + setTriggers(triggers: Object): void; + } + + + interface ITransitionService { + /** + * The browser specific animation event name. + */ + animationEndEventName: string; + + /** + * The browser specific transition event name. + */ + transitionEndEventName: string; + + /** + * Provides a consistent interface to trigger CSS 3 transitions and to be informed when they complete. + * + * @param element The DOMElement that will be animated + * @param trigger The thing that will cause the transition to start: + * - As a string, it represents the css class to be added to the element. + * - As an object, it represents a hash of style attributes to be applied to the element. + * - As a function, it represents a function to be called that will cause the transition to occur. + * @param options Optional settings for the transition. + * + * @return A promise that is resolved when the transition finishes. + */ + (element: angular.IAugmentedJQuery, trigger: any, options?: ITransitionServiceOptions): angular.IPromise<angular.IAugmentedJQuery>; + } + + interface ITransitionServiceOptions { + animation?: boolean; + } + +} diff --git a/catalog-ui/typings/angular-ui-router/angular-ui-router.d.ts b/catalog-ui/typings/angular-ui-router/angular-ui-router.d.ts new file mode 100644 index 0000000000..c27425e39c --- /dev/null +++ b/catalog-ui/typings/angular-ui-router/angular-ui-router.d.ts @@ -0,0 +1,207 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ +// Type definitions for Angular JS 1.1.5+ (ui.router module) +// Project: https://github.com/angular-ui/ui-router +// Definitions by: Michel Salib <https://github.com/michelsalib> +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +/// <reference path="../angularjs/angular.d.ts" /> + +declare module angular.ui { + + interface IState { + name?: string; + /** + * String HTML content, or function that returns an HTML string + */ + template?: string | {(): string}; + /** + * String URL path to template file OR Function, returns URL path string + */ + templateUrl?: string | {(): string}; + /** + * Function, returns HTML content string + */ + templateProvider?: Function; + /** + * A controller paired to the state. Function OR name as String + */ + controller?: Function | string; + controllerAs?: string; + /** + * Function (injectable), returns the actual controller function or string. + */ + controllerProvider?: Function; + resolve?: {}; + /** + * A url with optional parameters. When a state is navigated or transitioned to, the $stateParams service will be populated with any parameters that were passed. + */ + url?: string; + /** + * A map which optionally configures parameters declared in the url, or defines additional non-url parameters. Only use this within a state if you are not using url. Otherwise you can specify your parameters within the url. When a state is navigated or transitioned to, the $stateParams service will be populated with any parameters that were passed. + */ + params?: any; + /** + * Use the views property to set up multiple views. If you don't need multiple views within a single state this property is not needed. Tip: remember that often nested views are more useful and powerful than multiple sibling views. + */ + views?: {}; + abstract?: boolean; + /** + * Callback function for when a state is entered. Good way to trigger an action or dispatch an event, such as opening a dialog. + * If minifying your scripts, make sure to explictly annotate this function, because it won't be automatically annotated by your build tools. + */ + onEnter?: Function|(string|Function)[]; + /** + * Callback functions for when a state is entered and exited. Good way to trigger an action or dispatch an event, such as opening a dialog. + * If minifying your scripts, make sure to explictly annotate this function, because it won't be automatically annotated by your build tools. + */ + onExit?: Function|(string|Function)[]; + /** + * Arbitrary data object, useful for custom configuration. + */ + data?: any; + /** + * Boolean (default true). If false will not retrigger the same state just because a search/query parameter has changed. Useful for when you'd like to modify $location.search() without triggering a reload. + */ + reloadOnSearch?: boolean; + } + + interface IStateProvider extends ng.IServiceProvider { + state(name:string, config:IState): IStateProvider; + state(config:IState): IStateProvider; + decorator(name?: string, decorator?: (state: IState, parent: Function) => any): any; + } + + interface IUrlMatcher { + concat(pattern: string): IUrlMatcher; + exec(path: string, searchParams: {}): {}; + parameters(): string[]; + format(values: {}): string; + } + + interface IUrlMatcherFactory { + compile(pattern: string): IUrlMatcher; + isMatcher(o: any): boolean; + type(name: string, definition: any, definitionFn?: any): any; + } + + interface IUrlRouterProvider extends ng.IServiceProvider { + when(whenPath: RegExp, handler: Function): IUrlRouterProvider; + when(whenPath: RegExp, handler: any[]): IUrlRouterProvider; + when(whenPath: RegExp, toPath: string): IUrlRouterProvider; + when(whenPath: IUrlMatcher, hanlder: Function): IUrlRouterProvider; + when(whenPath: IUrlMatcher, handler: any[]): IUrlRouterProvider; + when(whenPath: IUrlMatcher, toPath: string): IUrlRouterProvider; + when(whenPath: string, handler: Function): IUrlRouterProvider; + when(whenPath: string, handler: any[]): IUrlRouterProvider; + when(whenPath: string, toPath: string): IUrlRouterProvider; + otherwise(handler: Function): IUrlRouterProvider; + otherwise(handler: any[]): IUrlRouterProvider; + otherwise(path: string): IUrlRouterProvider; + rule(handler: Function): IUrlRouterProvider; + rule(handler: any[]): IUrlRouterProvider; + } + + interface IStateOptions { + /** + * {boolean=true|string=} - If true will update the url in the location bar, if false will not. If string, must be "replace", which will update url and also replace last history record. + */ + location?: boolean | string; + /** + * {boolean=true}, If true will inherit url parameters from current url. + */ + inherit?: boolean; + /** + * {object=$state.$current}, When transitioning with relative path (e.g '^'), defines which state to be relative from. + */ + relative?: IState; + /** + * {boolean=true}, If true will broadcast $stateChangeStart and $stateChangeSuccess events. + */ + notify?: boolean; + /** + * {boolean=false}, If true will force transition even if the state or params have not changed, aka a reload of the same state. It differs from reloadOnSearch because you'd use this when you want to force a reload when everything is the same, including search params. + */ + reload?: boolean; + } + + interface IHrefOptions { + lossy?: boolean; + inherit?: boolean; + relative?: IState; + absolute?: boolean; + } + + interface IStateService { + /** + * Convenience method for transitioning to a new state. $state.go calls $state.transitionTo internally but automatically sets options to { location: true, inherit: true, relative: $state.$current, notify: true }. This allows you to easily use an absolute or relative to path and specify only the parameters you'd like to update (while letting unspecified parameters inherit from the currently active ancestor states). + * + * @param to Absolute state name or relative state path. Some examples: + * + * $state.go('contact.detail') - will go to the contact.detail state + * $state.go('^') - will go to a parent state + * $state.go('^.sibling') - will go to a sibling state + * $state.go('.child.grandchild') - will go to grandchild state + * + * @param params A map of the parameters that will be sent to the state, will populate $stateParams. Any parameters that are not specified will be inherited from currently defined parameters. This allows, for example, going to a sibling state that shares parameters specified in a parent state. Parameter inheritance only works between common ancestor states, I.e. transitioning to a sibling will get you the parameters for all parents, transitioning to a child will get you all current parameters, etc. + * + * @param options Options object. + */ + go(to: string, params?: {}, options?: IStateOptions): ng.IPromise<any>; + transitionTo(state: string, params?: {}, updateLocation?: boolean): void; + transitionTo(state: string, params?: {}, options?: IStateOptions): void; + includes(state: string, params?: {}): boolean; + is(state:string, params?: {}): boolean; + is(state: IState, params?: {}): boolean; + href(state: IState, params?: {}, options?: IHrefOptions): string; + href(state: string, params?: {}, options?: IHrefOptions): string; + get(state: string): IState; + get(): IState[]; + current: IState; + params: IStateParamsService; + reload(): void; + } + + interface IStateParamsService { + [key: string]: any; + } + + interface IUrlRouterService { + /* + * Triggers an update; the same update that happens when the address bar + * url changes, aka $locationChangeSuccess. + * + * This method is useful when you need to use preventDefault() on the + * $locationChangeSuccess event, perform some custom logic (route protection, + * auth, config, redirection, etc) and then finally proceed with the transition + * by calling $urlRouter.sync(). + * + */ + sync(): void; + } + + interface IUiViewScrollProvider { + /* + * Reverts back to using the core $anchorScroll service for scrolling + * based on the url anchor. + */ + useAnchorScroll(): void; + } +} diff --git a/catalog-ui/typings/angularjs/angular-mocks.d.ts b/catalog-ui/typings/angularjs/angular-mocks.d.ts new file mode 100644 index 0000000000..65b0ac1a09 --- /dev/null +++ b/catalog-ui/typings/angularjs/angular-mocks.d.ts @@ -0,0 +1,337 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ +// Type definitions for Angular JS 1.3 (ngMock, ngMockE2E module) +// Project: http://angularjs.org +// Definitions by: Diego Vilar <http://github.com/diegovilar>, Tony Curtis <http://github.com/daltin> +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +/// <reference path="angular.d.ts" /> + +declare module "angular-mocks/ngMock" { + var _: string; + export = _; +} + +declare module "angular-mocks/ngMockE2E" { + var _: string; + export = _; +} + +declare module "angular-mocks/ngAnimateMock" { + var _: string; + export = _; +} + +/////////////////////////////////////////////////////////////////////////////// +// ngMock module (angular-mocks.js) +/////////////////////////////////////////////////////////////////////////////// +declare module angular { + + /////////////////////////////////////////////////////////////////////////// + // AngularStatic + // We reopen it to add the MockStatic definition + /////////////////////////////////////////////////////////////////////////// + interface IAngularStatic { + mock: IMockStatic; + } + + // see https://docs.angularjs.org/api/ngMock/function/angular.mock.inject + interface IInjectStatic { + (...fns: Function[]): any; + (...inlineAnnotatedConstructor: any[]): any; // this overload is undocumented, but works + strictDi(val?: boolean): void; + } + + interface IMockStatic { + // see https://docs.angularjs.org/api/ngMock/function/angular.mock.dump + dump(obj: any): string; + + inject: IInjectStatic + + // see https://docs.angularjs.org/api/ngMock/function/angular.mock.module + module(...modules: any[]): any; + + // see https://docs.angularjs.org/api/ngMock/type/angular.mock.TzDate + TzDate(offset: number, timestamp: number): Date; + TzDate(offset: number, timestamp: string): Date; + } + + /////////////////////////////////////////////////////////////////////////// + // ExceptionHandlerService + // see https://docs.angularjs.org/api/ngMock/service/$exceptionHandler + // see https://docs.angularjs.org/api/ngMock/provider/$exceptionHandlerProvider + /////////////////////////////////////////////////////////////////////////// + interface IExceptionHandlerProvider extends IServiceProvider { + mode(mode: string): void; + } + + /////////////////////////////////////////////////////////////////////////// + // TimeoutService + // see https://docs.angularjs.org/api/ngMock/service/$timeout + // Augments the original service + /////////////////////////////////////////////////////////////////////////// + interface ITimeoutService { + flush(delay?: number): void; + flushNext(expectedDelay?: number): void; + verifyNoPendingTasks(): void; + } + + /////////////////////////////////////////////////////////////////////////// + // IntervalService + // see https://docs.angularjs.org/api/ngMock/service/$interval + // Augments the original service + /////////////////////////////////////////////////////////////////////////// + interface IIntervalService { + flush(millis?: number): number; + } + + /////////////////////////////////////////////////////////////////////////// + // LogService + // see https://docs.angularjs.org/api/ngMock/service/$log + // Augments the original service + /////////////////////////////////////////////////////////////////////////// + interface ILogService { + assertEmpty(): void; + reset(): void; + } + + interface ILogCall { + logs: string[]; + } + + /////////////////////////////////////////////////////////////////////////// + // HttpBackendService + // see https://docs.angularjs.org/api/ngMock/service/$httpBackend + /////////////////////////////////////////////////////////////////////////// + interface IHttpBackendService { + /** + * Flushes all pending requests using the trained responses. + * @param count Number of responses to flush (in the order they arrived). If undefined, all pending requests will be flushed. + */ + flush(count?: number): void; + + /** + * Resets all request expectations, but preserves all backend definitions. + */ + resetExpectations(): void; + + /** + * Verifies that all of the requests defined via the expect api were made. If any of the requests were not made, verifyNoOutstandingExpectation throws an exception. + */ + verifyNoOutstandingExpectation(): void; + + /** + * Verifies that there are no outstanding requests that need to be flushed. + */ + verifyNoOutstandingRequest(): void; + + /** + * Creates a new request expectation. + * Throws a preformatted error if expectation(s) don't match supplied string, regular expression, object, or if function returns false. + * Returns an object with respond method that controls how a matched request is handled. + * @param method HTTP method. + * @param url HTTP url string, regular expression or function that receives a url and returns true if the url matches the current expctation. + * @param data HTTP request body string, json object, regular expression or function that receives the data and returns true if the data matches the current expectation. + * @param headers HTTP headers object or function that receives the headers and returns true if the headers match the current expectation. + */ + expect(method: string, url: string | RegExp | ((url: string) => boolean), data?: string | RegExp | Object | ((data: string) => boolean), headers?: Object | ((object: Object) => boolean)) :mock.IRequestHandler; + + /** + * Creates a new request expectation for DELETE requests. + * Throws a preformatted error if expectation(s) don't match supplied string, regular expression, object, or if function returns false. + * Returns an object with respond method that controls how a matched request is handled. + * @param url HTTP url string, regular expression or function that receives a url and returns true if the url is as expected. + * @param headers HTTP headers object to be compared with the HTTP headers in the request. + */ + expectDELETE(url: string | RegExp | ((url: string) => boolean), headers?: Object): mock.IRequestHandler; + + /** + * Creates a new request expectation for GET requests. + * Throws a preformatted error if expectation(s) don't match supplied string, regular expression, object, or if function returns false. + * Returns an object with respond method that controls how a matched request is handled. + * @param url HTTP url string, regular expression or function that receives a url and returns true if the url matches the current expctation. + * @param headers HTTP headers object to be compared with the HTTP headers in the request. + */ + expectGET(url: string | RegExp | ((url: string) => boolean), headers?: Object): mock.IRequestHandler; + + /** + * Creates a new request expectation for HEAD requests. + * Throws a preformatted error if expectation(s) don't match supplied string, regular expression, object, or if function returns false. + * Returns an object with respond method that controls how a matched request is handled. + * @param url HTTP url string, regular expression or function that receives a url and returns true if the url matches the current expctation. + * @param headers HTTP headers object to be compared with the HTTP headers in the request. + */ + expectHEAD(url: string | RegExp | ((url: string) => boolean), headers?: Object): mock.IRequestHandler; + + /** + * Creates a new request expectation for JSONP requests. + * Throws a preformatted error if expectation(s) don't match supplied string, regular expression, or if function returns false. + * Returns an object with respond method that controls how a matched request is handled. + * @param url HTTP url string, regular expression or function that receives a url and returns true if the url matches the current expctation. + */ + expectJSONP(url: string | RegExp | ((url: string) => boolean)): mock.IRequestHandler; + + /** + * Creates a new request expectation for PATCH requests. + * Throws a preformatted error if expectation(s) don't match supplied string, regular expression, object, or if function returns false. + * Returns an object with respond method that controls how a matched request is handled. + * @param url HTTP url string, regular expression or function that receives a url and returns true if the url matches the current expctation. + * @param data HTTP request body string, json object, regular expression or function that receives the data and returns true if the data matches the current expectation. + * @param headers HTTP headers object or function that receives the headers and returns true if the headers match the current expectation. + */ + expectPATCH(url: string | RegExp | ((url: string) => boolean), data?: string | RegExp | Object | ((data: string) => boolean), headers?: Object): mock.IRequestHandler; + + /** + * Creates a new request expectation for POST requests. + * Throws a preformatted error if expectation(s) don't match supplied string, regular expression, object, or if function returns false. + * Returns an object with respond method that controls how a matched request is handled. + * @param url HTTP url string, regular expression or function that receives a url and returns true if the url matches the current expctation. + * @param data HTTP request body string, json object, regular expression or function that receives the data and returns true if the data matches the current expectation. + * @param headers HTTP headers object or function that receives the headers and returns true if the headers match the current expectation. + */ + expectPOST(url: string | RegExp | ((url: string) => boolean), data?: string | RegExp | Object | ((data: string) => boolean), headers?: Object): mock.IRequestHandler; + + /** + * Creates a new request expectation for PUT requests. + * Throws a preformatted error if expectation(s) don't match supplied string, regular expression, object, or if function returns false. + * Returns an object with respond method that controls how a matched request is handled. + * @param url HTTP url string, regular expression or function that receives a url and returns true if the url matches the current expctation. + * @param data HTTP request body string, json object, regular expression or function that receives the data and returns true if the data matches the current expectation. + * @param headers HTTP headers object or function that receives the headers and returns true if the headers match the current expectation. + */ + expectPUT(url: string | RegExp | ((url: string) => boolean), data?: string | RegExp | Object | ((data: string) => boolean), headers?: Object): mock.IRequestHandler; + + /** + * Creates a new backend definition. + * Returns an object with respond method that controls how a matched request is handled. + * @param method HTTP method. + * @param url HTTP url string, regular expression or function that receives a url and returns true if the url matches the current expctation. + * @param data HTTP request body string, json object, regular expression or function that receives the data and returns true if the data matches the current expectation. + * @param headers HTTP headers object or function that receives the headers and returns true if the headers match the current expectation. + */ + when(method: string, url: string | RegExp | ((url: string) => boolean), data?: string | RegExp | Object | ((data: string) => boolean), headers?: Object | ((object: Object) => boolean)): mock.IRequestHandler; + + /** + * Creates a new backend definition for DELETE requests. + * Returns an object with respond method that controls how a matched request is handled. + * @param url HTTP url string, regular expression or function that receives a url and returns true if the url matches the current expctation. + * @param headers HTTP headers object or function that receives the headers and returns true if the headers match the current expectation. + */ + whenDELETE(url: string | RegExp | ((url: string) => boolean), headers?: Object | ((object: Object) => boolean)): mock.IRequestHandler; + + /** + * Creates a new backend definition for GET requests. + * Returns an object with respond method that controls how a matched request is handled. + * @param url HTTP url string, regular expression or function that receives a url and returns true if the url matches the current expctation. + * @param headers HTTP headers object or function that receives the headers and returns true if the headers match the current expectation. + */ + whenGET(url: string | RegExp | ((url: string) => boolean), headers?: Object | ((object: Object) => boolean)): mock.IRequestHandler; + + /** + * Creates a new backend definition for HEAD requests. + * Returns an object with respond method that controls how a matched request is handled. + * @param url HTTP url string, regular expression or function that receives a url and returns true if the url matches the current expctation. + * @param headers HTTP headers object or function that receives the headers and returns true if the headers match the current expectation. + */ + whenHEAD(url: string | RegExp | ((url: string) => boolean), headers?: Object | ((object: Object) => boolean)): mock.IRequestHandler; + + /** + * Creates a new backend definition for JSONP requests. + * Returns an object with respond method that controls how a matched request is handled. + * @param url HTTP url string, regular expression or function that receives a url and returns true if the url matches the current expctation. + * @param headers HTTP headers object or function that receives the headers and returns true if the headers match the current expectation. + */ + whenJSONP(url: string | RegExp | ((url: string) => boolean)): mock.IRequestHandler; + + /** + * Creates a new backend definition for PATCH requests. + * Returns an object with respond method that controls how a matched request is handled. + * @param url HTTP url string, regular expression or function that receives a url and returns true if the url matches the current expctation. + * @param data HTTP request body string, json object, regular expression or function that receives the data and returns true if the data matches the current expectation. + * @param headers HTTP headers object or function that receives the headers and returns true if the headers match the current expectation. + */ + whenPATCH(url: string | RegExp | ((url: string) => boolean), data?: string | RegExp | Object | ((data: string) => boolean), headers?: Object | ((object: Object) => boolean)): mock.IRequestHandler; + + /** + * Creates a new backend definition for POST requests. + * Returns an object with respond method that controls how a matched request is handled. + * @param url HTTP url string, regular expression or function that receives a url and returns true if the url matches the current expctation. + * @param data HTTP request body string, json object, regular expression or function that receives the data and returns true if the data matches the current expectation. + * @param headers HTTP headers object or function that receives the headers and returns true if the headers match the current expectation. + */ + whenPOST(url: string | RegExp | ((url: string) => boolean), data?: string | RegExp | Object | ((data: string) => boolean), headers?: Object | ((object: Object) => boolean)): mock.IRequestHandler; + + /** + * Creates a new backend definition for PUT requests. + * Returns an object with respond method that controls how a matched request is handled. + * @param url HTTP url string, regular expression or function that receives a url and returns true if the url matches the current expctation. + * @param data HTTP request body string, json object, regular expression or function that receives the data and returns true if the data matches the current expectation. + * @param headers HTTP headers object or function that receives the headers and returns true if the headers match the current expectation. + */ + whenPUT(url: string | RegExp | ((url: string) => boolean), data?: string | RegExp | Object | ((data: string) => boolean), headers?: Object | ((object: Object) => boolean)): mock.IRequestHandler; + } + + export module mock { + // returned interface by the the mocked HttpBackendService expect/when methods + interface IRequestHandler { + + /** + * Controls the response for a matched request using a function to construct the response. + * Returns the RequestHandler object for possible overrides. + * @param func Function that receives the request HTTP method, url, data, and headers and returns an array containing response status (number), data, headers, and status text. + */ + respond(func: ((method: string, url: string, data: string | Object, headers: Object) => [number, string | Object, Object, string])): IRequestHandler; + + /** + * Controls the response for a matched request using supplied static data to construct the response. + * Returns the RequestHandler object for possible overrides. + * @param status HTTP status code to add to the response. + * @param data Data to add to the response. + * @param headers Headers object to add to the response. + * @param responseText Response text to add to the response. + */ + respond(status: number, data: string | Object, headers?: Object, responseText?: string): IRequestHandler; + + /** + * Controls the response for a matched request using the HTTP status code 200 and supplied static data to construct the response. + * Returns the RequestHandler object for possible overrides. + * @param data Data to add to the response. + * @param headers Headers object to add to the response. + * @param responseText Response text to add to the response. + */ + respond(data: string | Object, headers?: Object, responseText?: string): IRequestHandler; + + // Available when ngMockE2E is loaded + /** + * Any request matching a backend definition or expectation with passThrough handler will be passed through to the real backend (an XHR request will be made to the server.) + */ + passThrough(): IRequestHandler; + } + + } + +} + +/////////////////////////////////////////////////////////////////////////////// +// functions attached to global object (window) +/////////////////////////////////////////////////////////////////////////////// +//Use `angular.mock.module` instead of `module`, as `module` conflicts with commonjs. +//declare var module: (...modules: any[]) => any; +declare var inject: angular.IInjectStatic; diff --git a/catalog-ui/typings/angularjs/angular-resource.d.ts b/catalog-ui/typings/angularjs/angular-resource.d.ts new file mode 100644 index 0000000000..969997b1bc --- /dev/null +++ b/catalog-ui/typings/angularjs/angular-resource.d.ts @@ -0,0 +1,183 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ +// Type definitions for Angular JS 1.3 (ngResource module) +// Project: http://angularjs.org +// Definitions by: Diego Vilar <http://github.com/diegovilar>, Michael Jess <http://github.com/miffels> +// Definitions: https://github.com/daptiv/DefinitelyTyped + +/// <reference path="angular.d.ts" /> +/////////////////////////////////////////////////////////////////////////////// +// ngResource module (angular-resource.js) +/////////////////////////////////////////////////////////////////////////////// +declare module angular.resource { + + /** + * Currently supported options for the $resource factory options argument. + */ + interface IResourceOptions { + /** + * If true then the trailing slashes from any calculated URL will be stripped (defaults to true) + */ + stripTrailingSlashes?: boolean; + } + + /////////////////////////////////////////////////////////////////////////// + // ResourceService + // see http://docs.angularjs.org/api/ngResource.$resource + // Most part of the following definitions were achieved by analyzing the + // actual implementation, since the documentation doesn't seem to cover + // that deeply. + /////////////////////////////////////////////////////////////////////////// + interface IResourceService { + (url: string, paramDefaults?: any, + /** example: {update: { method: 'PUT' }, delete: deleteDescriptor } + where deleteDescriptor : IActionDescriptor */ + actions?: any, options?: IResourceOptions): IResourceClass<IResource<any>>; + <T, U>(url: string, paramDefaults?: any, + /** example: {update: { method: 'PUT' }, delete: deleteDescriptor } + where deleteDescriptor : IActionDescriptor */ + actions?: any, options?: IResourceOptions): U; + <T>(url: string, paramDefaults?: any, + /** example: {update: { method: 'PUT' }, delete: deleteDescriptor } + where deleteDescriptor : IActionDescriptor */ + actions?: any, options?: IResourceOptions): IResourceClass<T>; + } + + // Just a reference to facilitate describing new actions + interface IActionDescriptor { + method: string; + isArray?: boolean; + params?: any; + headers?: any; + url?: any; + cache?: Boolean; + transformRequest?: Function; + transformResponse?: Function; + } + + // Baseclass for everyresource with default actions. + // If you define your new actions for the resource, you will need + // to extend this interface and typecast the ResourceClass to it. + // + // In case of passing the first argument as anything but a function, + // it's gonna be considered data if the action method is POST, PUT or + // PATCH (in other words, methods with body). Otherwise, it's going + // to be considered as parameters to the request. + // https://github.com/angular/angular.js/blob/v1.2.0/src/ngResource/resource.js#L461-L465 + // + // Only those methods with an HTTP body do have 'data' as first parameter: + // https://github.com/angular/angular.js/blob/v1.2.0/src/ngResource/resource.js#L463 + // More specifically, those methods are POST, PUT and PATCH: + // https://github.com/angular/angular.js/blob/v1.2.0/src/ngResource/resource.js#L432 + // + // Also, static calls always return the IResource (or IResourceArray) retrieved + // https://github.com/angular/angular.js/blob/v1.2.0/src/ngResource/resource.js#L538-L549 + interface IResourceClass<T> { + new(dataOrParams? : any) : T; + get(): T; + get(params: Object): T; + get(success: Function, error?: Function): T; + get(params: Object, success: Function, error?: Function): T; + get(params: Object, data: Object, success?: Function, error?: Function): T; + + query(): IResourceArray<T>; + query(params: Object): IResourceArray<T>; + query(success: Function, error?: Function): IResourceArray<T>; + query(params: Object, success: Function, error?: Function): IResourceArray<T>; + query(params: Object, data: Object, success?: Function, error?: Function): IResourceArray<T>; + + save(): T; + save(data: Object): T; + save(success: Function, error?: Function): T; + save(data: Object, success: Function, error?: Function): T; + save(params: Object, data: Object, success?: Function, error?: Function): T; + + remove(): T; + remove(params: Object): T; + remove(success: Function, error?: Function): T; + remove(params: Object, success: Function, error?: Function): T; + remove(params: Object, data: Object, success?: Function, error?: Function): T; + + delete(): T; + delete(params: Object): T; + delete(success: Function, error?: Function): T; + delete(params: Object, success: Function, error?: Function): T; + delete(params: Object, data: Object, success?: Function, error?: Function): T; + } + + // Instance calls always return the the promise of the request which retrieved the object + // https://github.com/angular/angular.js/blob/v1.2.0/src/ngResource/resource.js#L538-L546 + interface IResource<T> { + $get(): angular.IPromise<T>; + $get(params?: Object, success?: Function, error?: Function): angular.IPromise<T>; + $get(success: Function, error?: Function): angular.IPromise<T>; + + $query(): angular.IPromise<IResourceArray<T>>; + $query(params?: Object, success?: Function, error?: Function): angular.IPromise<IResourceArray<T>>; + $query(success: Function, error?: Function): angular.IPromise<IResourceArray<T>>; + + $save(): angular.IPromise<T>; + $save(params?: Object, success?: Function, error?: Function): angular.IPromise<T>; + $save(success: Function, error?: Function): angular.IPromise<T>; + + $remove(): angular.IPromise<T>; + $remove(params?: Object, success?: Function, error?: Function): angular.IPromise<T>; + $remove(success: Function, error?: Function): angular.IPromise<T>; + + $delete(): angular.IPromise<T>; + $delete(params?: Object, success?: Function, error?: Function): angular.IPromise<T>; + $delete(success: Function, error?: Function): angular.IPromise<T>; + + /** the promise of the original server interaction that created this instance. **/ + $promise : angular.IPromise<T>; + $resolved : boolean; + } + + /** + * Really just a regular Array object with $promise and $resolve attached to it + */ + interface IResourceArray<T> extends Array<T> { + /** the promise of the original server interaction that created this collection. **/ + $promise : angular.IPromise<IResourceArray<T>>; + $resolved : boolean; + } + + /** when creating a resource factory via IModule.factory */ + interface IResourceServiceFactoryFunction<T> { + ($resource: angular.resource.IResourceService): IResourceClass<T>; + <U extends IResourceClass<T>>($resource: angular.resource.IResourceService): U; + } +} + +/** extensions to base ng based on using angular-resource */ +declare module angular { + + interface IModule { + /** creating a resource service factory */ + factory(name: string, resourceServiceFactoryFunction: angular.resource.IResourceServiceFactoryFunction<any>): IModule; + } +} + +interface Array<T> +{ + /** the promise of the original server interaction that created this collection. **/ + $promise : angular.IPromise<Array<T>>; + $resolved : boolean; +} diff --git a/catalog-ui/typings/angularjs/angular.d.ts b/catalog-ui/typings/angularjs/angular.d.ts new file mode 100644 index 0000000000..a5f56c0ccd --- /dev/null +++ b/catalog-ui/typings/angularjs/angular.d.ts @@ -0,0 +1,1613 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ +// Type definitions for Angular JS 1.3+ +// Project: http://angularjs.org +// Definitions by: Diego Vilar <http://github.com/diegovilar> +// Definitions: https://github.com/borisyankov/DefinitelyTyped + + +/// <reference path="../jquery/jquery.d.ts" /> + +declare var angular: angular.IAngularStatic; + +// Support for painless dependency injection +interface Function { + $inject?: string[]; +} + +// Collapse angular into ng +import ng = angular; +// Support AMD require +declare module 'angular' { + export = angular; +} + +/////////////////////////////////////////////////////////////////////////////// +// ng module (angular.js) +/////////////////////////////////////////////////////////////////////////////// +declare module angular { + + // not directly implemented, but ensures that constructed class implements $get + interface IServiceProviderClass { + new (...args: any[]): IServiceProvider; + } + + interface IServiceProviderFactory { + (...args: any[]): IServiceProvider; + } + + // All service providers extend this interface + interface IServiceProvider { + $get: any; + } + + interface IAngularBootstrapConfig { + strictDi?: boolean; + } + + /////////////////////////////////////////////////////////////////////////// + // AngularStatic + // see http://docs.angularjs.org/api + /////////////////////////////////////////////////////////////////////////// + interface IAngularStatic { + bind(context: any, fn: Function, ...args: any[]): Function; + + /** + * Use this function to manually start up angular application. + * + * @param element DOM element which is the root of angular application. + * @param modules An array of modules to load into the application. + * Each item in the array should be the name of a predefined module or a (DI annotated) + * function that will be invoked by the injector as a run block. + * @param config an object for defining configuration options for the application. The following keys are supported: + * - `strictDi`: disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code. + */ + bootstrap(element: string, modules?: string, config?: IAngularBootstrapConfig): auto.IInjectorService; + /** + * Use this function to manually start up angular application. + * + * @param element DOM element which is the root of angular application. + * @param modules An array of modules to load into the application. + * Each item in the array should be the name of a predefined module or a (DI annotated) + * function that will be invoked by the injector as a run block. + * @param config an object for defining configuration options for the application. The following keys are supported: + * - `strictDi`: disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code. + */ + bootstrap(element: string, modules?: Function, config?: IAngularBootstrapConfig): auto.IInjectorService; + /** + * Use this function to manually start up angular application. + * + * @param element DOM element which is the root of angular application. + * @param modules An array of modules to load into the application. + * Each item in the array should be the name of a predefined module or a (DI annotated) + * function that will be invoked by the injector as a run block. + * @param config an object for defining configuration options for the application. The following keys are supported: + * - `strictDi`: disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code. + */ + bootstrap(element: string, modules?: string[], config?: IAngularBootstrapConfig): auto.IInjectorService; + /** + * Use this function to manually start up angular application. + * + * @param element DOM element which is the root of angular application. + * @param modules An array of modules to load into the application. + * Each item in the array should be the name of a predefined module or a (DI annotated) + * function that will be invoked by the injector as a run block. + * @param config an object for defining configuration options for the application. The following keys are supported: + * - `strictDi`: disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code. + */ + bootstrap(element: JQuery, modules?: string, config?: IAngularBootstrapConfig): auto.IInjectorService; + /** + * Use this function to manually start up angular application. + * + * @param element DOM element which is the root of angular application. + * @param modules An array of modules to load into the application. + * Each item in the array should be the name of a predefined module or a (DI annotated) + * function that will be invoked by the injector as a run block. + * @param config an object for defining configuration options for the application. The following keys are supported: + * - `strictDi`: disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code. + */ + bootstrap(element: JQuery, modules?: Function, config?: IAngularBootstrapConfig): auto.IInjectorService; + /** + * Use this function to manually start up angular application. + * + * @param element DOM element which is the root of angular application. + * @param modules An array of modules to load into the application. + * Each item in the array should be the name of a predefined module or a (DI annotated) + * function that will be invoked by the injector as a run block. + * @param config an object for defining configuration options for the application. The following keys are supported: + * - `strictDi`: disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code. + */ + bootstrap(element: JQuery, modules?: string[], config?: IAngularBootstrapConfig): auto.IInjectorService; + /** + * Use this function to manually start up angular application. + * + * @param element DOM element which is the root of angular application. + * @param modules An array of modules to load into the application. + * Each item in the array should be the name of a predefined module or a (DI annotated) + * function that will be invoked by the injector as a run block. + * @param config an object for defining configuration options for the application. The following keys are supported: + * - `strictDi`: disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code. + */ + bootstrap(element: Element, modules?: string, config?: IAngularBootstrapConfig): auto.IInjectorService; + /** + * Use this function to manually start up angular application. + * + * @param element DOM element which is the root of angular application. + * @param modules An array of modules to load into the application. + * Each item in the array should be the name of a predefined module or a (DI annotated) + * function that will be invoked by the injector as a run block. + * @param config an object for defining configuration options for the application. The following keys are supported: + * - `strictDi`: disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code. + */ + bootstrap(element: Element, modules?: Function, config?: IAngularBootstrapConfig): auto.IInjectorService; + /** + * Use this function to manually start up angular application. + * + * @param element DOM element which is the root of angular application. + * @param modules An array of modules to load into the application. + * Each item in the array should be the name of a predefined module or a (DI annotated) + * function that will be invoked by the injector as a run block. + * @param config an object for defining configuration options for the application. The following keys are supported: + * - `strictDi`: disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code. + */ + bootstrap(element: Element, modules?: string[], config?: IAngularBootstrapConfig): auto.IInjectorService; + /** + * Use this function to manually start up angular application. + * + * @param element DOM element which is the root of angular application. + * @param modules An array of modules to load into the application. + * Each item in the array should be the name of a predefined module or a (DI annotated) + * function that will be invoked by the injector as a run block. + * @param config an object for defining configuration options for the application. The following keys are supported: + * - `strictDi`: disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code. + */ + bootstrap(element: Document, modules?: string, config?: IAngularBootstrapConfig): auto.IInjectorService; + /** + * Use this function to manually start up angular application. + * + * @param element DOM element which is the root of angular application. + * @param modules An array of modules to load into the application. + * Each item in the array should be the name of a predefined module or a (DI annotated) + * function that will be invoked by the injector as a run block. + * @param config an object for defining configuration options for the application. The following keys are supported: + * - `strictDi`: disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code. + */ + bootstrap(element: Document, modules?: Function, config?: IAngularBootstrapConfig): auto.IInjectorService; + /** + * Use this function to manually start up angular application. + * + * @param element DOM element which is the root of angular application. + * @param modules An array of modules to load into the application. + * Each item in the array should be the name of a predefined module or a (DI annotated) + * function that will be invoked by the injector as a run block. + * @param config an object for defining configuration options for the application. The following keys are supported: + * - `strictDi`: disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code. + */ + bootstrap(element: Document, modules?: string[], config?: IAngularBootstrapConfig): auto.IInjectorService; + + /** + * Creates a deep copy of source, which should be an object or an array. + * + * - If no destination is supplied, a copy of the object or array is created. + * - If a destination is provided, all of its elements (for array) or properties (for objects) are deleted and then all elements/properties from the source are copied to it. + * - If source is not an object or array (inc. null and undefined), source is returned. + * - If source is identical to 'destination' an exception will be thrown. + * + * @param source The source that will be used to make a copy. Can be any type, including primitives, null, and undefined. + * @param destination Destination into which the source is copied. If provided, must be of the same type as source. + */ + copy<T>(source: T, destination?: T): T; + + /** + * Wraps a raw DOM element or HTML string as a jQuery element. + * + * If jQuery is available, angular.element is an alias for the jQuery function. If jQuery is not available, angular.element delegates to Angular's built-in subset of jQuery, called "jQuery lite" or "jqLite." + */ + element: IAugmentedJQueryStatic; + equals(value1: any, value2: any): boolean; + extend(destination: any, ...sources: any[]): any; + + /** + * Invokes the iterator function once for each item in obj collection, which can be either an object or an array. The iterator function is invoked with iterator(value, key), where value is the value of an object property or an array element and key is the object property key or array element index. Specifying a context for the function is optional. + * + * It is worth noting that .forEach does not iterate over inherited properties because it filters using the hasOwnProperty method. + * + * @param obj Object to iterate over. + * @param iterator Iterator function. + * @param context Object to become context (this) for the iterator function. + */ + forEach<T>(obj: T[], iterator: (value: T, key: number) => any, context?: any): any; + /** + * Invokes the iterator function once for each item in obj collection, which can be either an object or an array. The iterator function is invoked with iterator(value, key), where value is the value of an object property or an array element and key is the object property key or array element index. Specifying a context for the function is optional. + * + * It is worth noting that .forEach does not iterate over inherited properties because it filters using the hasOwnProperty method. + * + * @param obj Object to iterate over. + * @param iterator Iterator function. + * @param context Object to become context (this) for the iterator function. + */ + forEach<T>(obj: { [index: string]: T; }, iterator: (value: T, key: string) => any, context?: any): any; + /** + * Invokes the iterator function once for each item in obj collection, which can be either an object or an array. The iterator function is invoked with iterator(value, key), where value is the value of an object property or an array element and key is the object property key or array element index. Specifying a context for the function is optional. + * + * It is worth noting that .forEach does not iterate over inherited properties because it filters using the hasOwnProperty method. + * + * @param obj Object to iterate over. + * @param iterator Iterator function. + * @param context Object to become context (this) for the iterator function. + */ + forEach(obj: any, iterator: (value: any, key: any) => any, context?: any): any; + + fromJson(json: string): any; + identity(arg?: any): any; + injector(modules?: any[]): auto.IInjectorService; + isArray(value: any): boolean; + isDate(value: any): boolean; + isDefined(value: any): boolean; + isElement(value: any): boolean; + isFunction(value: any): boolean; + isNumber(value: any): boolean; + isObject(value: any): boolean; + isString(value: any): boolean; + isUndefined(value: any): boolean; + lowercase(str: string): string; + + /** + * The angular.module is a global place for creating, registering and retrieving Angular modules. All modules (angular core or 3rd party) that should be available to an application must be registered using this mechanism. + * + * When passed two or more arguments, a new module is created. If passed only one argument, an existing module (the name passed as the first argument to module) is retrieved. + * + * @param name The name of the module to create or retrieve. + * @param requires The names of modules this module depends on. If specified then new module is being created. If unspecified then the module is being retrieved for further configuration. + * @param configFn Optional configuration function for the module. + */ + module( + name: string, + requires?: string[], + configFn?: Function): IModule; + + noop(...args: any[]): void; + reloadWithDebugInfo(): void; + toJson(obj: any, pretty?: boolean): string; + uppercase(str: string): string; + version: { + full: string; + major: number; + minor: number; + dot: number; + codeName: string; + }; + } + + /////////////////////////////////////////////////////////////////////////// + // Module + // see http://docs.angularjs.org/api/angular.Module + /////////////////////////////////////////////////////////////////////////// + interface IModule { + animation(name: string, animationFactory: Function): IModule; + animation(name: string, inlineAnnotatedFunction: any[]): IModule; + animation(object: Object): IModule; + /** + * Use this method to register work which needs to be performed on module loading. + * + * @param configFn Execute this function on module load. Useful for service configuration. + */ + config(configFn: Function): IModule; + /** + * Use this method to register work which needs to be performed on module loading. + * + * @param inlineAnnotatedFunction Execute this function on module load. Useful for service configuration. + */ + config(inlineAnnotatedFunction: any[]): IModule; + /** + * Register a constant service, such as a string, a number, an array, an object or a function, with the $injector. Unlike value it can be injected into a module configuration function (see config) and it cannot be overridden by an Angular decorator. + * + * @param name The name of the constant. + * @param value The constant value. + */ + constant(name: string, value: any): IModule; + constant(object: Object): IModule; + /** + * The $controller service is used by Angular to create new controllers. + * + * This provider allows controller registration via the register method. + * + * @param name Controller name, or an object map of controllers where the keys are the names and the values are the constructors. + * @param controllerConstructor Controller constructor fn (optionally decorated with DI annotations in the array notation). + */ + controller(name: string, controllerConstructor: Function): IModule; + /** + * The $controller service is used by Angular to create new controllers. + * + * This provider allows controller registration via the register method. + * + * @param name Controller name, or an object map of controllers where the keys are the names and the values are the constructors. + * @param controllerConstructor Controller constructor fn (optionally decorated with DI annotations in the array notation). + */ + controller(name: string, inlineAnnotatedConstructor: any[]): IModule; + controller(object: Object): IModule; + /** + * Register a new directive with the compiler. + * + * @param name Name of the directive in camel-case (i.e. ngBind which will match as ng-bind) + * @param directiveFactory An injectable directive factory function. + */ + directive(name: string, directiveFactory: IDirectiveFactory): IModule; + /** + * Register a new directive with the compiler. + * + * @param name Name of the directive in camel-case (i.e. ngBind which will match as ng-bind) + * @param directiveFactory An injectable directive factory function. + */ + directive(name: string, inlineAnnotatedFunction: any[]): IModule; + directive(object: Object): IModule; + /** + * Register a service factory, which will be called to return the service instance. This is short for registering a service where its provider consists of only a $get property, which is the given service factory function. You should use $provide.factory(getFn) if you do not need to configure your service in a provider. + * + * @param name The name of the instance. + * @param $getFn The $getFn for the instance creation. Internally this is a short hand for $provide.provider(name, {$get: $getFn}). + */ + factory(name: string, $getFn: Function): IModule; + /** + * Register a service factory, which will be called to return the service instance. This is short for registering a service where its provider consists of only a $get property, which is the given service factory function. You should use $provide.factory(getFn) if you do not need to configure your service in a provider. + * + * @param name The name of the instance. + * @param inlineAnnotatedFunction The $getFn for the instance creation. Internally this is a short hand for $provide.provider(name, {$get: $getFn}). + */ + factory(name: string, inlineAnnotatedFunction: any[]): IModule; + factory(object: Object): IModule; + filter(name: string, filterFactoryFunction: Function): IModule; + filter(name: string, inlineAnnotatedFunction: any[]): IModule; + filter(object: Object): IModule; + provider(name: string, serviceProviderFactory: IServiceProviderFactory): IModule; + provider(name: string, serviceProviderConstructor: IServiceProviderClass): IModule; + provider(name: string, inlineAnnotatedConstructor: any[]): IModule; + provider(name: string, providerObject: IServiceProvider): IModule; + provider(object: Object): IModule; + /** + * Run blocks are the closest thing in Angular to the main method. A run block is the code which needs to run to kickstart the application. It is executed after all of the service have been configured and the injector has been created. Run blocks typically contain code which is hard to unit-test, and for this reason should be declared in isolated modules, so that they can be ignored in the unit-tests. + */ + run(initializationFunction: Function): IModule; + /** + * Run blocks are the closest thing in Angular to the main method. A run block is the code which needs to run to kickstart the application. It is executed after all of the service have been configured and the injector has been created. Run blocks typically contain code which is hard to unit-test, and for this reason should be declared in isolated modules, so that they can be ignored in the unit-tests. + */ + run(inlineAnnotatedFunction: any[]): IModule; + service(name: string, serviceConstructor: Function): IModule; + service(name: string, inlineAnnotatedConstructor: any[]): IModule; + service(object: Object): IModule; + /** + * Register a value service with the $injector, such as a string, a number, an array, an object or a function. This is short for registering a service where its provider's $get property is a factory function that takes no arguments and returns the value service. + + Value services are similar to constant services, except that they cannot be injected into a module configuration function (see config) but they can be overridden by an Angular decorator. + * + * @param name The name of the instance. + * @param value The value. + */ + value(name: string, value: any): IModule; + value(object: Object): IModule; + + // Properties + name: string; + requires: string[]; + } + + /////////////////////////////////////////////////////////////////////////// + // Attributes + // see http://docs.angularjs.org/api/ng.$compile.directive.Attributes + /////////////////////////////////////////////////////////////////////////// + interface IAttributes { + /** + * this is necessary to be able to access the scoped attributes. it's not very elegant + * because you have to use attrs['foo'] instead of attrs.foo but I don't know of a better way + * this should really be limited to return string but it creates this problem: http://stackoverflow.com/q/17201854/165656 + */ + [name: string]: any; + + /** + * Adds the CSS class value specified by the classVal parameter to the + * element. If animations are enabled then an animation will be triggered + * for the class addition. + */ + $addClass(classVal: string): void; + + /** + * Removes the CSS class value specified by the classVal parameter from the + * element. If animations are enabled then an animation will be triggered for + * the class removal. + */ + $removeClass(classVal: string): void; + + /** + * Set DOM element attribute value. + */ + $set(key: string, value: any): void; + + /** + * Observes an interpolated attribute. + * The observer function will be invoked once during the next $digest + * following compilation. The observer is then invoked whenever the + * interpolated value changes. + */ + $observe(name: string, fn: (value?: any) => any): Function; + + /** + * A map of DOM element attribute names to the normalized name. This is needed + * to do reverse lookup from normalized name back to actual name. + */ + $attr: Object; + } + + /** + * form.FormController - type in module ng + * see https://docs.angularjs.org/api/ng/type/form.FormController + */ + interface IFormController { + + /** + * Indexer which should return ng.INgModelController for most properties but cannot because of "All named properties must be assignable to string indexer type" constraint - see https://github.com/Microsoft/TypeScript/issues/272 + */ + [name: string]: any; + + $pristine: boolean; + $dirty: boolean; + $valid: boolean; + $invalid: boolean; + $submitted: boolean; + $error: any; + $addControl(control: INgModelController): void; + $removeControl(control: INgModelController): void; + $setValidity(validationErrorKey: string, isValid: boolean, control: INgModelController): void; + $setDirty(): void; + $setPristine(): void; + $commitViewValue(): void; + $rollbackViewValue(): void; + $setSubmitted(): void; + $setUntouched(): void; + } + + /////////////////////////////////////////////////////////////////////////// + // NgModelController + // see http://docs.angularjs.org/api/ng.directive:ngModel.NgModelController + /////////////////////////////////////////////////////////////////////////// + interface INgModelController { + $render(): void; + $setValidity(validationErrorKey: string, isValid: boolean): void; + // Documentation states viewValue and modelValue to be a string but other + // types do work and it's common to use them. + $setViewValue(value: any, trigger?: string): void; + $setPristine(): void; + $validate(): void; + $setTouched(): void; + $setUntouched(): void; + $rollbackViewValue(): void; + $commitViewValue(): void; + $isEmpty(value: any): boolean; + + $viewValue: any; + + $modelValue: any; + + $parsers: IModelParser[]; + $formatters: IModelFormatter[]; + $viewChangeListeners: IModelViewChangeListener[]; + $error: any; + $name: string; + + $touched: boolean; + $untouched: boolean; + + $validators: IModelValidators; + $asyncValidators: IAsyncModelValidators; + + $pending: any; + $pristine: boolean; + $dirty: boolean; + $valid: boolean; + $invalid: boolean; + } + + interface IModelValidators { + [index: string]: (...args: any[]) => boolean; + } + + interface IAsyncModelValidators { + [index: string]: (...args: any[]) => IPromise<boolean>; + } + + interface IModelParser { + (value: any): any; + } + + interface IModelFormatter { + (value: any): any; + } + + interface IModelViewChangeListener { + (): void; + } + + /** + * $rootScope - $rootScopeProvider - service in module ng + * see https://docs.angularjs.org/api/ng/type/$rootScope.Scope and https://docs.angularjs.org/api/ng/service/$rootScope + */ + interface IRootScopeService { + [index: string]: any; + + $apply(): any; + $apply(exp: string): any; + $apply(exp: (scope: IScope) => any): any; + + $applyAsync(): any; + $applyAsync(exp: string): any; + $applyAsync(exp: (scope: IScope) => any): any; + + $broadcast(name: string, ...args: any[]): IAngularEvent; + $destroy(): void; + $digest(): void; + $emit(name: string, ...args: any[]): IAngularEvent; + + $eval(): any; + $eval(expression: string, locals?: Object): any; + $eval(expression: (scope: IScope) => any, locals?: Object): any; + + $evalAsync(): void; + $evalAsync(expression: string): void; + $evalAsync(expression: (scope: IScope) => any): void; + + // Defaults to false by the implementation checking strategy + $new(isolate?: boolean, parent?: IScope): IScope; + + /** + * Listens on events of a given type. See $emit for discussion of event life cycle. + * + * The event listener function format is: function(event, args...). + * + * @param name Event name to listen on. + * @param listener Function to call when the event is emitted. + */ + $on(name: string, listener: (event: IAngularEvent, ...args: any[]) => any): Function; + + $watch(watchExpression: string, listener?: string, objectEquality?: boolean): Function; + $watch(watchExpression: string, listener?: (newValue: any, oldValue: any, scope: IScope) => any, objectEquality?: boolean): Function; + $watch(watchExpression: (scope: IScope) => any, listener?: string, objectEquality?: boolean): Function; + $watch(watchExpression: (scope: IScope) => any, listener?: (newValue: any, oldValue: any, scope: IScope) => any, objectEquality?: boolean): Function; + + $watchCollection(watchExpression: string, listener: (newValue: any, oldValue: any, scope: IScope) => any): Function; + $watchCollection(watchExpression: (scope: IScope) => any, listener: (newValue: any, oldValue: any, scope: IScope) => any): Function; + + $watchGroup(watchExpressions: any[], listener: (newValue: any, oldValue: any, scope: IScope) => any): Function; + $watchGroup(watchExpressions: { (scope: IScope): any }[], listener: (newValue: any, oldValue: any, scope: IScope) => any): Function; + + $parent: IScope; + $root: IRootScopeService; + $id: number; + + // Hidden members + $$isolateBindings: any; + $$phase: any; + } + + interface IScope extends IRootScopeService { } + + /** + * $scope for ngRepeat directive. + * see https://docs.angularjs.org/api/ng/directive/ngRepeat + */ + interface IRepeatScope extends IScope { + + /** + * iterator offset of the repeated element (0..length-1). + */ + $index: number; + + /** + * true if the repeated element is first in the iterator. + */ + $first: boolean; + + /** + * true if the repeated element is between the first and last in the iterator. + */ + $middle: boolean; + + /** + * true if the repeated element is last in the iterator. + */ + $last: boolean; + + /** + * true if the iterator position $index is even (otherwise false). + */ + $even: boolean; + + /** + * true if the iterator position $index is odd (otherwise false). + */ + $odd: boolean; + + } + + interface IAngularEvent { + /** + * the scope on which the event was $emit-ed or $broadcast-ed. + */ + targetScope: IScope; + /** + * the scope that is currently handling the event. Once the event propagates through the scope hierarchy, this property is set to null. + */ + currentScope: IScope; + /** + * name of the event. + */ + name: string; + /** + * calling stopPropagation function will cancel further event propagation (available only for events that were $emit-ed). + */ + stopPropagation?: Function; + /** + * calling preventDefault sets defaultPrevented flag to true. + */ + preventDefault: Function; + /** + * true if preventDefault was called. + */ + defaultPrevented: boolean; + } + + /////////////////////////////////////////////////////////////////////////// + // WindowService + // see http://docs.angularjs.org/api/ng.$window + /////////////////////////////////////////////////////////////////////////// + interface IWindowService extends Window { + [key: string]: any; + } + + /////////////////////////////////////////////////////////////////////////// + // BrowserService + // TODO undocumented, so we need to get it from the source code + /////////////////////////////////////////////////////////////////////////// + interface IBrowserService { + defer: angular.ITimeoutService; + [key: string]: any; + } + + /////////////////////////////////////////////////////////////////////////// + // TimeoutService + // see http://docs.angularjs.org/api/ng.$timeout + /////////////////////////////////////////////////////////////////////////// + interface ITimeoutService { + (func: Function, delay?: number, invokeApply?: boolean): IPromise<any>; + cancel(promise: IPromise<any>): boolean; + } + + /////////////////////////////////////////////////////////////////////////// + // IntervalService + // see http://docs.angularjs.org/api/ng.$interval + /////////////////////////////////////////////////////////////////////////// + interface IIntervalService { + (func: Function, delay: number, count?: number, invokeApply?: boolean): IPromise<any>; + cancel(promise: IPromise<any>): boolean; + } + + /////////////////////////////////////////////////////////////////////////// + // AngularProvider + // see http://docs.angularjs.org/api/ng/provider/$animateProvider + /////////////////////////////////////////////////////////////////////////// + interface IAnimateProvider { + /** + * Registers a new injectable animation factory function. + * + * @param name The name of the animation. + * @param factory The factory function that will be executed to return the animation object. + */ + register(name: string, factory: () => IAnimateCallbackObject): void; + + /** + * Gets and/or sets the CSS class expression that is checked when performing an animation. + * + * @param expression The className expression which will be checked against all animations. + * @returns The current CSS className expression value. If null then there is no expression value. + */ + classNameFilter(expression?: RegExp): RegExp; + } + + /** + * The animation object which contains callback functions for each event that is expected to be animated. + */ + interface IAnimateCallbackObject { + eventFn(element: Node, doneFn: () => void): Function; + } + + /////////////////////////////////////////////////////////////////////////// + // FilterService + // see http://docs.angularjs.org/api/ng.$filter + // see http://docs.angularjs.org/api/ng.$filterProvider + /////////////////////////////////////////////////////////////////////////// + interface IFilterService { + (name: string): Function; + } + + interface IFilterProvider extends IServiceProvider { + register(name: string, filterFactory: Function): IServiceProvider; + } + + /////////////////////////////////////////////////////////////////////////// + // LocaleService + // see http://docs.angularjs.org/api/ng.$locale + /////////////////////////////////////////////////////////////////////////// + interface ILocaleService { + id: string; + + // These are not documented + // Check angular's i18n files for exemples + NUMBER_FORMATS: ILocaleNumberFormatDescriptor; + DATETIME_FORMATS: ILocaleDateTimeFormatDescriptor; + pluralCat: (num: any) => string; + } + + interface ILocaleNumberFormatDescriptor { + DECIMAL_SEP: string; + GROUP_SEP: string; + PATTERNS: ILocaleNumberPatternDescriptor[]; + CURRENCY_SYM: string; + } + + interface ILocaleNumberPatternDescriptor { + minInt: number; + minFrac: number; + maxFrac: number; + posPre: string; + posSuf: string; + negPre: string; + negSuf: string; + gSize: number; + lgSize: number; + } + + interface ILocaleDateTimeFormatDescriptor { + MONTH: string[]; + SHORTMONTH: string[]; + DAY: string[]; + SHORTDAY: string[]; + AMPMS: string[]; + medium: string; + short: string; + fullDate: string; + longDate: string; + mediumDate: string; + shortDate: string; + mediumTime: string; + shortTime: string; + } + + /////////////////////////////////////////////////////////////////////////// + // LogService + // see http://docs.angularjs.org/api/ng.$log + // see http://docs.angularjs.org/api/ng.$logProvider + /////////////////////////////////////////////////////////////////////////// + interface ILogService { + debug: ILogCall; + error: ILogCall; + info: ILogCall; + log: ILogCall; + warn: ILogCall; + } + + interface ILogProvider { + debugEnabled(): boolean; + debugEnabled(enabled: boolean): ILogProvider; + } + + // We define this as separate interface so we can reopen it later for + // the ngMock module. + interface ILogCall { + (...args: any[]): void; + } + + /////////////////////////////////////////////////////////////////////////// + // ParseService + // see http://docs.angularjs.org/api/ng.$parse + // see http://docs.angularjs.org/api/ng.$parseProvider + /////////////////////////////////////////////////////////////////////////// + interface IParseService { + (expression: string): ICompiledExpression; + } + + interface IParseProvider { + logPromiseWarnings(): boolean; + logPromiseWarnings(value: boolean): IParseProvider; + + unwrapPromises(): boolean; + unwrapPromises(value: boolean): IParseProvider; + } + + interface ICompiledExpression { + (context: any, locals?: any): any; + + // If value is not provided, undefined is gonna be used since the implementation + // does not check the parameter. Let's force a value for consistency. If consumer + // whants to undefine it, pass the undefined value explicitly. + assign(context: any, value: any): any; + } + + /** + * $location - $locationProvider - service in module ng + * see https://docs.angularjs.org/api/ng/service/$location + */ + interface ILocationService { + absUrl(): string; + hash(): string; + hash(newHash: string): ILocationService; + host(): string; + + /** + * Return path of current url + */ + path(): string; + + /** + * Change path when called with parameter and return $location. + * Note: Path should always begin with forward slash (/), this method will add the forward slash if it is missing. + * + * @param path New path + */ + path(path: string): ILocationService; + + port(): number; + protocol(): string; + replace(): ILocationService; + + /** + * Return search part (as object) of current url + */ + search(): any; + + /** + * Change search part when called with parameter and return $location. + * + * @param search When called with a single argument the method acts as a setter, setting the search component of $location to the specified value. + * + * If the argument is a hash object containing an array of values, these values will be encoded as duplicate search parameters in the url. + */ + search(search: any): ILocationService; + + /** + * Change search part when called with parameter and return $location. + * + * @param search New search params + * @param paramValue If search is a string or a Number, then paramValue will override only a single search property. If paramValue is null, the property specified via the first argument will be deleted. If paramValue is an array, it will override the property of the search component of $location specified via the first argument. If paramValue is true, the property specified via the first argument will be added with no value nor trailing equal sign. + */ + search(search: string, paramValue: string|number|string[]|boolean): ILocationService; + + state(): any; + state(state: any): ILocationService; + url(): string; + url(url: string): ILocationService; + } + + interface ILocationProvider extends IServiceProvider { + hashPrefix(): string; + hashPrefix(prefix: string): ILocationProvider; + html5Mode(): boolean; + + // Documentation states that parameter is string, but + // implementation tests it as boolean, which makes more sense + // since this is a toggler + html5Mode(active: boolean): ILocationProvider; + html5Mode(mode: { enabled?: boolean; requireBase?: boolean; rewriteLinks?: boolean; }): ILocationProvider; + } + + /////////////////////////////////////////////////////////////////////////// + // DocumentService + // see http://docs.angularjs.org/api/ng.$document + /////////////////////////////////////////////////////////////////////////// + interface IDocumentService extends IAugmentedJQuery {} + + /////////////////////////////////////////////////////////////////////////// + // ExceptionHandlerService + // see http://docs.angularjs.org/api/ng.$exceptionHandler + /////////////////////////////////////////////////////////////////////////// + interface IExceptionHandlerService { + (exception: Error, cause?: string): void; + } + + /////////////////////////////////////////////////////////////////////////// + // RootElementService + // see http://docs.angularjs.org/api/ng.$rootElement + /////////////////////////////////////////////////////////////////////////// + interface IRootElementService extends JQuery {} + + interface IQResolveReject<T> { + (): void; + (value: T): void; + } + /** + * $q - service in module ng + * A promise/deferred implementation inspired by Kris Kowal's Q. + * See http://docs.angularjs.org/api/ng/service/$q + */ + interface IQService { + new (resolver: (resolve: IQResolveReject<any>) => any): IPromise<any>; + new (resolver: (resolve: IQResolveReject<any>, reject: IQResolveReject<any>) => any): IPromise<any>; + new <T>(resolver: (resolve: IQResolveReject<T>, reject: IQResolveReject<any>) => any): IPromise<T>; + + /** + * Combines multiple promises into a single promise that is resolved when all of the input promises are resolved. + * + * Returns a single promise that will be resolved with an array of values, each value corresponding to the promise at the same index in the promises array. If any of the promises is resolved with a rejection, this resulting promise will be rejected with the same rejection value. + * + * @param promises An array of promises. + */ + all(promises: IPromise<any>[]): IPromise<any[]>; + /** + * Combines multiple promises into a single promise that is resolved when all of the input promises are resolved. + * + * Returns a single promise that will be resolved with a hash of values, each value corresponding to the promise at the same key in the promises hash. If any of the promises is resolved with a rejection, this resulting promise will be rejected with the same rejection value. + * + * @param promises A hash of promises. + */ + all(promises: { [id: string]: IPromise<any>; }): IPromise<{ [id: string]: any; }>; + /** + * Creates a Deferred object which represents a task which will finish in the future. + */ + defer<T>(): IDeferred<T>; + /** + * Creates a promise that is resolved as rejected with the specified reason. This api should be used to forward rejection in a chain of promises. If you are dealing with the last promise in a promise chain, you don't need to worry about it. + * + * When comparing deferreds/promises to the familiar behavior of try/catch/throw, think of reject as the throw keyword in JavaScript. This also means that if you "catch" an error via a promise error callback and you want to forward the error to the promise derived from the current promise, you have to "rethrow" the error by returning a rejection constructed via reject. + * + * @param reason Constant, message, exception or an object representing the rejection reason. + */ + reject(reason?: any): IPromise<any>; + /** + * Wraps an object that might be a value or a (3rd party) then-able promise into a $q promise. This is useful when you are dealing with an object that might or might not be a promise, or if the promise comes from a source that can't be trusted. + * + * @param value Value or a promise + */ + when<T>(value: IPromise<T>|T): IPromise<T>; + /** + * Wraps an object that might be a value or a (3rd party) then-able promise into a $q promise. This is useful when you are dealing with an object that might or might not be a promise, or if the promise comes from a source that can't be trusted. + * + * @param value Value or a promise + */ + when(): IPromise<void>; + } + + interface IPromise<T> { + /** + * Regardless of when the promise was or will be resolved or rejected, then calls one of the success or error callbacks asynchronously as soon as the result is available. The callbacks are called with a single argument: the result or rejection reason. Additionally, the notify callback may be called zero or more times to provide a progress indication, before the promise is resolved or rejected. + * + * This method returns a new promise which is resolved or rejected via the return value of the successCallback, errorCallback. It also notifies via the return value of the notifyCallback method. The promise can not be resolved or rejected from the notifyCallback method. + */ + then<TResult>(successCallback: (promiseValue: T) => IHttpPromise<TResult>|IPromise<TResult>|TResult, errorCallback?: (reason: any) => any, notifyCallback?: (state: any) => any): IPromise<TResult>; + + /** + * Shorthand for promise.then(null, errorCallback) + */ + catch<TResult>(onRejected: (reason: any) => IHttpPromise<TResult>|IPromise<TResult>|TResult): IPromise<TResult>; + + /** + * Allows you to observe either the fulfillment or rejection of a promise, but to do so without modifying the final value. This is useful to release resources or do some clean-up that needs to be done whether the promise was rejected or resolved. See the full specification for more information. + * + * Because finally is a reserved word in JavaScript and reserved keywords are not supported as property names by ES3, you'll need to invoke the method like promise['finally'](callback) to make your code IE8 and Android 2.x compatible. + */ + finally<TResult>(finallyCallback: () => any): IPromise<TResult>; + } + + interface IDeferred<T> { + resolve(value?: T): void; + reject(reason?: any): void; + notify(state?: any): void; + promise: IPromise<T>; + } + + /////////////////////////////////////////////////////////////////////////// + // AnchorScrollService + // see http://docs.angularjs.org/api/ng.$anchorScroll + /////////////////////////////////////////////////////////////////////////// + interface IAnchorScrollService { + (): void; + yOffset: any; + } + + interface IAnchorScrollProvider extends IServiceProvider { + disableAutoScrolling(): void; + } + + /////////////////////////////////////////////////////////////////////////// + // CacheFactoryService + // see http://docs.angularjs.org/api/ng.$cacheFactory + /////////////////////////////////////////////////////////////////////////// + interface ICacheFactoryService { + // Lets not foce the optionsMap to have the capacity member. Even though + // it's the ONLY option considered by the implementation today, a consumer + // might find it useful to associate some other options to the cache object. + //(cacheId: string, optionsMap?: { capacity: number; }): CacheObject; + (cacheId: string, optionsMap?: { capacity: number; }): ICacheObject; + + // Methods bellow are not documented + info(): any; + get(cacheId: string): ICacheObject; + } + + interface ICacheObject { + info(): { + id: string; + size: number; + + // Not garanteed to have, since it's a non-mandatory option + //capacity: number; + }; + put<T>(key: string, value?: T): T; + get(key: string): any; + remove(key: string): void; + removeAll(): void; + destroy(): void; + } + + /////////////////////////////////////////////////////////////////////////// + // CompileService + // see http://docs.angularjs.org/api/ng.$compile + // see http://docs.angularjs.org/api/ng.$compileProvider + /////////////////////////////////////////////////////////////////////////// + interface ICompileService { + (element: string, transclude?: ITranscludeFunction, maxPriority?: number): ITemplateLinkingFunction; + (element: Element, transclude?: ITranscludeFunction, maxPriority?: number): ITemplateLinkingFunction; + (element: JQuery, transclude?: ITranscludeFunction, maxPriority?: number): ITemplateLinkingFunction; + } + + interface ICompileProvider extends IServiceProvider { + directive(name: string, directiveFactory: Function): ICompileProvider; + + // Undocumented, but it is there... + directive(directivesMap: any): ICompileProvider; + + aHrefSanitizationWhitelist(): RegExp; + aHrefSanitizationWhitelist(regexp: RegExp): ICompileProvider; + + imgSrcSanitizationWhitelist(): RegExp; + imgSrcSanitizationWhitelist(regexp: RegExp): ICompileProvider; + + debugInfoEnabled(enabled?: boolean): any; + } + + interface ICloneAttachFunction { + // Let's hint but not force cloneAttachFn's signature + (clonedElement?: JQuery, scope?: IScope): any; + } + + // This corresponds to the "publicLinkFn" returned by $compile. + interface ITemplateLinkingFunction { + (scope: IScope, cloneAttachFn?: ICloneAttachFunction): IAugmentedJQuery; + } + + // This corresponds to $transclude (and also the transclude function passed to link). + interface ITranscludeFunction { + // If the scope is provided, then the cloneAttachFn must be as well. + (scope: IScope, cloneAttachFn: ICloneAttachFunction): IAugmentedJQuery; + // If one argument is provided, then it's assumed to be the cloneAttachFn. + (cloneAttachFn?: ICloneAttachFunction): IAugmentedJQuery; + } + + /////////////////////////////////////////////////////////////////////////// + // ControllerService + // see http://docs.angularjs.org/api/ng.$controller + // see http://docs.angularjs.org/api/ng.$controllerProvider + /////////////////////////////////////////////////////////////////////////// + interface IControllerService { + // Although the documentation doesn't state this, locals are optional + (controllerConstructor: Function, locals?: any): any; + (controllerName: string, locals?: any): any; + } + + interface IControllerProvider extends IServiceProvider { + register(name: string, controllerConstructor: Function): void; + register(name: string, dependencyAnnotatedConstructor: any[]): void; + allowGlobals(): void; + } + + /** + * HttpService + * see http://docs.angularjs.org/api/ng/service/$http + */ + interface IHttpService { + /** + * Object describing the request to be made and how it should be processed. + */ + <T>(config: IRequestConfig): IHttpPromise<T>; + + /** + * Shortcut method to perform GET request. + * + * @param url Relative or absolute URL specifying the destination of the request + * @param config Optional configuration object + */ + get<T>(url: string, config?: IRequestShortcutConfig): IHttpPromise<T>; + + /** + * Shortcut method to perform DELETE request. + * + * @param url Relative or absolute URL specifying the destination of the request + * @param config Optional configuration object + */ + delete<T>(url: string, config?: IRequestShortcutConfig): IHttpPromise<T>; + + /** + * Shortcut method to perform HEAD request. + * + * @param url Relative or absolute URL specifying the destination of the request + * @param config Optional configuration object + */ + head<T>(url: string, config?: IRequestShortcutConfig): IHttpPromise<T>; + + /** + * Shortcut method to perform JSONP request. + * + * @param url Relative or absolute URL specifying the destination of the request + * @param config Optional configuration object + */ + jsonp<T>(url: string, config?: IRequestShortcutConfig): IHttpPromise<T>; + + /** + * Shortcut method to perform POST request. + * + * @param url Relative or absolute URL specifying the destination of the request + * @param data Request content + * @param config Optional configuration object + */ + post<T>(url: string, data: any, config?: IRequestShortcutConfig): IHttpPromise<T>; + + /** + * Shortcut method to perform PUT request. + * + * @param url Relative or absolute URL specifying the destination of the request + * @param data Request content + * @param config Optional configuration object + */ + put<T>(url: string, data: any, config?: IRequestShortcutConfig): IHttpPromise<T>; + + /** + * Shortcut method to perform PATCH request. + * + * @param url Relative or absolute URL specifying the destination of the request + * @param data Request content + * @param config Optional configuration object + */ + patch<T>(url: string, data: any, config?: IRequestShortcutConfig): IHttpPromise<T>; + + /** + * Runtime equivalent of the $httpProvider.defaults property. Allows configuration of default headers, withCredentials as well as request and response transformations. + */ + defaults: IRequestConfig; + + /** + * Array of config objects for currently pending requests. This is primarily meant to be used for debugging purposes. + */ + pendingRequests: any[]; + } + + /** + * Object describing the request to be made and how it should be processed. + * see http://docs.angularjs.org/api/ng/service/$http#usage + */ + interface IRequestShortcutConfig { + /** + * {Object.<string|Object>} + * Map of strings or objects which will be turned to ?key1=value1&key2=value2 after the url. If the value is not a string, it will be JSONified. + */ + params?: any; + + /** + * Map of strings or functions which return strings representing HTTP headers to send to the server. If the return value of a function is null, the header will not be sent. + */ + headers?: any; + + /** + * Name of HTTP header to populate with the XSRF token. + */ + xsrfHeaderName?: string; + + /** + * Name of cookie containing the XSRF token. + */ + xsrfCookieName?: string; + + /** + * {boolean|Cache} + * If true, a default $http cache will be used to cache the GET request, otherwise if a cache instance built with $cacheFactory, this cache will be used for caching. + */ + cache?: any; + + /** + * whether to to set the withCredentials flag on the XHR object. See [requests with credentials]https://developer.mozilla.org/en/http_access_control#section_5 for more information. + */ + withCredentials?: boolean; + + /** + * {string|Object} + * Data to be sent as the request message data. + */ + data?: any; + + /** + * {function(data, headersGetter)|Array.<function(data, headersGetter)>} + * Transform function or an array of such functions. The transform function takes the http request body and headers and returns its transformed (typically serialized) version. + */ + transformRequest?: any; + + /** + * {function(data, headersGetter)|Array.<function(data, headersGetter)>} + * Transform function or an array of such functions. The transform function takes the http response body and headers and returns its transformed (typically deserialized) version. + */ + transformResponse?: any; + + /** + * {number|Promise} + * Timeout in milliseconds, or promise that should abort the request when resolved. + */ + timeout?: any; + + /** + * See requestType. + */ + responseType?: string; + } + + /** + * Object describing the request to be made and how it should be processed. + * see http://docs.angularjs.org/api/ng/service/$http#usage + */ + interface IRequestConfig extends IRequestShortcutConfig { + /** + * HTTP method (e.g. 'GET', 'POST', etc) + */ + method: string; + /** + * Absolute or relative URL of the resource that is being requested. + */ + url: string; + } + + interface IHttpHeadersGetter { + (): { [name: string]: string; }; + (headerName: string): string; + } + + interface IHttpPromiseCallback<T> { + (data: T, status: number, headers: IHttpHeadersGetter, config: IRequestConfig): void; + } + + interface IHttpPromiseCallbackArg<T> { + data?: T; + status?: number; + headers?: IHttpHeadersGetter; + config?: IRequestConfig; + statusText?: string; + } + + interface IHttpPromise<T> extends IPromise<IHttpPromiseCallbackArg<T>> { + success(callback: IHttpPromiseCallback<T>): IHttpPromise<T>; + error(callback: IHttpPromiseCallback<any>): IHttpPromise<T>; + then<TResult>(successCallback: (response: IHttpPromiseCallbackArg<T>) => IPromise<TResult>|TResult, errorCallback?: (response: IHttpPromiseCallbackArg<any>) => any): IPromise<TResult>; + } + + /** + * Object that controls the defaults for $http provider + * https://docs.angularjs.org/api/ng/service/$http#defaults + */ + interface IHttpProviderDefaults { + xsrfCookieName?: string; + xsrfHeaderName?: string; + withCredentials?: boolean; + headers?: { + common?: any; + post?: any; + put?: any; + patch?: any; + } + } + + interface IHttpProvider extends IServiceProvider { + defaults: IHttpProviderDefaults; + interceptors: any[]; + useApplyAsync(): boolean; + useApplyAsync(value: boolean): IHttpProvider; + } + + /////////////////////////////////////////////////////////////////////////// + // HttpBackendService + // see http://docs.angularjs.org/api/ng.$httpBackend + // You should never need to use this service directly. + /////////////////////////////////////////////////////////////////////////// + interface IHttpBackendService { + // XXX Perhaps define callback signature in the future + (method: string, url: string, post?: any, callback?: Function, headers?: any, timeout?: number, withCredentials?: boolean): void; + } + + /////////////////////////////////////////////////////////////////////////// + // InterpolateService + // see http://docs.angularjs.org/api/ng.$interpolate + // see http://docs.angularjs.org/api/ng.$interpolateProvider + /////////////////////////////////////////////////////////////////////////// + interface IInterpolateService { + (text: string, mustHaveExpression?: boolean, trustedContext?: string, allOrNothing?: boolean): IInterpolationFunction; + endSymbol(): string; + startSymbol(): string; + } + + interface IInterpolationFunction { + (context: any): string; + } + + interface IInterpolateProvider extends IServiceProvider { + startSymbol(): string; + startSymbol(value: string): IInterpolateProvider; + endSymbol(): string; + endSymbol(value: string): IInterpolateProvider; + } + + /////////////////////////////////////////////////////////////////////////// + // TemplateCacheService + // see http://docs.angularjs.org/api/ng.$templateCache + /////////////////////////////////////////////////////////////////////////// + interface ITemplateCacheService extends ICacheObject {} + + /////////////////////////////////////////////////////////////////////////// + // SCEService + // see http://docs.angularjs.org/api/ng.$sce + /////////////////////////////////////////////////////////////////////////// + interface ISCEService { + getTrusted(type: string, mayBeTrusted: any): any; + getTrustedCss(value: any): any; + getTrustedHtml(value: any): any; + getTrustedJs(value: any): any; + getTrustedResourceUrl(value: any): any; + getTrustedUrl(value: any): any; + parse(type: string, expression: string): (context: any, locals: any) => any; + parseAsCss(expression: string): (context: any, locals: any) => any; + parseAsHtml(expression: string): (context: any, locals: any) => any; + parseAsJs(expression: string): (context: any, locals: any) => any; + parseAsResourceUrl(expression: string): (context: any, locals: any) => any; + parseAsUrl(expression: string): (context: any, locals: any) => any; + trustAs(type: string, value: any): any; + trustAsHtml(value: any): any; + trustAsJs(value: any): any; + trustAsResourceUrl(value: any): any; + trustAsUrl(value: any): any; + isEnabled(): boolean; + } + + /////////////////////////////////////////////////////////////////////////// + // SCEProvider + // see http://docs.angularjs.org/api/ng.$sceProvider + /////////////////////////////////////////////////////////////////////////// + interface ISCEProvider extends IServiceProvider { + enabled(value: boolean): void; + } + + /////////////////////////////////////////////////////////////////////////// + // SCEDelegateService + // see http://docs.angularjs.org/api/ng.$sceDelegate + /////////////////////////////////////////////////////////////////////////// + interface ISCEDelegateService { + getTrusted(type: string, mayBeTrusted: any): any; + trustAs(type: string, value: any): any; + valueOf(value: any): any; + } + + + /////////////////////////////////////////////////////////////////////////// + // SCEDelegateProvider + // see http://docs.angularjs.org/api/ng.$sceDelegateProvider + /////////////////////////////////////////////////////////////////////////// + interface ISCEDelegateProvider extends IServiceProvider { + resourceUrlBlacklist(blacklist: any[]): void; + resourceUrlWhitelist(whitelist: any[]): void; + } + + /** + * $templateRequest service + * see http://docs.angularjs.org/api/ng/service/$templateRequest + */ + interface ITemplateRequestService { + /** + * Downloads a template using $http and, upon success, stores the + * contents inside of $templateCache. + * + * If the HTTP request fails or the response data of the HTTP request is + * empty then a $compile error will be thrown (unless + * {ignoreRequestError} is set to true). + * + * @param tpl The template URL. + * @param ignoreRequestError Whether or not to ignore the exception + * when the request fails or the template is + * empty. + * + * @return A promise whose value is the template content. + */ + (tpl: string, ignoreRequestError?: boolean): IPromise<string>; + /** + * total amount of pending template requests being downloaded. + * @type {number} + */ + totalPendingRequests: number; + } + + /////////////////////////////////////////////////////////////////////////// + // Directive + // see http://docs.angularjs.org/api/ng.$compileProvider#directive + // and http://docs.angularjs.org/guide/directive + /////////////////////////////////////////////////////////////////////////// + + interface IDirectiveFactory { + (...args: any[]): IDirective; + } + + interface IDirectiveLinkFn { + ( + scope: IScope, + instanceElement: IAugmentedJQuery, + instanceAttributes: IAttributes, + controller: any, + transclude: ITranscludeFunction + ): void; + } + + interface IDirectivePrePost { + pre?: IDirectiveLinkFn; + post?: IDirectiveLinkFn; + } + + interface IDirectiveCompileFn { + ( + templateElement: IAugmentedJQuery, + templateAttributes: IAttributes, + transclude: ITranscludeFunction + ): IDirectivePrePost; + } + + interface IDirective { + compile?: IDirectiveCompileFn; + controller?: any; + controllerAs?: string; + bindToController?: boolean; + link?: IDirectiveLinkFn | IDirectivePrePost; + name?: string; + priority?: number; + replace?: boolean; + require?: any; + restrict?: string; + scope?: any; + template?: any; + templateUrl?: any; + terminal?: boolean; + transclude?: any; + } + + /** + * angular.element + * when calling angular.element, angular returns a jQuery object, + * augmented with additional methods like e.g. scope. + * see: http://docs.angularjs.org/api/angular.element + */ + interface IAugmentedJQueryStatic extends JQueryStatic { + (selector: string, context?: any): IAugmentedJQuery; + (element: Element): IAugmentedJQuery; + (object: {}): IAugmentedJQuery; + (elementArray: Element[]): IAugmentedJQuery; + (object: JQuery): IAugmentedJQuery; + (func: Function): IAugmentedJQuery; + (array: any[]): IAugmentedJQuery; + (): IAugmentedJQuery; + } + + interface IAugmentedJQuery extends JQuery { + // TODO: events, how to define? + //$destroy + + find(selector: string): IAugmentedJQuery; + find(element: any): IAugmentedJQuery; + find(obj: JQuery): IAugmentedJQuery; + controller(): any; + controller(name: string): any; + injector(): any; + scope(): IScope; + isolateScope(): IScope; + + inheritedData(key: string, value: any): JQuery; + inheritedData(obj: { [key: string]: any; }): JQuery; + inheritedData(key?: string): any; + } + + /////////////////////////////////////////////////////////////////////// + // AnimateService + // see http://docs.angularjs.org/api/ng.$animate + /////////////////////////////////////////////////////////////////////// + interface IAnimateService { + addClass(element: JQuery, className: string, done?: Function): IPromise<any>; + enter(element: JQuery, parent: JQuery, after: JQuery, done?: Function): void; + leave(element: JQuery, done?: Function): void; + move(element: JQuery, parent: JQuery, after: JQuery, done?: Function): void; + removeClass(element: JQuery, className: string, done?: Function): void; + } + + /////////////////////////////////////////////////////////////////////////// + // AUTO module (angular.js) + /////////////////////////////////////////////////////////////////////////// + export module auto { + + /////////////////////////////////////////////////////////////////////// + // InjectorService + // see http://docs.angularjs.org/api/AUTO.$injector + /////////////////////////////////////////////////////////////////////// + interface IInjectorService { + annotate(fn: Function): string[]; + annotate(inlineAnnotatedFunction: any[]): string[]; + get(name: string): any; + has(name: string): boolean; + instantiate(typeConstructor: Function, locals?: any): any; + invoke(inlineAnnotatedFunction: any[]): any; + invoke(func: Function, context?: any, locals?: any): any; + } + + /////////////////////////////////////////////////////////////////////// + // ProvideService + // see http://docs.angularjs.org/api/AUTO.$provide + /////////////////////////////////////////////////////////////////////// + interface IProvideService { + // Documentation says it returns the registered instance, but actual + // implementation does not return anything. + // constant(name: string, value: any): any; + /** + * Register a constant service, such as a string, a number, an array, an object or a function, with the $injector. Unlike value it can be injected into a module configuration function (see config) and it cannot be overridden by an Angular decorator. + * + * @param name The name of the constant. + * @param value The constant value. + */ + constant(name: string, value: any): void; + + /** + * Register a service decorator with the $injector. A service decorator intercepts the creation of a service, allowing it to override or modify the behaviour of the service. The object returned by the decorator may be the original service, or a new service object which replaces or wraps and delegates to the original service. + * + * @param name The name of the service to decorate. + * @param decorator This function will be invoked when the service needs to be instantiated and should return the decorated service instance. The function is called using the injector.invoke method and is therefore fully injectable. Local injection arguments: + * + * $delegate - The original service instance, which can be monkey patched, configured, decorated or delegated to. + */ + decorator(name: string, decorator: Function): void; + /** + * Register a service decorator with the $injector. A service decorator intercepts the creation of a service, allowing it to override or modify the behaviour of the service. The object returned by the decorator may be the original service, or a new service object which replaces or wraps and delegates to the original service. + * + * @param name The name of the service to decorate. + * @param inlineAnnotatedFunction This function will be invoked when the service needs to be instantiated and should return the decorated service instance. The function is called using the injector.invoke method and is therefore fully injectable. Local injection arguments: + * + * $delegate - The original service instance, which can be monkey patched, configured, decorated or delegated to. + */ + decorator(name: string, inlineAnnotatedFunction: any[]): void; + factory(name: string, serviceFactoryFunction: Function): IServiceProvider; + factory(name: string, inlineAnnotatedFunction: any[]): IServiceProvider; + provider(name: string, provider: IServiceProvider): IServiceProvider; + provider(name: string, serviceProviderConstructor: Function): IServiceProvider; + service(name: string, constructor: Function): IServiceProvider; + value(name: string, value: any): IServiceProvider; + } + + } +} diff --git a/catalog-ui/typings/angularjs/restangular.d.ts b/catalog-ui/typings/angularjs/restangular.d.ts new file mode 100644 index 0000000000..3428b0493f --- /dev/null +++ b/catalog-ui/typings/angularjs/restangular.d.ts @@ -0,0 +1,156 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ +// Type definitions for Restangular v1.4.0 +// Project: https://github.com/mgonto/restangular +// Definitions by: Boris Yankov <https://github.com/borisyankov/> +// Definitions: https://github.com/borisyankov/DefinitelyTyped + + +/// <reference path="../angularjs/angular.d.ts" /> + +// Support AMD require (copying angular.d.ts approach) +// allows for import {IRequestConfig} from 'restangular' ES6 approach +declare module 'restangular' { + export = restangular; +} + + + +declare module restangular { + + interface IPromise<T> extends angular.IPromise<T> { + call(methodName: string, params?: any): IPromise<T>; + get(fieldName: string): IPromise<T>; + $object: T; + } + + interface ICollectionPromise<T> extends angular.IPromise<T[]> { + push(object: any): ICollectionPromise<T>; + call(methodName: string, params?: any): ICollectionPromise<T>; + get(fieldName: string): ICollectionPromise<T>; + $object: T[]; + } + + interface IResponse { + status: number; + data: any; + headers(name: string): string; + config: { + method: string; + url: string; + params: any; + } + } + + interface IProvider { + setBaseUrl(baseUrl: string): void; + setExtraFields(fields: string[]): void; + setParentless(parentless: boolean, routes: string[]): void; + setDefaultHttpFields(httpFields: any): void; + addElementTransformer(route: string, transformer: Function): void; + addElementTransformer(route: string, isCollection: boolean, transformer: Function): void; + setTransformOnlyServerElements(active: boolean): void; + setOnElemRestangularized(callback: (elem: any, isCollection: boolean, what: string, restangular: IService) => any): void; + setResponseInterceptor(responseInterceptor: (data: any, operation: string, what: string, url: string, response: IResponse, deferred: angular.IDeferred<any>) => any): void; + setResponseExtractor(responseInterceptor: (data: any, operation: string, what: string, url: string, response: IResponse, deferred: angular.IDeferred<any>) => any): void; + addResponseInterceptor(responseInterceptor: (data: any, operation: string, what: string, url: string, response: IResponse, deferred: angular.IDeferred<any>) => any): void; + setRequestInterceptor(requestInterceptor: (element: any, operation: string, what: string, url: string) => any): void; + addRequestInterceptor(requestInterceptor: (element: any, operation: string, what: string, url: string) => any): void; + setFullRequestInterceptor(fullRequestInterceptor: (element: any, operation: string, what: string, url: string, headers: any, params: any, httpConfig: angular.IRequestShortcutConfig) => {element: any; headers: any; params: any}): void; + addFullRequestInterceptor(requestInterceptor: (element: any, operation: string, what: string, url: string, headers: any, params: any, httpConfig: angular.IRequestShortcutConfig) => {headers: any; params: any; element: any; httpConfig: angular.IRequestShortcutConfig}): void; + setErrorInterceptor(errorInterceptor: (response: IResponse, deferred: angular.IDeferred<any>) => any): void; + setRestangularFields(fields: {[fieldName: string]: string}): void; + setMethodOverriders(overriders: string[]): void; + setJsonp(jsonp: boolean): void; + setDefaultRequestParams(params: any): void; + setDefaultRequestParams(method: string, params: any): void; + setDefaultRequestParams(methods: string[], params: any): void; + setFullResponse(fullResponse: boolean): void; + setDefaultHeaders(headers: any): void; + setRequestSuffix(suffix: string): void; + setUseCannonicalId(useCannonicalId: boolean): void; + setEncodeIds(encode: boolean): void; + } + + interface ICustom { + customGET(path: string, params?: any, headers?: any): IPromise<any>; + customGETLIST(path: string, params?: any, headers?: any): ICollectionPromise<any>; + customDELETE(path: string, params?: any, headers?: any): IPromise<any>; + customPOST(elem?: any, path?: string, params?: any, headers?: any): IPromise<any>; + customPUT(elem?: any, path?: string, params?: any, headers?: any): IPromise<any>; + customOperation(operation: string, path: string, params?: any, headers?: any, elem?: any): IPromise<any>; + addRestangularMethod(name: string, operation: string, path?: string, params?: any, headers?: any, elem?: any): IPromise<any>; + } + + interface IService extends ICustom, IProvider { + one(route: string, id?: number): IElement; + one(route: string, id?: string): IElement; + oneUrl(route: string, url: string): IElement; + all(route: string): IElement; + allUrl(route: string, url: string): IElement; + copy(fromElement: any): IElement; + withConfig(configurer: (RestangularProvider: IProvider) => any): IService; + restangularizeElement(parent: any, element: any, route: string, collection?: any, reqParams?: any): IElement; + restangularizeCollection(parent: any, element: any, route: string): ICollection; + service(route: string, parent?: any): IService; + stripRestangular(element: any): any; + extendModel(route: string, extender: (model: IElement) => any): void; + } + + interface IElement extends IService { + get(queryParams?: any, headers?: any): IPromise<any>; + get<T>(queryParams?: any, headers?: any): IPromise<T>; + getList(subElement?: any, queryParams?: any, headers?: any): ICollectionPromise<any>; + getList<T>(subElement?: any, queryParams?: any, headers?: any): ICollectionPromise<T>; + put(queryParams?: any, headers?: any): IPromise<any>; + post(subElement: any, elementToPost: any, queryParams?: any, headers?: any): IPromise<any>; + post<T>(subElement: any, elementToPost: T, queryParams?: any, headers?: any): IPromise<T>; + post(elementToPost: any, queryParams?: any, headers?: any): IPromise<any>; + post<T>(elementToPost: T, queryParams?: any, headers?: any): IPromise<T>; + remove(queryParams?: any, headers?: any): IPromise<any>; + head(queryParams?: any, headers?: any): IPromise<any>; + trace(queryParams?: any, headers?: any): IPromise<any>; + options(queryParams?: any, headers?: any): IPromise<any>; + patch(queryParams?: any, headers?: any): IPromise<any>; + clone(): IElement; + plain(): any; + plain<T>(): T; + withHttpConfig(httpConfig: angular.IRequestShortcutConfig): IElement; + save(queryParams?: any, headers?: any): IPromise<any>; + getRestangularUrl(): string; + } + + interface ICollection extends IService, Array<any> { + getList(queryParams?: any, headers?: any): ICollectionPromise<any>; + getList<T>(queryParams?: any, headers?: any): ICollectionPromise<T>; + post(elementToPost: any, queryParams?: any, headers?: any): IPromise<any>; + post<T>(elementToPost: T, queryParams?: any, headers?: any): IPromise<T>; + head(queryParams?: any, headers?: any): IPromise<any>; + trace(queryParams?: any, headers?: any): IPromise<any>; + options(queryParams?: any, headers?: any): IPromise<any>; + patch(queryParams?: any, headers?: any): IPromise<any>; + putElement(idx: any, params: any, headers: any): IPromise<any>; + withHttpConfig(httpConfig: angular.IRequestShortcutConfig): ICollection; + clone(): ICollection; + plain(): any; + plain<T>(): T[]; + getRestangularUrl(): string; + } +} diff --git a/catalog-ui/typings/cytoscape/cytoscape-extension.js b/catalog-ui/typings/cytoscape/cytoscape-extension.js new file mode 100644 index 0000000000..dbf22c37b9 --- /dev/null +++ b/catalog-ui/typings/cytoscape/cytoscape-extension.js @@ -0,0 +1 @@ +//# sourceMappingURL=cytoscape-extension.js.map
\ No newline at end of file diff --git a/catalog-ui/typings/cytoscape/cytoscape-extension.js.map b/catalog-ui/typings/cytoscape/cytoscape-extension.js.map new file mode 100644 index 0000000000..5eeda401dc --- /dev/null +++ b/catalog-ui/typings/cytoscape/cytoscape-extension.js.map @@ -0,0 +1 @@ +{"version":3,"file":"cytoscape-extension.js","sourceRoot":"","sources":["cytoscape-extension.ts"],"names":[],"mappings":""}
\ No newline at end of file diff --git a/catalog-ui/typings/cytoscape/cytoscape-extension.ts b/catalog-ui/typings/cytoscape/cytoscape-extension.ts new file mode 100644 index 0000000000..88843af088 --- /dev/null +++ b/catalog-ui/typings/cytoscape/cytoscape-extension.ts @@ -0,0 +1,40 @@ +/** + * Created by obarda on 12/21/2016. + */ +declare module Cy { + + interface Instance { + + expandCollapse(options?: ExpandCollapseOptions); + collapseAll(options?: ExpandCollapseOptions); + } + + + + interface CollectionNodes { + + qtip(tooltipOptions: TooltipOption); + } + + + interface TooltipOption { + content?: string | Function; + position?: any; + style?: any; + show?:any; + hide?:any; + includeLabels?: boolean; + } + + interface ExpandCollapseOptions { + layoutBy:any; + fisheye: boolean; + undoable: boolean; + expandCueImage: string; + collapseCueImage: string; + expandCollapseCueSize: number; + expandCollapseCueSensitivity: number; + cueOffset: number; + // expandCollapseCuePosition: string; + } +}
\ No newline at end of file diff --git a/catalog-ui/typings/cytoscape/cytoscape.d.ts b/catalog-ui/typings/cytoscape/cytoscape.d.ts new file mode 100644 index 0000000000..e10b6273ae --- /dev/null +++ b/catalog-ui/typings/cytoscape/cytoscape.d.ts @@ -0,0 +1,3095 @@ +// Type definitions for Cytoscape.js 2.4.2 +// Project: http://js.cytoscape.org/ +// Definitions by: Fabian Schmidt +// +// Translation from Objects in help to Typescript interface. +// cy --> Cy.Instance +// the core +// ele --> Cy.CollectionFirst +// a collection of a single element (node or edge) +// eles --> Cy.Collection +// a collection of one or more elements (nodes and edges) +// node --> Cy.CollectionFirstNode +// a collection of a single node +// nodes -> Cy.CollectionNodes +// a collection of one or more nodes +// edge --> Cy.CollectionFirstEdge +// a collection of a single edge +// edges -> Cy.CollectionEdges +// a collection of one or more edges +// +// The library makes a diferrence between input and output parameter due to the dynamic behaviour of the Cytoscape library. +// For a input parameter it will always expect: +// - Cy.Collection +// The input can be any element (node and edge) collection. +// - Cy.CollectionNodes +// The input must be a node collection. +// - Cy.CollectionEdges +// The input must be a edge collection. +// - Cy.CollectionFirst +// The input must be a single element. +// - Cy.CollectionFirstNode +// The inut must be a single node. +// - Cy.CollectionFirstEdge +// The input must be a single edge. +// +// For a output of a function it will always give: +// - Cy.CollectionElements +// The output is a collection of node and edge elements OR single element. +// - Cy.CollectionEdges +// The output is a collection of edge elements OR single edge. +// - Cy.CollectionNodes +// The output is a collection of node elements OR single node. + +declare module Cy { + /** + * See http://js.cytoscape.org/#selectors for details about writing selectors. + */ + import ClipExtent = d3.geo.ClipExtent; + type Selector = string; + + /** + * Possbile values are 'additive' or 'single'. + */ + type SelectionType = string; + + /** + * Possible values are 'nodes' or 'edges'. + */ + type ElementGroup = string; + + /** + * Possible values are 'x' or 'y'. + */ + type PositionDimension = string; + + /** + * Usually temp or nonserialisable data can be stored. + */ + type Scratchpad = any; + + interface CollectionElements extends CollectionEdges, CollectionNodes, CollectionFirstElement { + //Intentionally empty. + } + + interface Extent { + x1: number, y1: number, x2: number, y2: number, w: number, h: number + } + + interface CollectionEdges extends Collection, CollectionFirstEdge, + CollectionEdgesTraversing { + } + + interface CollectionNodes extends Collection, CollectionFirstNode, + CollectionNodesMetadata, CollectionNodesPosition, CollectionNodesTraversing, CollectionNodesCompound { + } + + interface Collection extends CollectionFirst, + CollectionManipulation, CollectionEvents, CollectionData, CollectionPosition, CollectionLayout, CollectionSelection, CollectionStyle, CollectionAnimation, CollectionComparision, CollectionIteration, CollectionBuildingUnion, CollectionAlgorithms, CollectionTraversing { + } + + interface CollectionFirstElement extends CollectionFirstEdge, CollectionFirstNode { + //Intentionally empty. + } + + interface CollectionFirstEdge extends CollectionFirst, + CollectionFirstEdgeData, CollectionFirstEdgeTraversing { + } + + interface CollectionFirstNode extends CollectionFirst, + CollectionFirstNodeMetadata, CollectionFirstNodePosition, CollectionFirstNodeCompound { + } + + interface CollectionFirst extends CollectionFirstManipulation, CollectionFirstData, CollectionFirstPosition, CollectionFirstSelection, CollectionFirstStyle, CollectionFirtsAnimation { + } + + interface CollectionManipulation { + /** + * Remove the elements from the graph. + */ + remove(): CollectionElements; + + /** + * Put removed elements back into the graph. + */ + restore(): CollectionElements; + + /** + * Get a new collection containing clones (i.e. copies) of the elements in the calling collection. + */ + clone(): CollectionElements; + /** + * Get a new collection containing clones (i.e. copies) of the elements in the calling collection. + */ + copy(): CollectionElements; + + /** + * Effectively move edges to different nodes. The modified (actually new) elements are returned. + */ + move(location: { source?: string, target?: string }): CollectionEdges; + /** + * Effectively move nodes to different parent node. The modified (actually new) elements are returned. + */ + move(location: { parent: string }): CollectionNodes; + } + + interface CollectionEvents { + //TODO: http://js.cytoscape.org/#collection/events + //TODO: http://js.cytoscape.org/#collection/events + + // on(event:string, callback: () => void); + + on(events: string, any); + } + + interface CollectionData { + //http://js.cytoscape.org/#collection/data + + // The following fields are immutable: + //id: The id field is used to uniquely identify an element in the graph. + //source & target : These fields define an edge's relationship to nodes, and this relationship can not be changed after creation. + //parent: The parent field defines the parent (compound) node. + + /** + * Remove developer-defined data associated with the elements. + */ + removeData(): CollectionElements; + /** + * Remove developer-defined data associated with the elements. + * + * @param names A space-separated list of fields to delete. + */ + removeData(names: string): CollectionElements; + /** + * Remove developer-defined data associated with the elements. + */ + removeAttr(): CollectionElements; + /** + * Remove developer-defined data associated with the elements. + * + * @param names A space-separated list of fields to delete. + */ + removeAttr(names: string): CollectionElements; + + /** + * Get an array of the plain JavaScript object representation of all elements in the collection. + */ + jsons(): string[]; + } + interface CollectionNodesMetadata { + //http://js.cytoscape.org/#collection/metadata + + /** + * Get the maximum degree of the nodes in the collection. + * + * For a node, the degree is the number of edge connections it has. Each time a node is referenced as source or target of an edge in the graph, that counts as an edge connection. + * + * For a set of nodes, the the total degree is the total number of edge connections to nodes in the set. + * + * @param includeLoops A boolean, indicating whether loops are to be included in degree calculations. + */ + maxDegree(includeLoops: boolean): number; + /** + * Get the minimum indegree of the nodes in the collection. + * + * For a node, the indegree is the number of incoming edge connections it has. Each time a node is referred to as target of an edge in the graph, that counts as an incoming edge connection. + * + * For a set of nodes, the the total degree is the total number of edge connections to nodes in the set. + * + * @param includeLoops A boolean, indicating whether loops are to be included in degree calculations. + */ + minIndegree(includeLoops: boolean): number; + /** + * Get the maximum indegree of the nodes in the collection. + * + * For a node, the indegree is the number of incoming edge connections it has. Each time a node is referred to as target of an edge in the graph, that counts as an incoming edge connection. + * + * For a set of nodes, the the total degree is the total number of edge connections to nodes in the set. + * + * @param includeLoops A boolean, indicating whether loops are to be included in degree calculations. + */ + maxIndegree(includeLoops: boolean): number; + /** + * Get the minimum outdegree of the nodes in the collection. + * + * For a node, the outdegree is the number of outgoing edge connections it has. Each time a node is referred to as source of an edge in the graph, that counts as an outgoing edge connection. + * + * For a set of nodes, the the total degree is the total number of edge connections to nodes in the set. + * + * @param includeLoops A boolean, indicating whether loops are to be included in degree calculations. + */ + minOutdegree(includeLoops: boolean): number; + /** + * Get the maximum outdegree of the nodes in the collection. + * + * For a node, the outdegree is the number of outgoing edge connections it has. Each time a node is referred to as source of an edge in the graph, that counts as an outgoing edge connection. + * + * For a set of nodes, the the total degree is the total number of edge connections to nodes in the set. + * + * @param includeLoops A boolean, indicating whether loops are to be included in degree calculations. + */ + maxOutdegree(includeLoops: boolean): number; + } + + interface BoundingBox { + x1: number; + x2: number; + y1: number; + y2: number; + w: number; + h: number; + } + interface CollectionPosition { + //http://js.cytoscape.org/#collection/position--dimensions + + /** + * Get the bounding box of the elements in model coordinates. + * + * @param options An object containing options for the function. + */ + boundingBox(options: BoundingBoxOptions): BoundingBox; + /** + * Get the bounding box of the elements in model coordinates. + * + * @param options An object containing options for the function. + */ + boundingbox(options?: BoundingBoxOptions): BoundingBox; + + /** + * Get the bounding box of the elements in rendered coordinates. + * + * @param options An object containing options for the function. + */ + renderedBoundingBox(options?: BoundingBoxOptions): BoundingBox; + /** + * Get the bounding box of the elements in rendered coordinates. + * + * @param options An object containing options for the function. + */ + renderedBoundingbox(options?: BoundingBoxOptions): BoundingBox; + } + interface CollectionNodesPosition { + //http://js.cytoscape.org/#collection/position--dimensions + + /** + * Set the positions functionally. + * + * @param callback A callback function that returns the position to set for each element. + * i - The index of the element when iterating over the elements in the collection. + * ele - The element being iterated over for which the function should return a position to set. + */ + positions(callback: (i: number, ele: CollectionNodes) => Position): CollectionNodes; + /** + * Set positions for all nodes based on a single position object. + * + * @param pos An object specifying name-value pairs representing dimensions to set. + */ + positions(pos: Position): CollectionNodes; + + /** + * Set the positions functionally. + * + * @param callback A callback function that returns the position to set for each element. + * i - The index of the element when iterating over the elements in the collection. + * ele - The element being iterated over for which the function should return a position to set. + */ + modelPositions(callback: (i: number, ele: CollectionNodes) => Position): CollectionNodes; + /** + * Set positions for all nodes based on a single position object. + * + * @param pos An object specifying name-value pairs representing dimensions to set. + */ + modelPositions(pos: Position): CollectionNodes; + + /** + * Set the positions functionally. + * + * @param callback A callback function that returns the position to set for each element. + * i - The index of the element when iterating over the elements in the collection. + * ele - The element being iterated over for which the function should return a position to set. + */ + points(callback: (i: number, ele: CollectionNodes) => Position): CollectionNodes; + /** + * Set positions for all nodes based on a single position object. + * + * @param pos An object specifying name-value pairs representing dimensions to set. + */ + points(pos: Position): CollectionNodes; + + /** + * Allow the user to grab the nodes. + */ + grabify(): CollectionNodes; + + /** + * Disallow the user to grab the nodes. + */ + ungrabify(): CollectionNodes; + + /** + * Lock the nodes such that their positions can not be changed. + */ + lock(): CollectionNodes; + /** + * Unlock the nodes such that their positions can be changed. + */ + unlock(): CollectionNodes; + } + interface CollectionLayout { + // http://js.cytoscape.org/#collection/layout + + /** + * Run a layout on the elements in the calling collection, algorithmically positioning the nodes. + * This function is useful for running a layout on a subset of the elements in the graph. + * + * @param options The layout options. + */ + layout(options: LayoutOptions): CollectionElements; + + /** + * Get a new layout, which can be used to algorithmically position the nodes in the collection. + * This function is useful for running a layout on a subset of the elements in the graph, perhaps in parallel to other layouts. + * + * You must specify options.name with the name of the layout you wish to use. + * + * Note: that you must call layout.run() in order for it to affect the graph. + * + * @param options The layout options. + */ + makeLayout(options: LayoutOptions): LayoutInstance; + /** + * Get a new layout, which can be used to algorithmically position the nodes in the collection. + * This function is useful for running a layout on a subset of the elements in the graph, perhaps in parallel to other layouts. + * + * You must specify options.name with the name of the layout you wish to use. + * + * Note: that you must call layout.run() in order for it to affect the graph. + * + * @param options The layout options. + */ + createLayout(options: LayoutOptions): LayoutInstance; + } + interface CollectionSelection { + // http://js.cytoscape.org/#collection/selection + + /** + * Make the elements selected (NB other elements outside the collection are not affected). + */ + select(): CollectionElements; + + /** + * Make the elements not selected (NB other elements outside the collection are not affected). + */ + unselect(): CollectionElements; + /** + * Make the elements not selected (NB other elements outside the collection are not affected). + */ + deselect(): CollectionElements; + + /** + * Make the selection states of the elements mutable. + */ + selectify(): CollectionElements; + + /** + * Make the selection states of the elements immutable. + */ + unselectify(): CollectionElements; + } + interface CollectionStyle { + // http://js.cytoscape.org/#collection/style + + /** + * Add classes to elements. + * + * @param classes A space-separated list of class names to add to the elements. + */ + addClass(classes: string): CollectionElements; + + /** + * Remove classes from elements. + * + * @param classes A space-separated list of class names to remove from the elements. + */ + removeClass(classes: string): CollectionElements; + + /** + * Toggle whether the elements have the specified classes. + * + * @param classes A space-separated list of class names to toggle on the elements. + * @param toggle [optional] Instead of automatically toggling, adds the classes on truthy values or removes them on falsey values. + */ + toggleClass(classes: string, toggle?: boolean): CollectionElements; + + /** + * Add classes to the elements, and then remove the classes after a specified duration. + * + * @param classes A space-separated list of class names to flash on the elements. + * @param duration [optional] The duration in milliseconds that the classes should be added on the elements. After the duration, the classes are removed. + */ + flashClass(classes: string, duration?: number): CollectionElements; + + + /** + * Get a name-value pair object containing visual style properties and their values for the element. + */ + style(): Css.ElementCss; + /** + * Get a particular style property value. + * + * @param name The name of the visual style property to get. + */ + style(name: string): Css.ElementCss; + + /** + * Get a name-value pair object containing visual style properties and their values for the element. + */ + css(): Css.ElementCss; + /** + * Get a particular style property value. + * + * @param name The name of the visual style property to get. + */ + css(name: string): Css.ElementCss; + + /** + * Get a name-value pair object containing visual style properties and their values for the element. + */ + bypass(): Css.ElementCss; + /** + * Get a particular style property value. + * + * @param name The name of the visual style property to get. + */ + bypass(name: string): Css.ElementCss; + + + /** + * Set the specified visual style property for the elements. + * + * You should use this function very sparingly, because it overrides the style of an element, despite the state and classes that it has. In general, it's much better to specify a better stylesheet at initialisation that reflects your application state rather than programmatically modifying style. + * + * If you would like to remove a particular overridden style property, set null to it. + * + * @param name The name of the property to set. + * @param value The value to set to the visual style property. + */ + style(name: string, value: string): CollectionElements; + /** + * Set several visual style properties at once for the elements. + * + * You should use this function very sparingly, because it overrides the style of an element, despite the state and classes that it has. In general, it's much better to specify a better stylesheet at initialisation that reflects your application state rather than programmatically modifying style. + * + * If you would like to remove a particular overridden style property, set null to it. + * + * @param props An object with name-value pairs representing properties to set on the elements. + */ + style(props: Css.ElementCss): CollectionElements; + + /** + * Set the specified visual style property for the elements. + * + * You should use this function very sparingly, because it overrides the style of an element, despite the state and classes that it has. In general, it's much better to specify a better stylesheet at initialisation that reflects your application state rather than programmatically modifying style. + * + * If you would like to remove a particular overridden style property, set null to it. + * + * @param name The name of the property to set. + * @param value The value to set to the visual style property. + */ + css(name: string, value: string): CollectionElements; + /** + * Set several visual style properties at once for the elements. + * + * You should use this function very sparingly, because it overrides the style of an element, despite the state and classes that it has. In general, it's much better to specify a better stylesheet at initialisation that reflects your application state rather than programmatically modifying style. + * + * If you would like to remove a particular overridden style property, set null to it. + * + * @param props An object with name-value pairs representing properties to set on the elements. + */ + css(props: Css.ElementCss): CollectionElements; + + /** + * Set the specified visual style property for the elements. + * + * You should use this function very sparingly, because it overrides the style of an element, despite the state and classes that it has. In general, it's much better to specify a better stylesheet at initialisation that reflects your application state rather than programmatically modifying style. + * + * If you would like to remove a particular overridden style property, set null to it. + * + * @param name The name of the property to set. + * @param value The value to set to the visual style property. + */ + bypass(name: string, value: string): CollectionElements; + /** + * Set several visual style properties at once for the elements. + * + * You should use this function very sparingly, because it overrides the style of an element, despite the state and classes that it has. In general, it's much better to specify a better stylesheet at initialisation that reflects your application state rather than programmatically modifying style. + * + * If you would like to remove a particular overridden style property, set null to it. + * + * @param props An object with name-value pairs representing properties to set on the elements. + */ + bypass(props: Css.ElementCss): CollectionElements; + + /** + * Removes all overridden style of the elements. + */ + removeStyle(): CollectionElements; + /** + * Removes particular overridden style properties of the elements. + * + * @param names A space-separated list of property names for which overridden styles will be removed. + */ + removeStyle(names: string): CollectionElements; + /** + * Removes all overridden style of the elements. + */ + removeCss(): CollectionElements; + /** + * Removes particular overridden style properties of the elements. + * + * @param names A space-separated list of property names for which overridden styles will be removed. + */ + removeCss(names: string): CollectionElements; + /** + * Removes all overridden style of the elements. + */ + removeBypass(): CollectionElements; + /** + * Removes particular overridden style properties of the elements. + * + * @param names A space-separated list of property names for which overridden styles will be removed. + */ + removeBypass(names: string): CollectionElements; + } + interface CollectionAnimation { + // http://js.cytoscape.org/#collection/animation + + /** + * Animate the elements. + * + * Note that you can specify only one of position and renderedPosition: You can not animate to two positions at once. + * + * @param anis An object containing the details of the animation. + * position - A position to which the elements will be animated. + * renderedPosition - A rendered position to which the elements will be animated. + * style - An object containing name-value pairs of style properties to animate. + * @param options An object containing animation options. + * duration - The duration of the animation in milliseconds. + * queue - A boolean indicating whether to queue the animation. + * complete - A function to call when the animation is done. + * step - A function to call each time the animation steps. + */ + animate(anis: { + postion?: Position, + renderedPosition?: Position, + style?: Css.ElementCss + }, options?: { + duration?: number, + queue?: boolean, + complete?: () => void, + step?: () => void + }): CollectionElements; + + /** + * Add a delay between animations for the elements. + * + * @param duration How long the delay should be in milliseconds. + * @param complete A function to call when the delay is complete. + */ + delay(duration: number, complete?: () => void): CollectionElements; + + /** + * Stop all animations that are currently running. + * + * @param clearQueue A boolean, indicating whether the queue of animations should be emptied. + * @param jumpToEnd A boolean, indicating whether the currently-running animations should jump to their ends rather than just stopping midway. + */ + stop(clearQueue?: boolean, jumpToEnd?: boolean): CollectionElements; + + /** + * Remove all queued animations for the elements. + */ + clearQueue(): CollectionElements; + } + interface CollectionComparision { + // http://js.cytoscape.org/#collection/comparison + + /** + * Determine whether this collection contains exactly the same elements as another collection. + * + * @param eles The other elements to compare to. + */ + same(eles: Collection): boolean; + + /** + * Determine whether this collection contains any of the same elements as another collection. + * + * @param eles The other elements to compare to. + */ + anySame(eles: Collection): boolean; + + /** + * Determine whether all elements in the specified collection are in the neighbourhood of the calling collection. + * + * @param eles The other elements to compare to. + */ + allAreNeighbors(eles: Collection): boolean; + /** + * Determine whether all elements in the specified collection are in the neighbourhood of the calling collection. + * + * @param eles The other elements to compare to. + */ + allAreNeighbours(eles: Collection): boolean; + + /** + * Determine whether any element in this collection matches a selector. + * + * @param selector The selector to match against. + */ + is(selector: Selector): boolean; + + /** + * Determine whether all elements in the collection match a selector. + * @param selector The selector to match against. + */ + allAre(selector: Selector): boolean; + + /** + * Determine whether any element in this collection satisfies the specified test function. + * + * @param test The test function that returns truthy values for elements that satisfy the test and falsey values for elements that do not satisfy the test. + * ele - The current element. + * i - The index of the current element. + * eles - The collection of elements being tested. + * @param thisArg [optional] The value for this within the test function. + */ + some(test: (ele: CollectionElements, i: number, eles: CollectionElements) => boolean, thisArg?: any): boolean; + + /** + * Determine whether all elements in this collection satisfy the specified test function. + * + * @param test The test function that returns truthy values for elements that satisfy the test and falsey values for elements that do not satisfy the test. + * ele - The current element. + * i - The index of the current element. + * eles - The collection of elements being tested. + * @param thisArg [optional] The value for this within the test function. + */ + every(test: (ele: CollectionElements, i: number, eles: CollectionElements) => boolean, thisArg?: any): boolean; + } + interface CollectionIteration { + // http://js.cytoscape.org/#collection/iteration + + /** + * Get the number of elements in the collection. + */ + size(): number; + /** + * Get the number of elements in the collection. + */ + length: number; + + /** + * Get whether the collection is empty, meaning it has no elements. + */ + empty(): boolean; + /** + * Get whether the collection is nonempty, meaning it has elements. + */ + nonempty(): boolean; + + /** + * Iterate over the elements in the collection. + * + * Note that although this function is convenient in some cases, it is less efficient than making your own loop. + * + * @param each The function executed each iteration. + * i - The index of the element in the collection. + * ele - The element at the current index. + */ + each(each: (i: number, ele: CollectionElements) => void); + + /** + * Iterate over the elements in the collection using an implementation like the native array function namesake. + * + * This function behaves like Array.prototype.forEach() with minor changes for convenience: + * You can exit the iteration early by returning false in the iterating function. The Array.prototype.forEach() implementation does not support this, but it is included anyway on account of its utility. + * + * @param each The function executed each iteration. + * ele - The current element. + * i - The index of the current element. + * eles - The collection of elements being iterated. + * @param thisArg [optional] The value for this within the iterating function. + */ + forEach(each: (ele: CollectionElements, i: number, eles: CollectionElements) => void|boolean, thisArg?: any); + + /** + * Get an element at a particular index in the collection. + * + * You may use eles[i] in place of eles.eq(i) as a more performant alternative. + * + * @param index The index of the element to get. + */ + eq(index: number): CollectionElements; + /** + * Get an element at a particular index in the collection. + * + * @param index The index of the element to get. + */ + [index: number]: CollectionElements; + /** + * Get the first element in the collection. + */ + first(): CollectionElements; + /** + * Get the last element in the collection. + */ + last(): CollectionElements; + + /** + * Get a subset of the elements in the collection based on specified indices. + * + * @param start [optional] An integer that specifies where to start the selection. The first element has an index of 0. Use negative numbers to select from the end of an array. + * @param end [optional] An integer that specifies where to end the selection. If omitted, all elements from the start position and to the end of the array will be selected. Use negative numbers to select from the end of an array. + */ + slice(start?: number, end?: number): CollectionElements; + } + interface CollectionBuildingUnion { + /** + * Get a new collection, resulting from adding the collection with another one + * + * @param eles The elements to add. + */ + (eles: Collection): CollectionElements; + /** + * Get a new collection, resulting from adding the collection with another one + * + * @param elesArray An array of elements to add. + */ + (elesArray: Collection[]): CollectionElements; + /** + * Get a new collection, resulting from adding the collection with another one + * + * @param selector Elements in the graph matching this selector are added. + */ + (selector: Selector): CollectionElements; + } + interface CollectionBuildingDifference { + /** + * Get a new collection, resulting from the collection without some specified elements. + * + * @param eles The elements that will not be in the resultant collection. + */ + (eles: Collection): CollectionElements; + /** + * Get a new collection, resulting from the collection without some specified elements. + * + * @param selector Elements from the calling collection matching this selector will not be in the resultant collection. + */ + (selector: Selector): CollectionElements; + } + interface CollectionBuildingIntersection { + /** + * Get the elements in both this collection and another specified collection. + * + * @param eles The elements to intersect with. + */ + (eles: Collection): CollectionElements; + /** + * Get the elements in both this collection and another specified collection. + * + * @param selector A selector representing the elements to intersect with. All elements in the graph matching the selector are used as the passed collection. + */ + (selector: Selector): CollectionElements; + } + interface CollectionSymmetricDifference { + /** + * Get the elements that are in the calling collection or the passed collection but not in both. + * + * @param eles The elements to apply the symmetric difference with. + */ + (eles: Collection): CollectionElements; + /** + * Get the elements that are in the calling collection or the passed collection but not in both. + * + * @param selector A selector representing the elements to apply the symmetric difference with. All elements in the graph matching the selector are used as the passed collection. + */ + (selector: Selector): CollectionElements; + } + interface CollectionBuildingUnion { + // http://js.cytoscape.org/#collection/building--filtering + + union: CollectionBuildingUnion; + //[index: "u"]: CollectionBuildingUnion; + add: CollectionBuildingUnion; + //[index: "+"]: CollectionBuildingUnion; + or: CollectionBuildingUnion; + //[index: "|"]: CollectionBuildingUnion; + + difference: CollectionBuildingDifference; + //[index: "\\"]: CollectionBuildingDifference; + not: CollectionBuildingDifference; + //[index: "!"]: CollectionBuildingDifference; + relativeComplement(): CollectionBuildingDifference; + //[index: "-"]: CollectionBuildingDifference; + + /** + * Get all elements in the graph that are not in the calling collection. + */ + absoluteComplement(): CollectionElements; + /** + * Get all elements in the graph that are not in the calling collection. + */ + abscomp(): CollectionElements; + /** + * Get all elements in the graph that are not in the calling collection. + */ + complement(): CollectionElements; + + intersection: CollectionBuildingIntersection; + intersect: CollectionBuildingIntersection; + and: CollectionBuildingIntersection; + //[index: "n"]: CollectionBuildingIntersection; + //[index: "&"]: CollectionBuildingIntersection; + //[index: "."]: CollectionBuildingIntersection; + + symmetricDifference: CollectionSymmetricDifference; + symdiff: CollectionSymmetricDifference; + xor: CollectionSymmetricDifference; + //[index: "^"]: CollectionSymmetricDifference; + //[index: "(+)"]: CollectionSymmetricDifference; + //[index: "(-)"]: CollectionSymmetricDifference; + + //[index: string]: CollectionBuildingDifference |CollectionBuildingUnion | CollectionBuildingIntersection | CollectionSymmetricDifference; + + /** + * Perform a traditional left/right diff on the two collections. + * + * @param eles The elements on the right side of the diff. + */ + diff(eles: Collection): CollectionElements; + /** + * Perform a traditional left/right diff on the two collections. + * + * @param selector A selector representing the elements on the right side of the diff. All elements in the graph matching the selector are used as the passed collection. + * @return This function returns a plain object of the form { left, right, both } where + * left - is the set of elements only in the calling (i.e. left) collection, + * right - is the set of elements only in the passed (i.e. right) collection, and + * both - is the set of elements in both collections. + */ + diff(selector: Selector): { + left: CollectionElements, + right: CollectionElements, + both: CollectionElements + }; + + /** + * Get a new collection containing elements that are accepted by the specified filter. + * + * @param selector The selector to match against. + */ + filter(selector: Selector): CollectionElements; + /** + * Get a new collection containing elements that are accepted by the specified filter. + * + * @filter selector The filter function that returns true for elements to include. + * i - The index of the current element being considered. + * ele - The element being considered. + */ + filter(filter: (i: number, ele: CollectionElements) => boolean): CollectionElements; + /** + * Get the nodes that match the specified selector. + * + * @param selector The selector to match against. + */ + nodes(selector: Selector): CollectionNodes; + /** + * Get the edges that match the specified selector. + * + * @param selector The selector to match against. + */ + edges(selector: Selector): CollectionEdges; + + /** + * Get a new collection containing elements that are accepted by the specified filter, using an implementation like the standard array namesake. + * + * @param filter The filter function that returns truthy values for elements to include and falsey values for elements to exclude. + * ele - The current element. + * i - The index of the current element. + * eles - The collection of elements being filtered. + * @param thisArg [optional] The value for this within the iterating function. + */ + filterFn(filter: (ele: CollectionElements, i: number, eles: CollectionElements) => boolean, thisArg?: any): CollectionElements; + /** + * Get a new collection containing elements that are accepted by the specified filter, using an implementation like the standard array namesake. + * + * @param filter The filter function that returns truthy values for elements to include and falsey values for elements to exclude. + * ele - The current element. + * i - The index of the current element. + * eles - The collection of elements being filtered. + * @param thisArg [optional] The value for this within the iterating function. + */ + fnFilter(filter: (ele: CollectionElements, i: number, eles: CollectionElements) => boolean, thisArg?: any): CollectionElements; + /** + * Get a new collection containing elements that are accepted by the specified filter, using an implementation like the standard array namesake. + * + * @param filter The filter function that returns truthy values for elements to include and falsey values for elements to exclude. + * ele - The current element. + * i - The index of the current element. + * eles - The collection of elements being filtered. + * @param thisArg [optional] The value for this within the iterating function. + */ + stdFilter(filter: (ele: CollectionElements, i: number, eles: CollectionElements) => boolean, thisArg?: any): CollectionElements; + + /** + * Get a new collection containing the elements sorted by the specified comparison function. + * + * @param sort The sorting comparison function that returns a negative number for ele1 before ele2, 0 for ele1 same as ele2, or a positive number for ele1 after ele2. + */ + sort(sort: (ele1: CollectionElements, ele2: CollectionElements) => number): CollectionElements; + + /** + * Get an array containing values mapped from the collection. + * + * @param fn The function that returns the mapped value for each element. + * ele - The current element. + * i - The index of the current element. + * eles - The collection of elements being mapped. + * @param thisArg [optional] The value for this within the iterating function. + */ + map(fn: (ele: CollectionElements, i: number, eles: CollectionElements) => any, thisArg?: any): any[]; + + /** + * Find a minimum value in a collection. + * + * @param fn The function that returns the value to compare for each element. + * ele - The current element. + * i - The index of the current element. + * eles - The collection of elements being mapped. + * @param thisArg [optional] The value for this within the iterating function. + */ + min(fn: (ele: CollectionElements, i: number, eles: CollectionElements) => any, thisArg?: any): { + /** + * The minimum value found. + */ + value: any, + /** + * The element that corresponds to the minimum value. + */ + ele: CollectionElements + }; + + /** + * Find a maximum value and the corresponding element. + * + * @param fn The function that returns the value to compare for each element. + * ele - The current element. + * i - The index of the current element. + * eles - The collection of elements being mapped. + * @param thisArg [optional] The value for this within the iterating function. + */ + max(fn: (ele: CollectionElements, i: number, eles: CollectionElements) => any, thisArg?: any): { + /** + * The maximum value found. + */ + value: any, + /** + * The element that corresponds to the maximum value. + */ + ele: CollectionElements + }; + } + interface CollectionTraversing { + // http://js.cytoscape.org/#collection/traversing + + /** + * Get the open neighbourhood of the elements. + * + * The neighbourhood returned by this function is a bit different than the traditional definition of a "neighbourhood": This returned neighbourhood includes the edges connecting the collection to the neighbourhood. This gives you more flexibility. + * An open neighbourhood is one that does not include the original set of elements. If unspecified, a neighbourhood is open by default. + * + * @param selector [optional] An optional selector that is used to filter the resultant collection. + */ + neighborhood(selector?: Selector): CollectionElements; + /** + * Get the open neighbourhood of the elements. + * + * The neighbourhood returned by this function is a bit different than the traditional definition of a "neighbourhood": This returned neighbourhood includes the edges connecting the collection to the neighbourhood. This gives you more flexibility. + * An open neighbourhood is one that does not include the original set of elements. If unspecified, a neighbourhood is open by default. + * + * @param selector [optional] An optional selector that is used to filter the resultant collection. + */ + openNeighborhood(selector?: Selector): CollectionElements; + /** + * Get the closed neighbourhood of the elements. + * + * The neighbourhood returned by this function is a bit different than the traditional definition of a "neighbourhood": This returned neighbourhood includes the edges connecting the collection to the neighbourhood. This gives you more flexibility. + * A closed neighbourhood is one that does include the original set of elements. + * + * @param selector [optional] An optional selector that is used to filter the resultant collection. + */ + closedNeighborhood(selector?: Selector): CollectionElements; + } + interface CollectionEdgesTraversing { + // http://js.cytoscape.org/#collection/traversing + + /** + * Get the nodes connected to the edges in the collection + * + * @param selector [optional] An optional selector that is used to filter the resultant collection. + */ + connectedNodes(selector?: Selector): CollectionNodes; + + /** + * Get source nodes connected to the edges in the collection. + * + * @param selector [optional] An optional selector that is used to filter the resultant collection. + */ + sources(selector?: Selector): CollectionNodes; + + /** + * Get target nodes connected to the edges in the collection. + * + * @param selector [optional] An optional selector that is used to filter the resultant collection. + */ + targets(selector?: Selector): CollectionNodes; + + /** + * Get edges parallel to those in the collection. + * + * Two edges are said to be parallel if they connect the same two nodes. Any two parallel edges may connect nodes in the same direction, in which case the edges share the same source and target. They may alternatively connect nodes in the opposite direction, in which case the source and target are reversed in the second edge. + * That is: + * - edge1.source().id() === edge2.source().id() + * && edge1.target().id() === edge2.target().id() + * OR + * - edge1.source().id() === edge2.target().id() + * && edge1.target().id() === edge2.source().id() + * + * @param selector [optional] An optional selector that is used to filter the resultant collection. + */ + parallelEdges(selector?: Selector): CollectionEdges; + + /** + * Get edges codirected to those in the collection. + * + * Two edges are said to be codirected if they connect the same two nodes in the same direction: The edges have the same source and target. + * That is: + * - edge1.source().id() === edge2.source().id() + * && edge1.target().id() === edge2.target().id() + + * @param selector [optional] An optional selector that is used to filter the resultant collection. + */ + codirectedEdges(selector?: Selector): CollectionEdges; + } + interface CollectionNodesTraversing { + // http://js.cytoscape.org/#collection/traversing + + /** + * Get the edges connecting the collection to another collection. Direction of the edges does not matter. + * + * @param eles The other collection. + */ + edgesWith(eles: Collection): CollectionEdges; + /** + * Get the edges connecting the collection to another collection. Direction of the edges does not matter. + * + * @param selector The other collection, specified as a selector which is matched against all elements in the graph. + */ + edgesWith(selector: Selector): CollectionEdges; + + /** + * Get the edges coming from the collection (i.e. the source) going to another collection (i.e. the target). + * + * @param eles The other collection. + */ + edgesTo(eles: Collection): CollectionEdges; + /** + * Get the edges coming from the collection (i.e. the source) going to another collection (i.e. the target). + * + * @param selector The other collection, specified as a selector which is matched against all elements in the graph. + */ + edgesTo(selector: Selector): CollectionEdges; + + /** + * Get the edges connected to the nodes in the collection. + * + * @param selector [optional] An optional selector that is used to filter the resultant collection. + */ + connectedEdges(selector?: Selector): CollectionEdges; + + /** + * From the set of calling nodes, get the nodes which are leaves (i.e. no outgoing edges, as in a directed acyclic graph). + * + * @param selector [optional] An optional selector that is used to filter the resultant collection. + */ + leaves(selector?: Selector): CollectionNodes; + + /** + * Get edges (and their targets) coming out of the nodes in the collection. + * + * @param selector [optional] An optional selector that is used to filter the resultant collection. + */ + outgoers(selector?: Selector): CollectionEdges; + + /** + * Recursively get edges (and their targets) coming out of the nodes in the collection (i.e. the outgoers, the outgoers' outgoers, ...). + * + * @param selector [optional] An optional selector that is used to filter the resultant collection. + */ + successors(selector?: Selector): CollectionEdges; + + /** + * Get edges (and their sources) coming into the nodes in the collection. + * + * @param selector [optional] An optional selector that is used to filter the resultant collection. + */ + incomers(selector?: Selector): CollectionEdges; + + /** + * Recursively get edges (and their sources) coming into the nodes in the collection (i.e. the incomers, the incomers' incomers, ...). + * + * @param selector [optional] An optional selector that is used to filter the resultant collection. + */ + predecessors(selector?: Selector): CollectionEdges; + } + interface SearchBreadthFirstOptions { + /** + * The root nodes (selector or collection) to start the search from. + */ + roots: Selector|Collection; + /** + * A handler function that is called when a node is visited in the search. The handler returns true when it finds the desired node, and it returns false to cancel the search. + * i - The index indicating this node is the ith visited node. + * depth - How many edge hops away this node is from the root nodes. + * v - The current node. + * e - The edge connecting the previous node to the current node. + * u - The previous node. + */ + visit?: (i: number, depth: number, v: CollectionNodes, e: CollectionEdges, u: CollectionNodes) => boolean; + /** + * A boolean indicating whether the algorithm should only go along edges from source to target (default false). + */ + directed?: boolean; + } + interface SearchBreadthFirstResult { + /** + * The path of the search. + * - The path returned includes edges such that if path[i] is a node, then path[i - 1] is the edge used to get to that node. + */ + path: CollectionElements; + /** + * The node found by the search + * - If no node was found, then found is empty. + * - If your handler function returns false, then the only the path up to that point is returned. + */ + found: CollectionNodes; + } + interface SearchDijkstraOptions { + /** + * The root node (selector or collection) where the algorithm starts. + */ + root: Selector|Collection; + + /** + * A function that returns the positive numeric weight for this edge. + * + * If no weight function is defined, a constant weight of 1 is used for each edge. + */ + weight?: (edge: CollectionEdges) => number; + + /** + * A boolean indicating whether the algorithm should only go along edges from source to target (default false). + */ + directed?: boolean; + } + interface SearchDijkstraResult { + /** + * Returns the distance from the source node to node. + */ + distanceTo: (node: CollectionFirstNode) => number; + + /** + * Returns a collection containing the shortest path from the source node to node. + * The path starts with the source node and includes the edges between the nodes in the path such that if pathTo(node)[i] is an edge, then pathTo(node)[i-1] is the previous node in the path and pathTo(node)[i+1] is the next node in the path. + */ + pathTo: (node: CollectionFirstNode) => Collection; + } + interface SearchAStarOptions { + } + interface SearchAStarResult { + } + interface CollectionAlgorithms { + // http://js.cytoscape.org/#collection/algorithms + + /** + * Perform a breadth-first search within the elements in the collection. + * + * Note that this function performs a breadth-first search on only the subset of the graph in the calling collection. + */ + breadthFirstSearch(options: SearchBreadthFirstOptions): SearchBreadthFirstResult; + /** + * Perform a breadth-first search within the elements in the collection. + * + * Note that this function performs a breadth-first search on only the subset of the graph in the calling collection. + * + * @param roots The root nodes (selector or collection) to start the search from. + * @param visit [optional] A handler function that is called when a node is visited in the search. The handler returns true when it finds the desired node, and it returns false to cancel the search. + * i - The index indicating this node is the ith visited node. + * depth - How many edge hops away this node is from the root nodes. + * v - The current node. + * e - The edge connecting the previous node to the current node. + * u - The previous node. + * @param directed [optional] A boolean indicating whether the search should only go along edges from source to target (default false). + */ + breadthFirstSearch(roots: Selector|Collection, + visit?: (i: number, depth: number, v: CollectionNodes, e: CollectionEdges, u: CollectionNodes) => boolean, + directed?: boolean): SearchBreadthFirstResult; + /** + * Perform a breadth-first search within the elements in the collection. + * + * Note that this function performs a breadth-first search on only the subset of the graph in the calling collection. + */ + bfs(options: SearchBreadthFirstOptions): SearchBreadthFirstResult; + /** + * Perform a breadth-first search within the elements in the collection. + * + * Note that this function performs a breadth-first search on only the subset of the graph in the calling collection. + * + * @param roots The root nodes (selector or collection) to start the search from. + * @param visit [optional] A handler function that is called when a node is visited in the search. The handler returns true when it finds the desired node, and it returns false to cancel the search. + * i - The index indicating this node is the ith visited node. + * depth - How many edge hops away this node is from the root nodes. + * v - The current node. + * e - The edge connecting the previous node to the current node. + * u - The previous node. + * @param directed [optional] A boolean indicating whether the search should only go along edges from source to target (default false). + */ + bfs(roots: Selector|Collection, + visit?: (i: number, depth: number, v: CollectionNodes, e: CollectionEdges, u: CollectionNodes) => boolean, + directed?: boolean): SearchBreadthFirstResult; + + /** + * Perform a depth-first search within the elements in the collection. + * + * Note that this function performs a depth-first search on only the subset of the graph in the calling collection. + */ + depthFirstSearch(options: SearchBreadthFirstOptions): SearchBreadthFirstResult; + /** + * Perform a depth-first search within the elements in the collection. + * + * Note that this function performs a depth-first search on only the subset of the graph in the calling collection. + * + * @param roots The root nodes (selector or collection) to start the search from. + * @param visit [optional] A handler function that is called when a node is visited in the search. The handler returns true when it finds the desired node, and it returns false to cancel the search. + * i - The index indicating this node is the ith visited node. + * depth - How many edge hops away this node is from the root nodes. + * v - The current node. + * e - The edge connecting the previous node to the current node. + * u - The previous node. + * @param directed [optional] A boolean indicating whether the search should only go along edges from source to target (default false). + */ + depthFirstSearch(roots: Selector|Collection, + visit?: (i: number, depth: number, v: CollectionNodes, e: CollectionEdges, u: CollectionNodes) => boolean, + directed?: boolean): SearchBreadthFirstResult; + /** + * Perform a depth-first search within the elements in the collection. + * + * Note that this function performs a depth-first search on only the subset of the graph in the calling collection. + */ + dfs(options: SearchBreadthFirstOptions): SearchBreadthFirstResult; + /** + * Perform a depth-first search within the elements in the collection. + * + * Note that this function performs a depth-first search on only the subset of the graph in the calling collection. + * + * @param roots The root nodes (selector or collection) to start the search from. + * @param visit [optional] A handler function that is called when a node is visited in the search. The handler returns true when it finds the desired node, and it returns false to cancel the search. + * i - The index indicating this node is the ith visited node. + * depth - How many edge hops away this node is from the root nodes. + * v - The current node. + * e - The edge connecting the previous node to the current node. + * u - The previous node. + * @param directed [optional] A boolean indicating whether the search should only go along edges from source to target (default false). + */ + dfs(roots: Selector|Collection, + visit?: (i: number, depth: number, v: CollectionNodes, e: CollectionEdges, u: CollectionNodes) => boolean, + directed?: boolean): SearchBreadthFirstResult; + + /** + * Perform Dijkstra's algorithm on the elements in the collection. This finds the shortest paths to all other nodes in the collection from the root node. + * + * Note that this function performs Dijkstra's algorithm on only the subset of the graph in the calling collection. + */ + dijkstra(options: SearchDijkstraOptions): SearchDijkstraResult; + /** + * Perform Dijkstra's algorithm on the elements in the collection. This finds the shortest paths to all other nodes in the collection from the root node. + * + * Note that this function performs Dijkstra's algorithm on only the subset of the graph in the calling collection. + * + * @param root The root node (selector or collection) where the algorithm starts. + * @param weight [optional] A function that returns the positive numeric weight for this edge. + * If no weight function is defined, a constant weight of 1 is used for each edge. + * @param directed [optional] A boolean indicating whether the algorithm should only go along edges from source to target (default false). + */ + dijkstra(root: Selector|Collection, + weight?: (edge: CollectionEdges) => number, + directed?: boolean): SearchDijkstraResult; + + + //TODO: continue here: http://js.cytoscape.org/#collection/algorithms/eles.dijkstra + } + interface CollectionNodesCompound { + // http://js.cytoscape.org/#collection/compound-nodes + + /** + * Get the compound parent node of each node in the collection. + * + * @param selector [optional] A selector used to filter the resultant collection. + */ + parent(selector?: Selector): CollectionNodes; + + /** + * Get all compound ancestor nodes (i.e. parents, parents' parents, etc.) of each node in the collection. + * + * @param selector [optional] A selector used to filter the resultant collection. + */ + parents(selector?: Selector): CollectionNodes; + /** + * Get all compound ancestor nodes (i.e. parents, parents' parents, etc.) of each node in the collection. + * + * @param selector [optional] A selector used to filter the resultant collection. + */ + ancestors(selector?: Selector): CollectionNodes; + + /** + * Get all compound ancestors common to all the nodes in the collection, starting with the closest and getting progressively farther. + * + * You can get the closest common ancestor via + * nodes.commonAncestors().first() + * and the farthest via + * nodes.commonAncestors().last() + * , because the common ancestors are in descending order of closeness. + * + * @param selector [optional] A selector used to filter the resultant collection + */ + commonAncestors(selector?: Selector): CollectionNodes; + + /** + * Get all orphan (i.e. has no compound parent) nodes in the calling collection. + * + * @param selector [optional] A selector used to filter the resultant collection. + */ + orphans(selector?: Selector): CollectionNodes; + + /** + * Get all nonorphan (i.e. has a compound parent) nodes in the calling collection. + * + * @param selector [optional] A selector used to filter the resultant collection. + */ + nonorphans(selector?: Selector): CollectionNodes; + + /** + * Get all compound child (i.e. direct descendant) nodes of each node in the collection. + * + * @param selector [optional] A selector used to filter the resultant collection. + */ + children(selector?: Selector): CollectionNodes; + + /** + * Get all compound descendant (i.e. children, children's children, etc.) nodes of each node in the collection. + * + * @param selector [optional] A selector used to filter the resultant collection. + */ + descendants(selector?: Selector): CollectionNodes; + + /** + * Get all sibling (i.e. same compound parent) nodes of each node in the collection. + * + * @param selector [optional] A selector used to filter the resultant collection. + */ + siblings(selector?: Selector): CollectionNodes; + } + + interface CollectionFirstManipulation { + /** + * Get whether the element has been removed from the graph. + */ + removed(): boolean; + /** + * Get whether the element is inside the graph (i.e. not removed). + */ + inside(): boolean; + + } + interface CollectionFirstData { + //http://js.cytoscape.org/#collection/data + + /** + * Get all data for the element. + */ + data(): any; + /** + * Get a particular data field for the element. + */ + data(name: string): any; + /** + * Set a particular data field for the element. + */ + data(name: string, value: any); + /** + * Update multiple data fields at once via an object. + */ + data(obj: any); + + /** + * Get the entire scratchpad object for the element, where temporary or non-JSON data can be stored. App-level scratchpad data should use namespaces prefixed with underscore, like '_foo'. + */ + scratch(): Scratchpad; + /** + * Get the scratchpad at a particular namespace, where temporary or non-JSON data can be stored. App-level scratchpad data should use namespaces prefixed with underscore, like '_foo'. + * + * @param namespace A namespace string. + */ + scratch(namespace: string): Scratchpad; + /** + * Set the scratchpad at a particular namespace, where temporary or non-JSON data can be stored. App-level scratchpad data should use namespaces prefixed with underscore, like '_foo'. + * + * @param namespace A namespace string. + * @param value The value to set at the specified namespace. + */ + scratch(namespace: string, value: any): Scratchpad; + + /** + * Remove scratchpad data. You should remove scratchpad data only at your own namespaces. + * + * @param namespace A namespace string. + */ + removeScratch(namespace: string); + + /** + * A shortcut to get the ID of an element. + */ + id(): string; + + /** + * Get the element's plain JavaScript object representation. + */ + json(): string; + + /** + * Get the group string that defines the type of the element. + * + * The group strings are 'nodes' for nodes and 'edges' for edges. In general, you should be using ele.isEdge() and ele.isNode() instead of ele.group(). + */ + group(): ElementGroup; + + /** + * Get whether the element is a node. + */ + isNode(): boolean; + + /** + * Get whether the element is an edge. + */ + isEdge(): boolean; + + + cy(): Cy.Instance + } + interface CollectionFirstEdgeData { + //http://js.cytoscape.org/#collection/data + + /** + * Get whether the edge is a loop (i.e. source same as target). + */ + isLoop(): boolean; + + /** + * Get whether the edge is simple (i.e. source different than target). + */ + isSimple(): boolean; + } + interface CollectionFirstNodeMetadata { + //http://js.cytoscape.org/#collection/metadata + + /** + * Get the degree of a node. + * + * For a node, the degree is the number of edge connections it has. Each time a node is referenced as source or target of an edge in the graph, that counts as an edge connection. + * + * @param includeLoops A boolean, indicating whether loops are to be included in degree calculations. + */ + degree(includeLoops: boolean): number; + /** + * Get the indegree of a node. + * + * For a node, the indegree is the number of incoming edge connections it has. Each time a node is referred to as target of an edge in the graph, that counts as an incoming edge connection. + * + * @param includeLoops A boolean, indicating whether loops are to be included in degree calculations. + */ + indegree(includeLoops: boolean): number; + /*** + * Get the outdegree of a node. + * + * For a node, the outdegree is the number of outgoing edge connections it has. Each time a node is referred to as source of an edge in the graph, that counts as an outgoing edge connection. + * + * @param includeLoops A boolean, indicating whether loops are to be included in degree calculations. + */ + outdegree(includeLoops: boolean): number; + } + interface CollectionFirstNodePosition extends CollectionPosition{ + //http://js.cytoscape.org/#collection/position--dimensions + + /** + * Get the (model) position of a node. + */ + position(): Position; + /** + * Get the value of a specified position dimension. + * + * @param dimension The position dimension to get. + */ + position(dimension: PositionDimension): Position; + /** + * Set the value of a specified position dimension. + * + * @param dimension The position dimension to set. + * @param value The value to set to the dimension. + */ + position(dimension: PositionDimension, value: number): CollectionNodes; + /** + * Set the position using name-value pairs in the specified object. + * + * @param pos An object specifying name-value pairs representing dimensions to set. + */ + position(pos: Position): CollectionNodes; + + /** + * Get the (model) position of a node. + */ + modelPosition(): Position; + /** + * Get the value of a specified position dimension. + * + * @param dimension The position dimension to get. + */ + modelPosition(dimension: PositionDimension): Position; + /** + * Set the value of a specified position dimension. + * + * @param dimension The position dimension to set. + * @param value The value to set to the dimension. + */ + modelPosition(dimension: PositionDimension, value: number): CollectionNodes; + /** + * Set the position using name-value pairs in the specified object. + * + * @param pos An object specifying name-value pairs representing dimensions to set. + */ + modelPosition(pos: Position): CollectionNodes; + + /** + * Get the (model) position of a node. + */ + point(): Position; + /** + * Get the value of a specified position dimension. + * + * @param dimension The position dimension to get. + */ + point(dimension: PositionDimension): Position; + /** + * Set the value of a specified position dimension. + * + * @param dimension The position dimension to set. + * @param value The value to set to the dimension. + */ + point(dimension: PositionDimension, value: number): CollectionNodes; + /** + * Set the position using name-value pairs in the specified object. + * + * @param pos An object specifying name-value pairs representing dimensions to set. + */ + point(pos: Position): CollectionNodes; + + /** + * Get the rendered (on-screen) position of a node. + */ + renderedPosition(): Position; + /** + * Get the value of a specified rendered posisition dimension. + * + * @param dimension The position dimension to get. + */ + renderedPosition(dimension: PositionDimension): number; + /** + * Set the value of a specified rendered posisition dimension. + * + * @param dimension The position dimension to get. + * @param value The value to set to the dimension. + */ + renderedPosition(dimension: PositionDimension, value: number): CollectionNodes; + /** + * Set the rendered position using name-value pairs in the specified object. + * + * @param pos An object specifying name-value pairs representing dimensions to set. + */ + renderedPosition(pos: Position): CollectionNodes; + + /** + * Get the rendered (on-screen) position of a node. + */ + renderedPoint(): Position; + /** + * Get the rendered (on-screen) position of a node. + * + * @param dimension The position dimension to get. + */ + renderedPoint(dimension: PositionDimension): number; + /** + * Set the value of a specified rendered posisition dimension. + * + * @param dimension The position dimension to get. + * @param value The value to set to the dimension. + */ + renderedPoint(dimension: PositionDimension, value: number): CollectionNodes; + /** + * Set the rendered position using name-value pairs in the specified object. + * + * @param pos An object specifying name-value pairs representing dimensions to set. + */ + renderedPoint(pos: Position): CollectionNodes; + + /** + * Get the position of a node, relative to its compound parent. + */ + relativePosition(): Position; + /** + * Get the position of a node, relative to its compound parent. + * + * @param dimension The position dimension to get. + */ + relativePosition(dimension: PositionDimension): number; + /** + * Set the value of a specified relative posisition dimension. + * + * @param dimension The position dimension to get. + * @param value The value to set to the dimension. + */ + relativePosition(dimension: PositionDimension, value: number): CollectionNodes; + /** + * Set the relative position using name-value pairs in the specified object. + * + * @param pos An object specifying name-value pairs representing dimensions to set. + */ + relativePosition(pos: Position): CollectionNodes; + + /** + * Get the position of a node, relative to its compound parent. + */ + relativePoint(): Position; + /** + * Get the position of a node, relative to its compound parent. + * + * @param dimension The position dimension to get. + */ + relativePoint(dimension: PositionDimension): number; + /** + * Set the value of a specified relative posisition dimension. + * + * @param dimension The position dimension to get. + * @param value The value to set to the dimension. + */ + relativePoint(dimension: PositionDimension, value: number): CollectionNodes; + /** + * Set the relative position using name-value pairs in the specified object. + * + * @param pos An object specifying name-value pairs representing dimensions to set. + */ + relativePoint(pos: Position): CollectionNodes; + } + interface CollectionFirstPosition { + //http://js.cytoscape.org/#collection/position--dimensions + + /** + * Get the width of the element. + */ + width(): number; + /** + * Get the outer width of the element (includes width & border). + */ + outerWidth(): number; + /** + * Get the width of the element in rendered dimensions. + */ + renderedWidth(): number; + /** + * Get the outer width of the element (includes width & border) in rendered dimensions. + */ + renderedOuterWidth(): number; + + /** + * Get the height of the element. + */ + height(): number; + /** + * Get the outer height of the element (includes height & border). + */ + outerHeight(): number; + /** + * Get the height of the element in rendered dimensions. + */ + renderedHeight(): number; + /** + * Get the outer height of the element (includes height & border) in rendered dimensions. + */ + renderedOuterHeight(): number; + + /** + * Gets whether the element is active (e.g. on user tap, grab, etc). + */ + active(): boolean; + } + interface CollectionFirstSelection { + // http://js.cytoscape.org/#collection/selection + + /** + * Get whether the element is selected. + */ + selected(): boolean; + + /** + * Get whether the element's selection state is mutable. + */ + selectable(): boolean; + } + interface CollectionFirstStyle { + // http://js.cytoscape.org/#collection/style + + /** + * Get whether an element has a particular class. + * + * @param className The name of the class to test for. + */ + hasClass(className: string): boolean; + + ///** + //* Get a name-value pair object containing visual style properties and their values for the element. + //*/ + //style(): Css.ElementCss; + ///** + // * Get a particular style property value. + // * + // * @param name The name of the visual style property to get. + // */ + //style(name: string): Css.ElementCss; + + ///** + // * Get a name-value pair object containing visual style properties and their values for the element. + // */ + //css(): Css.ElementCss; + ///** + // * Get a particular style property value. + // * + // * @param name The name of the visual style property to get. + // */ + //css(name: string): Css.ElementCss; + + ///** + // * Get a name-value pair object containing visual style properties and their values for the element. + // */ + //bypass(): Css.ElementCss; + ///** + // * Get a particular style property value. + // * + // * @param name The name of the visual style property to get. + // */ + //bypass(name: string): Css.ElementCss; + + /** + * Get a name-value pair object containing rendered visual style properties and their values for the element. + */ + renderedStyle(): Css.ElementCss; + /** + * Get a particular rendered style property value. + * + * @param name The name of the visual style property to get. + */ + renderedStyle(name: string): Css.ElementCss; + /** + * Get a name-value pair object containing rendered visual style properties and their values for the element. + */ + renderedCss(): Css.ElementCss; + /** + * Get a particular rendered style property value. + * + * @param name The name of the visual style property to get. + */ + renderedCss(name: string): Css.ElementCss; + + /** + * Get whether the element is visible. + */ + visible(): boolean; + /** + * Get whether the element is hidden. + */ + hidden(): boolean; + + /** + * Get the effective opacity of the element (i.e. on-screen opacity), which takes into consideration parent node opacity. + */ + effectiveOpacity(): number; + + /** + * Get whether the element's effective opacity is completely transparent, which takes into consideration parent node opacity. + */ + transparent(): boolean; + } + interface CollectionFirtsAnimation { + // http://js.cytoscape.org/#collection/animation + + /** + * Get whether the element is currently being animated. + */ + animated(): boolean; + } + interface CollectionFirstEdgeTraversing { + // http://js.cytoscape.org/#collection/traversing + + /** + * Get source node of this edge. + * + * @param selector [optional] An optional selector that is used to filter the resultant collection. + */ + source(selector?: Selector): CollectionNodes; + + /** + * Get target node of this edge. + * + * @param selector [optional] An optional selector that is used to filter the resultant collection. + */ + target(selector?: Selector): CollectionNodes; + } + interface CollectionFirstNodeCompound { + // http://js.cytoscape.org/#collection/compound-nodes + + /** + * Get whether the node is a compound parent (i.e. a node containing one or more child nodes) + */ + isParent(): boolean; + + /** + * Get whether the node is a compound child (i.e. contained within a node) + */ + isChild(): boolean; + } + + interface ElementsDefinition { + nodes: Sdc.Models.Graph.CommonNodeBase[]; + edges: Sdc.Models.CommonLinkBase[]; + } + + interface ElementDefinition { + + + group?: ElementGroup; + data: Sdc.Models.Graph.CommonNodeBase| Sdc.Models.CommonLinkBase; + /** + * Scratchpad data (usually temp or nonserialisable data) + */ + scatch?: Scratchpad; + /** + * The model position of the node (optional on init, mandatory after) + */ + position?: Position; + /** + * can alternatively specify position in rendered on-screen pixels + */ + renderedPosition?: Position; + /** + * Whether the element is selected (default false) + */ + selected?: boolean; + /** + * Whether the selection state is mutable (default true) + */ + selectable?: boolean; + /** + * When locked a node's position is immutable (default false) + */ + locked?: boolean; + /** + * Wether the node can be grabbed and moved by the user + */ + grabbable?: boolean; + /** + * a space separated list of class names that the element has + */ + classes?: string; + style?: CSSStyleDeclaration; + /** + * you should only use `style`/`css` for very special cases; use classes instead + */ + css?: Css.ElementCss; + } + + // interface ElementDataDefinition { + // /** + // * elided id => autogenerated id + // */ + // isSdcElement?: boolean; + // id?: string; + // position?: Position; + // label?: string; + // } + interface EdgeDefinition extends ElementDefinition { + data: Sdc.Models.CommonLinkBase; + } + + // interface EdgeDataDefinition extends ElementDataDefinition { /** + // * the source node id (edge comes from this node) + // */ + // source: string; + // /** + // * the target node id (edge goes to this node) + // */ + // target: string; + // commonGraphLink?: Sdc.Models.CompositionCiLinkBase; //this is sdc-link-data-object + // } + interface NodeDefinition extends ElementDefinition { + + data: Sdc.Models.Graph.CommonNodeBase; + + } + // interface NodeDataDefinition extends ElementDataDefinition { + // parent?: string; + // commonGraphNode?: Sdc.Models.Graph.CommonNodeBase; //this is sdc-node-data-object + // type: string + // + // } + + interface Stylesheet { + selector: string; + css: Css.ElementCss; + } + + export module Css { + //TODO: http://js.cytoscape.org/#style + + type Colour = string; + + // TODO: How to constrain to a value? + type Shape = string; // 'rectangle', 'roundrectangle', 'ellipse', 'triangle', pentagon, hexagon, heptagon, octagon, star + + // TODO: How to constrain to a value? + type Style = string; // solid, dotted, dashed, or double + + export interface NodeCss { + width?: number; + height?: number; + shape?: Shape; + backgroundColor?: Colour; + "background-color"?: any; + "background-blacken"?: number; + "background-opacity"?: number; + "background-image"?: any; + "background-width"?: number; + "background-height"?: number; + "border-width"?: number; + "border-style"?: Style; + "border-color"?: Colour; + "border-opacity"?: number; + "label"?: string; + "events"?: string; + "text-events"?: string; + "text-valign"? :string; + "text-halign"? :string; + "text-margin-y"? :any; + "active-bg-size"?: number; + "background-fit"?: string; + "background-clip"?: string; + "background-image-opacity"?: number; + "overlay-color"?: string; + "font-size"? :number; + "font-family"? :string; + "background-position-x"? :number; + "background-position-y"? :number; + 'overlay-opacity'?: number; + 'text-border-width'?: number; + 'text-border-color'?: string; + 'text-border-opacity'?: number; + } + + export interface SelectionBox { + "selection-box-color"?: string + "selection-box-border-color"?: string + "selection-box-border-width"?: number + "selection-box-opacity"?: number + + } + + export interface CompoundNodeCss extends NodeCss { + "padding-left"?: number; + "padding-right"?: number; + "padding-top"?: number; + "padding-bottom"?: number; + "compound-sizing-wrt-labels"?: string; + } + + export interface EdgeCss { + + "line-color"?: string; + "target-arrow-color"?: string; + "target-arrow-shape"?: string; + "curve-style"?: string; + "control-point-step-size"?: number; + "control-point-distances"?: string, + "control-point-weights"?: string, + "segment-distances"?: string, + "segment-weights"?: string + "line-style"? : string + } + + export interface ElementCss extends NodeCss, CompoundNodeCss, EdgeCss, SelectionBox { + } + //export interface ElementCss extends CSSStyleDeclaration { } + } + + interface Renderer { + /** + * The name of the renderer to use. By default, the 'canvas' renderer is used. If you build and register your own renderer, then you can specify its name here. + */ + name: string; + } + + interface Instance extends InstanceEvent, InstanceViewPort, InstanceAnimation, InstanceLayout, InstanceStyle, InstanceExport { + /** + * Add elements to the graph and return them. + */ + add(eleObj: ElementDefinition): CollectionElements; + /** + * Add elements to the graph and return them. + */ + add(eleObjs: ElementDefinition[]): CollectionElements; + /** + * Add elements to the graph and return them. + */ + add(eles: Collection): CollectionElements; + + /** + * Remove elements from the graph and return them. + */ + remove(eles: Collection): CollectionElements; + /** + * Remove elements in the graph matching the specified selector. + */ + remove(selector: Selector): CollectionElements; + + /** + * Get an empty collection. + */ + collection(): CollectionElements; + /** + * Get a collection from elements in the graph matching the specified selector. + */ + collection(selector: Selector): CollectionElements; + /** + * Get a collection from an array of elements. + */ + collection(elesArray: CollectionElements[]): CollectionElements; + + /** + * Get an element from its ID in a very performant way. + */ + getElementById(id: string): CollectionElements; + + /** + * Get elements in the graph matching the specified selector. + */ + $(selector: Selector): CollectionElements; + /** + * Get elements in the graph. + */ + elements(): CollectionElements; + /** + * Get elements in the graph matching the specified selector. + */ + elements(selector: Selector): CollectionElements; + /** + * Get nodes in the graph. + */ + nodes(): CollectionNodes; + /** + * Get nodes in the graph matching the specified selector. + */ + nodes(selector: Selector): CollectionNodes; + /** + * Get edges in the graph. + */ + edges(): CollectionEdges; + /** + * Get edges in the graph matching the specified selector. + */ + edges(selector: Selector): CollectionEdges; + /** + * Get elements in the graph matching the specified selector. + */ + filter(selector: Selector): CollectionElements; + /** + * Get elements in the graph matching the specified filter function. + */ + filter(filter: (i: number, ele: CollectionFirst) => boolean): CollectionElements; + + /** + * Allow for manipulation of elements without triggering multiple style calculations or multiple redraws. + * + * A callback within which you can make batch updates to elements. + */ + batch(callback: () => void): void; + /** + * Allow for manipulation of elements without triggering multiple style calculations or multiple redraws. + * Starts batching manually (useful for asynchronous cases). + */ + startBatch(): void; + /** + * Allow for manipulation of elements without triggering multiple style calculations or multiple redraws. + * Ends batching manually (useful for asynchronous cases). + */ + endBatch(): void; + + /** + * A convenience function to explicitly destroy the instance. + */ + destroy(): void; + } + + interface EventObject { + /** + * Holds a reference to the originator of the event (core or element) + */ + cyTarget: any; //CollectionElements or Cy.Instance; + data: any; + } + + interface InstanceEvent { + // http://js.cytoscape.org/#core/events + + /** + * Bind to events that occur in the graph. + * + * @param events A space separated list of event names. + * @param handler The handler function that is called when one of the specified events occurs. + */ + on(events: string, handler: (evt: EventObject, data?: any) => void): void; + /** + * Bind to events that occur in the graph. + * + * @param events A space separated list of event names. + * @param handler The handler function that is called when one of the specified events occurs. + * @param selector A selector to specify elements for which the handler is triggered. + */ + on(events: string, selector: Selector, handler: (evt: EventObject, data?: any) => void): void; + /** + * Bind to events that occur in the graph. + * + * @param events A space separated list of event names. + * @param handler The handler function that is called when one of the specified events occurs. + * @param selector A selector to specify elements for which the handler is triggered. + * @param data A plain object which is passed to the handler in the event object argument. + */ + on(events: string, selector: Selector, data: any, handler: (evt: EventObject, data?: any) => void): void; + /** + * Bind to events that occur in the graph. + * + * @param eventsMap A map of event names to handler functions. + * @param selector A selector to specify elements for which the handler is triggered. + * @param data A plain object which is passed to the handler in the event object argument. + */ + on(eventsMap: { + [value: string]: (evt: EventObject, data?: any) => void + }, selector?: Selector, data?: any); + + /** + * Bind to events that occur in the graph. + * + * @param events A space separated list of event names. + * @param handler The handler function that is called when one of the specified events occurs. + */ + bind(events: string, handler: (evt: EventObject, data?: any) => void): void; + /** + * Bind to events that occur in the graph. + * + * @param events A space separated list of event names. + * @param handler The handler function that is called when one of the specified events occurs. + * @param selector A selector to specify elements for which the handler is triggered. + */ + bind(events: string, selector: Selector, handler: (evt: EventObject, data?: any) => void): void; + /** + * Bind to events that occur in the graph. + * + * @param events A space separated list of event names. + * @param handler The handler function that is called when one of the specified events occurs. + * @param selector A selector to specify elements for which the handler is triggered. + * @param data A plain object which is passed to the handler in the event object argument. + */ + bind(events: string, selector: Selector, data: any, handler: (evt: EventObject, data?: any) => void): void; + /** + * Bind to events that occur in the graph. + * + * @param eventsMap A map of event names to handler functions. + * @param selector A selector to specify elements for which the handler is triggered. + * @param data A plain object which is passed to the handler in the event object argument. + */ + bind(eventsMap: { + [value: string]: (evt: EventObject, data?: any) => void + }, selector?: Selector, data?: any); + + /** + * Bind to events that occur in the graph. + * + * @param events A space separated list of event names. + * @param handler The handler function that is called when one of the specified events occurs. + */ + listen(events: string, handler: (evt: EventObject) => void): void; + /** + * Bind to events that occur in the graph. + * + * @param events A space separated list of event names. + * @param handler The handler function that is called when one of the specified events occurs. + * @param selector A selector to specify elements for which the handler is triggered. + */ + listen(events: string, selector: Selector, handler: (evt: EventObject) => void): void; + /** + * Bind to events that occur in the graph. + * + * @param events A space separated list of event names. + * @param handler The handler function that is called when one of the specified events occurs. + * @param selector A selector to specify elements for which the handler is triggered. + * @param data A plain object which is passed to the handler in the event object argument. + */ + listen(events: string, selector: Selector, data: any, handler: (evt: EventObject) => void): void; + /** + * Bind to events that occur in the graph. + * + * @param eventsMap A map of event names to handler functions. + * @param selector A selector to specify elements for which the handler is triggered. + * @param data A plain object which is passed to the handler in the event object argument. + */ + listen(eventsMap: { + [value: string]: (evt: EventObject) => void + }, selector?: Selector, data?: any); + + /** + * Bind to events that occur in the graph. + * + * @param events A space separated list of event names. + * @param handler The handler function that is called when one of the specified events occurs. + */ + addListener(events: string, handler: (evt: EventObject) => void): void; + /** + * Bind to events that occur in the graph. + * + * @param events A space separated list of event names. + * @param handler The handler function that is called when one of the specified events occurs. + * @param selector A selector to specify elements for which the handler is triggered. + */ + addListener(events: string, selector: Selector, handler: (evt: EventObject) => void): void; + /** + * Bind to events that occur in the graph. + * + * @param events A space separated list of event names. + * @param handler The handler function that is called when one of the specified events occurs. + * @param selector A selector to specify elements for which the handler is triggered. + * @param data A plain object which is passed to the handler in the event object argument. + */ + addListener(events: string, selector: Selector, data: any, handler: (evt: EventObject) => void): void; + /** + * Bind to events that occur in the graph. + * + * @param eventsMap A map of event names to handler functions. + * @param selector A selector to specify elements for which the handler is triggered. + * @param data A plain object which is passed to the handler in the event object argument. + */ + addListener(eventsMap: { + [value: string]: (evt: EventObject) => void + }, selector?: Selector, data?: any); + + /** + * Bind to events that occur in the graph, and trigger the handler only once. + * + * @param events A space separated list of event names. + * @param handler The handler function that is called when one of the specified events occurs. + */ + one(events: string, handler: (evt: EventObject) => void): void; + /** + * Bind to events that occur in the graph, and trigger the handler only once. + * + * @param events A space separated list of event names. + * @param handler The handler function that is called when one of the specified events occurs. + * @param selector A selector to specify elements for which the handler is triggered. + */ + one(events: string, selector: Selector, handler: (evt: EventObject) => void): void; + /** + * Bind to events that occur in the graph, and trigger the handler only once. + * + * @param events A space separated list of event names. + * @param handler The handler function that is called when one of the specified events occurs. + * @param selector A selector to specify elements for which the handler is triggered. + * @param data A plain object which is passed to the handler in the event object argument. + */ + one(events: string, selector: Selector, data: any, handler: (evt: EventObject) => void): void; + /** + * Bind to events that occur in the graph, and trigger the handler only once. + * + * @param eventsMap A map of event names to handler functions. + * @param selector A selector to specify elements for which the handler is triggered. + * @param data A plain object which is passed to the handler in the event object argument. + */ + one(eventsMap: { + [value: string]: (evt: EventObject) => void + }, selector?: Selector, data?: any); + + /** + * Remove event handlers. + * @param events A space separated list of event names. + * @param selector [optional] The same selector used to bind to the events. + * @param handler [optional] A reference to the handler function to remove. + */ + off(events: string, selector?: Selector, handler?: (evt: EventObject) => void): void; + + /** + * Remove event handlers. + * @param eventsMap A map of event names to handler functions to remove. + * @param selector [optional] The same selector used to bind to the events. + */ + off(eventsMap: { + [value: string]: (evt: EventObject) => void + }, selector?: Selector): void; + + /** + * Remove event handlers. + * @param events A space separated list of event names. + * @param selector [optional] The same selector used to bind to the events. + * @param handler [optional] A reference to the handler function to remove. + */ + unbind(events: string, selector?: Selector, handler?: (evt: EventObject) => void): void; + + /** + * Remove event handlers. + * @param eventsMap A map of event names to handler functions to remove. + * @param selector [optional] The same selector used to bind to the events. + */ + unbind(eventsMap: { + [value: string]: (evt: EventObject) => void + }, selector?: Selector): void; + + /** + * Remove event handlers. + * @param events A space separated list of event names. + * @param selector [optional] The same selector used to bind to the events. + * @param handler [optional] A reference to the handler function to remove. + */ + unlisten(events: string, selector?: Selector, handler?: (evt: EventObject) => void): void; + + /** + * Remove event handlers. + * @param eventsMap A map of event names to handler functions to remove. + * @param selector [optional] The same selector used to bind to the events. + */ + unlisten(eventsMap: { + [value: string]: (evt: EventObject) => void + }, selector?: Selector): void; + + /** + * Remove event handlers. + * @param events A space separated list of event names. + * @param selector [optional] The same selector used to bind to the events. + * @param handler [optional] A reference to the handler function to remove. + */ + removeListener(events: string, selector?: Selector, handler?: (evt: EventObject) => void): void; + + /** + * Remove event handlers. + * + * @param eventsMap A map of event names to handler functions to remove. + * @param selector [optional] The same selector used to bind to the events. + */ + removeListener(eventsMap: { + [value: string]: (evt: EventObject) => void + }, selector?: Selector): void; + + /** + * Trigger one or more events. + * + * @param events A space separated list of event names to trigger. + * @param extraParams [optional] An array of additional parameters to pass to the handler. + */ + trigger(events: string, extraParams?: any[]): void; + + /** + * Trigger one or more events. + * + * @param events A space separated list of event names to trigger. + * @param extraParams [optional] An array of additional parameters to pass to the handler. + */ + emit(events: string, extraParams?: any[]): void; + + /** + * Get whether the initial render event has occurred (useful for plugins etc). + * + * This function returns whether the initrender event has occurred on the graph, meaning that the renderer has drawn the graph at least once. This is useful when you need to grab image data from the core, as this function will let you know whether that data is available yet: You can not grab the graph scene if it has not yet been rendered. + */ + initrender(): boolean; + + /** + * Run a handler function every time a frame is rendered. + * + * @param handler The handler function to call on each frame. + */ + onRender(handler: () => void): void; + + /** + * Remove handlers function bound via cy.onRender(). + * + * @param handler [optional] A reference to the handler function to remove. All handlers are removed if this is unspecified. + */ + offRender(handler?: () => void): void; + + /** + * Run a callback as soon as the graph becomes ready. If the graph is already ready, then the callback is called immediately. + * @param fn The callback run as soon as the graph is ready, inside which this refers to the core (cy). + */ + ready(fn: () => void): void; + } + + interface InstanceViewPort { + // http://js.cytoscape.org/#core/viewport-manipulation + + /** + * Pan the graph to the centre of a collection. + * + * @param eles The collection to centre upon. + */ + center(eles?: Collection): CollectionElements; + + /** + * Pan and zooms the graph to fit to a collection. + * + * @param eles [optional] The collection to fit to. + * @param padding [optional] An amount of padding (in pixels) to have around the graph + */ + fit(eles?: Collection, padding?: number): CollectionElements; + + /** + * Reset the graph to the default zoom level and panning position. + */ + reset(): CollectionElements; + + /** + * Get the panning position of the graph. + */ + pan(): Position; + + /** + * Set the panning position of the graph. + * + * @param renderedPosition The rendered position to pan the graph to. + */ + pan(renderedPosition?: Position): void; + + /** + * Relatively pan the graph by a specified rendered position vector. + * + * @param renderedPosition The rendered position vector to pan the graph by. + */ + panBy(renderedPosition: Position): void; + + /** + * Get whether panning is enabled. If cy.boxSelectionEnabled() === true, then the user must taphold to initiate panning. + */ + panningEnabled(): boolean; + + /** + * Set whether panning is enabled. If cy.boxSelectionEnabled() === true, then the user must taphold to initiate panning. + * + * @param bool A truthy value enables panning; a falsey value disables it. + */ + panningEnabled(bool: boolean): void; + + /** + * Get whether panning by user events (e.g. dragging the graph background) is enabled. If cy.boxSelectionEnabled() === true, then the user must taphold to initiate panning. + */ + userPanningEnabled(): boolean; + + /** + * Set whether panning by user events (e.g. dragging the graph background) is enabled. If cy.boxSelectionEnabled() === true, then the user must taphold to initiate panning. + * + * @param bool A truthy value enables user panning; a falsey value disables it. + */ + userPanningEnabled(bool: boolean): void; + + /** + * Get the zoom level. + */ + zoom(): number; + /** + * Set the zoom level. + * + * @param level The zoom level to set. + */ + zoom(level: number): void; + /** + * Set the zoom level. + * + * @param options The options for zooming. + */ + zoom(options: ZoomOptions): void; + + /** + * Get whether zooming is enabled. + */ + zoomingEnabled(): boolean; + /** + * Set whether zooming is enabled. + * + * @param bool A truthy value enables zooming; a falsey value disables it. + */ + zoomingEnabled(bool: boolean): void; + + /** + * Get whether zooming by user events (e.g. mouse wheel, pinch-to-zoom) is enabled. + */ + userZoomingEnabled(): boolean; + /** + * Set whether zooming by user events (e.g. mouse wheel, pinch-to-zoom) is enabled. + * + * @param bool A truthy value enables user zooming; a falsey value disables it. + */ + userZoomingEnabled(bool: boolean): void; + + /** + * Get the minimum zoom level. + */ + minZoom(): number; + /** + * Set the minimum zoom level. + * + * @param zoom The new minimum zoom level to use. + */ + minZoom(zoom: number): void; + + /** + * Get the maximum zoom level. + */ + maxZoom(): number; + /** + * Set the maximum zoom level. + * + * @param zoom The new maximum zoom level to use. + */ + maxZoom(zoom: number): void; + + /** + * Set the viewport state (pan & zoom) in one call. + * + * @param zoom The zoom level to set. + * @param pan The pan to set (a rendered position). + */ + viewport(zoom: number, pan: Position): void; + + /** + * Get whether box selection is enabled. If enabled, the user must hold left-click to initiate panning. + */ + boxSelectionEnabled(): boolean; + /** + * Set whether box selection is enabled. If enabled, the user must hold left-click to initiate panning. + * + * @param bool A truthy value enables box selection; a falsey value disables it. + */ + boxSelectionEnabled(bool: boolean): void; + + /** + * Get the on-screen width of the viewport in pixels. + */ + width(): number; + + /** + * Get the on-screen height of the viewport in pixels. + */ + height(): number; + + /** + * Get the extent of the viewport, a bounding box in model coordinates that lets you know what model positions are visible in the viewport. + */ + extent(): Extent; + + /** + * Get whether nodes are automatically locked (i.e. if true, nodes are locked despite their individual state). + */ + autolock(): boolean; + /** + * Set whether nodes are automatically locked (i.e. if true, nodes are locked despite their individual state). + * + * @param bool A truthy value enables autolocking; a falsey value disables it. + */ + autolock(bool: boolean): void; + + /** + * Get whether nodes are automatically ungrabified (i.e. if true, nodes are ungrabbale despite their individual state). + */ + autoungrabify(): boolean; + /** + * Set whether nodes are automatically ungrabified (i.e. if true, nodes are ungrabbale despite their individual state). + * + * @param bool A truthy value enables autolocking; a falsey value disables it. + */ + autoungrabify(bool: boolean): void; + + /** + * Get whether nodes are automatically unselectified (i.e. if true, nodes are unselectable despite their individual state). + */ + autounselectify(): boolean; + /** + * Set whether nodes are automatically unselectified (i.e. if true, nodes are unselectable despite their individual state). + * + * @param bool A truthy value enables autolocking; a falsey value disables it. + */ + autounselectify(bool: boolean): void; + + /** + * Force the renderer to redraw (i.e. draw a new frame). + * + * This function forces the renderer to draw a new frame. It is useful for very specific edgecases, such as in certain UI plugins, but it should not be needed for most developers. + */ + forceRender(): void; + + /** + * Force the renderer to recalculate the viewport bounds. + * + * If your code resizes the graph's dimensions or position (i.e. by changing the style of the HTML DOM element that holds the graph), you will want to call cy.resize() to have the graph resize and redraw itself. + * + * Cytoscape.js can not automatically monitor the bounding box of the viewport, as querying the DOM for those dimensions can be expensive. Although cy.resize() is automatically called for you on the window's resize event, there is no resize or style event for arbitrary DOM elements. + */ + resize(): CollectionElements; + } + + interface InstanceAnimation { + // http://js.cytoscape.org/#core/animation + + /** + * Get whether the viewport is currently being animated. + */ + animated(): boolean; + + /** + * Animate the viewport. + * + * @param anis An object containing the details of the animation. + * zoom A zoom level to which the graph will be animated. + * pan A panning position to which the graph will be animated. + * panBy A relative panning position to which the graph will be animated. + * fit An object containing fitting options from which the graph will be animated. + * eles Elements or a selector to which the viewport will be fitted. + * padding Padding to use with the fitting. + * center An object containing centring options from which the graph will be animated. + * eles Elements or a selector to which the viewport will be centred. + * @param options An object containing animation options. + * duration - The duration of the animation in milliseconds. + * queue - A boolean indicating whether to queue the animation. + * complete - A function to call when the animation is done. + * step - A function to call each time the animation steps. + */ + animate(anis: { + zoom?: number, + pan?: Position, + panBy?: Position, + fit?: { + eles: Collection, + padding?: number + }, + center?: { + eles: Collection + } + }, options?: { + duration?: number, + queue?: boolean, + complete?: () => void, + step?: () => void + }): Cy.Instance; + + /** + * Add a delay between animations for the viewport. + * + * @param duration How long the delay should be in milliseconds. + * @param complete A function to call when the delay is complete. + */ + delay(duration: number, complete?: () => void): Cy.Instance; + + /** + * Stop all viewport animations that are currently running. + * + * @param clearQueue A boolean, indicating whether the queue of animations should be emptied. + * @param jumpToEnd A boolean, indicating whether the currently-running animations should jump to their ends rather than just stopping midway. + */ + stop(clearQueue?: boolean, jumpToEnd?: boolean): Cy.Instance; + + /** + * Remove all queued animations for the viewport. + */ + clearQueue(): Cy.Instance; + } + + interface InstanceLayout { + //TODO: http://js.cytoscape.org/#core/layout + layout(layout: LayoutOptions): void; + + } + + interface InstanceStyle { + //TODO: http://js.cytoscape.org/#core/style + } + + interface InstanceExport { + /** + * Export the current graph view as a PNG image in Base64 representation. + */ + png(): string; + /** + * Export the current graph view as a PNG image in Base64 representation. + */ + png(options: ExportOptions): string; + + /** + * Export the current graph view as a JPG image in Base64 representation. + */ + jpg(): string; + /** + * Export the current graph view as a JPG image in Base64 representation. + */ + jpg(options: ExportOptions): string; + + /** + * Export the current graph view as a JPG image in Base64 representation. + */ + jpeg(): string; + /** + * Export the current graph view as a JPG image in Base64 representation. + */ + jpeg(options: ExportOptions): string; + + /** + * Export the graph as JSON, the same format used at initialisation. + */ + json(): string; + } + + interface Position { + x: number; + y: number; + } + + interface LayoutInstance { + //TODO: http://js.cytoscape.org/#layouts/layout-manipulation + + /** + * Start running the layout. + */ + run(): void; + /** + * Start running the layout. + */ + start(): void; + + /** + * Stop running the (asynchronous/discrete) layout. + */ + stop(): void; + } + + interface LayoutOptions { + // TODO: http://js.cytoscape.org/#layouts + /** + * + * The default is 'grid'. + */ + name?: string; + padding?: number; + avoidOverlap?: boolean; + } + + interface CytoscapeOptions { + // very commonly used options: + /** + * A HTML DOM element in which the graph should be rendered. + * This is optional if Cytoscape.js is run headlessly or if you initialise using jQuery (in which case your jQuery object already has an associated DOM element). + * + * The default is undefined. + */ + container?: HTMLElement | JQuery; + /** + * The [[Stylesheet]] used to style the graph. For convenience, this option can alternatively be specified as a promise that resolves to the stylesheet. + */ + style?: Stylesheet[]|Promise<Stylesheet[]>; + /** + * An array of [[Elements]] specified as plain objects. For convenience, this option can alternatively be specified as a promise that resolves to the elements JSON. + */ + elements?: ElementsDefinition|ElementDefinition[]|Promise<ElementsDefinition>|Promise<ElementDefinition[]>; + /** + * A plain object that specifies layout options. Which layout is initially run is specified by the name field. Refer to a layout's documentation for the options it supports. If you want to specify your node positions yourself in your elements JSON, you can use the preset layout — by default it does not set any positions, leaving your nodes in their current positions (e.g. specified in options.elements at initialisation time) + */ + layout?: LayoutOptions; + /** + * A callback function that is called when Cytoscape.js has loaded the graph and the layout has specified initial positions of the nodes. After this point, rendering can happen, the user can interact with the graph, et cetera. + */ + ready?: (evt: any) => void; + + // initial viewport state: + /** + * The initial zoom level of the graph. Make sure to disable viewport manipulation options, such as fit, in your layout so that it is not overridden when the layout is applied. You can set options.minZoom and options.maxZoom to set restrictions on the zoom level. + * + * The default value is 1. + */ + zoom?: number; + /** + * The initial panning position of the graph. Make sure to disable viewport manipulation options, such as fit, in your layout so that it is not overridden when the layout is applied. + */ + pan?: Position; + + // interaction options?: + /** + * A minimum bound on the zoom level of the graph. The viewport can not be scaled smaller than this zoom level. + * + * The default value is 1e-50. + */ + minZoom?: number; + /** + * A maximum bound on the zoom level of the graph. The viewport can not be scaled larger than this zoom level. + * + * The default value is 1e50. + */ + maxZoom?: number; + /** + * Whether zooming the graph is enabled, both by user events and programmatically. + * + * The default value is true. + */ + zoomingEnabled?: boolean; + /** + * Whether user events (e.g. mouse wheel, pinch-to-zoom) are allowed to zoom the graph. Programmatic changes to zoom are unaffected by this option. + * + * The default value is true. + */ + userZoomingEnabled?: boolean; + /** + * Whether panning the graph is enabled, both by user events and programmatically. + * + * The default value is true. + */ + panningEnabled?: boolean; + /** + * Whether user events (e.g. dragging the graph background) are allowed to pan the graph. Programmatic changes to pan are unaffected by this option. + * + * The default value is true. + */ + userPanningEnabled?: boolean; + /** + * Whether box selection (i.e. drag a box overlay around, and release it to select) is enabled. If enabled, the user must taphold to pan the graph. + * + * The default value is false. + */ + boxSelectionEnabled?: boolean; + /** + * A string indicating the selection behaviour from user input. By default, this is set automatically for you based on the type of input device detected. On touch devices, 'additive' is default — a new selection made by the user adds to the set of currenly selected elements. On mouse-input devices, 'single' is default — a new selection made by the user becomes the entire set of currently selected elements (i.e. the previous elements are unselected). + * + * The default value is (isTouchDevice ? 'additive' : 'single'). + */ + selectionType?: SelectionType; + /** + * A nonnegative integer that indicates the maximum allowable distance that a user may move during a tap gesture, on touch devices and desktop devices respectively. This makes tapping easier for users. These values have sane defaults, so it is not advised to change these options unless you have very good reason for doing so. Larger values will almost certainly have undesirable consequences. + * + * The default value is is 8. + */ + touchTapThreshold?: number; + /** + * A nonnegative integer that indicates the maximum allowable distance that a user may move during a tap gesture, on touch devices and desktop devices respectively. This makes tapping easier for users. These values have sane defaults, so it is not advised to change these options unless you have very good reason for doing so. Larger values will almost certainly have undesirable consequences. + * + * The default value is 4. + */ + desktopTapThreshold?: number; + /** + * Whether nodes should be locked (not draggable at all) by default (if true, overrides individual node state). + * + * The default value is false. + */ + autolock?: boolean; + /** + * Whether nodes should be ungrabified (not grabbable by user) by default (if true, overrides individual node state). + * + * The default value is false. + */ + autoungrabify?: boolean; + /** + * Whether nodes should be unselectified (immutable selection state) by default (if true, overrides individual element state). + * + * The default value is false. + */ + autounselectify?: boolean; + + // rendering options: + /** + * A convenience option that initialises the instance to run headlessly. You do not need to set this in environments that are implicitly headless (e.g. Node.js). However, it is handy to set headless: true if you want a headless instance in a browser. + * + * The default value is false. + */ + headless?: boolean; + /** + * A boolean that indicates whether styling should be used. For headless (i.e. outside the browser) environments, display is not necessary and so neither is styling necessary — thereby speeding up your code. You can manually enable styling in headless environments if you require it for a special case. Note that it does not make sense to disable style if you plan on rendering the graph. + * + * The default value is true. + */ + styleEnabled?: boolean; + /** + * When set to true, the renderer does not render edges while the viewport is being manipulated. This makes panning, zooming, dragging, et cetera more responsive for large graphs. + * + * The default value is false. + */ + hideEdgesOnViewport?: boolean; + /** + * hen set to true, the renderer does not render labels while the viewport is being manipulated. This makes panning, zooming, dragging, et cetera more responsive for large graphs. + * + * The default value is false. + */ + hideLabelsOnViewport?: boolean; + /** + * When set to true, the renderer uses a texture (if supported) during panning and zooming instead of drawing the elements, making large graphs more responsive. + * + * The default value is false. + */ + textureOnViewport?: boolean; + /** + * When set to true, the renderer will use a motion blur effect to make the transition between frames seem smoother. This can significantly increase the perceived performance for a large graphs. + * + * The default value is false. + */ + motionBlur?: boolean; + /** + * When motionBlur: true, this value controls the opacity of motion blur frames. Higher values make the motion blur effect more pronounced. + * + * The default value is 0.2. + */ + motionBlurOpacity?: number; + /** + * Changes the scroll wheel sensitivity when zooming. This is a multiplicative modifier. So, a value between 0 and 1 reduces the sensitivity (zooms slower), and a value greater than 1 increases the sensitivity (zooms faster). + * + * The default value is 1. + */ + wheelSensitivity?: number; + /** + * Overrides the screen pixel ratio with a manually set value (1.0 or 0.666 recommended, if set). This can be used to increase performance on high density displays by reducing the effective area that needs to be rendered. If you want to use the hardware's actual pixel ratio at the expense of performance, you can set pixelRatio: 'auto'. + * + * The default value is 1. + */ + pixelRatio?: number; + /** + * A callback function that is called when Cytoscape.js has rendered its first frame. This is useful for grabbing screenshots etc after initialision, but in general you should use ready instead. + */ + initrender?: (evt: any) => void; + /** + * A plain object containing options for the renderer to be used. The options.renderer.name field specifies which renderer is used. You need not specify anything for the renderer option, unless you want to specify one of the rendering options. + */ + renderer?: Renderer; + } + + interface ExportOptions { + /** + * The background colour of the image (transparent by default). + */ + bg?: string; + /** + * Whether to export the current viewport view (false, default) or the entire graph (true). + */ + full?: boolean; + /** + * This value specifies a positive number that scales the size of the resultant image. + */ + scale?: number; + /** + * Specifies the scale automatically in combination with maxHeight such that the resultant image is no wider than maxWidth. + */ + maxWidth?: number; + /** + * Specifies the scale automatically in combination with maxWidth such that the resultant image is no taller than maxHeight. + */ + maxHeight?: number; + } + + interface BoundingBoxOptions { + /** + * A boolean indicating whether to include nodes in the bounding box. + */ + includeNodes: boolean; + /** + * A boolean indicating whether to include edges in the bounding box. + */ + includeEdges: boolean; + /** + * A boolean indicating whether to include labels in the bounding box. + */ + includeLabels: boolean; + /** + * A boolean indicating whether to include shadows in the bounding box (default true). + */ + + includeShadows: boolean + } + + interface ZoomOptions { + /** + * The zoom level to set. + */ + level: number; + /** + * The position about which to zoom. + */ + position?: Position; + /** + * The rendered position about which to zoom. + */ + renderedPosition?: Position; + } + + interface Static { + (options?: CytoscapeOptions): Instance; + (extensionName: string, foo: string, bar: any): Instance; + version: string; + + Promise<T>(): Cy.Promise<T>; + } + + enum PromiseState { + STATE_PENDING = 0, + STATE_FULFILLED = 1, + STATE_REJECTED = 2 + + } + + interface Promise<T> { + id: string; + state: PromiseState; + fulfillValue: T; + rejectReason: any; + onFulfilled: any[]; + onRejected: any[]; + + fulfill(value: T): Promise<T>; + reject(error: any): Promise<any>; + then<U>(onFulfilled?: (value: T) => U | Promise<U>, onRejected?: (error: any) => U | Promise<U>): Promise<U>; + then<U>(onFulfilled?: (value: T) => U | Promise<U>, onRejected?: (error: any) => void): Promise<U>; + } +} + +declare module "cytoscape" { + export = cytoscape; +} + +declare var cytoscape: Cy.Static;
\ No newline at end of file diff --git a/catalog-ui/typings/cytoscape/edge-editation.d.ts b/catalog-ui/typings/cytoscape/edge-editation.d.ts new file mode 100644 index 0000000000..e5ebd709b2 --- /dev/null +++ b/catalog-ui/typings/cytoscape/edge-editation.d.ts @@ -0,0 +1,28 @@ +/** + * Created by obarda on 11/6/2016. + */ + +interface CytoscapeEdgeEditation { + new(): CytoscapeEdgeEditation; + + init(cy: Cy.Instance, handleSize?: number):void; + registerHandle(handle: Handle): void; +} + +interface Handle { + positionX: string, + positionY: string, + offsetX?: number, + offsetY?: number, + color: string, + type: string, + single: boolean, + nodeTypeNames: Array<string>; + imageUrl: string; + lineWidth: number; + lineStyle: string; +} + +declare var CytoscapeEdgeEditation: CytoscapeEdgeEditation; + +declare function require(name:string);
\ No newline at end of file diff --git a/catalog-ui/typings/d3/d3.d.ts b/catalog-ui/typings/d3/d3.d.ts new file mode 100644 index 0000000000..ff4335106c --- /dev/null +++ b/catalog-ui/typings/d3/d3.d.ts @@ -0,0 +1,3308 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ +// Type definitions for d3JS +// Project: http://d3js.org/ +// Definitions by: Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov> +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +declare module d3 { + /** + * The current version of D3.js. + */ + export var version: string; + + /** + * Find the first element that matches the given selector string. + */ + export function select(selector: string): Selection<any>; + + /** + * Create a selection from the given node reference. + */ + export function select(node: EventTarget): Selection<any>; + + /** + * Find all elements that match the given selector string. + */ + export function selectAll(selector: string): Selection<any>; + + /** + * Create a selection from the given list of nodes. + */ + export function selectAll(nodes: EventTarget[]): Selection<any>; + + /** + * Returns the root selection (as if by d3.select(document.documentElement)). This function may be used for 'instanceof' tests, and extending its prototype will add properties to all selections. + */ + export function selection(): Selection<any>; + + module selection { + export var prototype: Selection<any>; + + /** + * Selections are grouped into arrays of nodes, with the parent tracked in the 'parentNode' property. + */ + interface Group extends Array<EventTarget> { + parentNode: EventTarget; + } + + interface Update<Datum> { + /** + * Retrieve a grouped selection. + */ + [index: number]: Group; + + /** + * The number of groups in this selection. + */ + length: number; + + /** + * Retrieve the value of the given attribute for the first node in the selection. + * + * @param name The attribute name to query. May be prefixed (see d3.ns.prefix). + */ + attr(name: string): string; + + /** + * For all nodes, set the attribute to the specified constant value. Use null to remove. + * + * @param name The attribute name, optionally prefixed. + * @param value The attribute value to use. Note that this is coerced to a string automatically. + */ + attr(name: string, value: Primitive): Update<Datum>; + + /** + * Derive an attribute value for each node in the selection based on bound data. + * + * @param name The attribute name, optionally prefixed. + * @param value The function of the datum (the bound data item) and index (the position in the subgrouping) which computes the attribute value. If the function returns null, the attribute is removed. + */ + attr(name: string, value: (datum: Datum, index: number) => Primitive): Update<Datum>; + + /** + * Set multiple properties at once using an Object. D3 iterates over all enumerable properties and either sets or computes the attribute's value based on the corresponding entry in the Object. + * + * @param obj A key-value mapping corresponding to attributes and values. If the value is a simple string or number, it is taken as a constant. Otherwise, it is a function that derives the attribute value. + */ + attr(obj: { [key: string]: Primitive | ((datum: Datum, index: number) => Primitive) }): Update<Datum>; + + /** + * Returns true if the first node in this selection has the given class list. If multiple classes are specified (i.e., "foo bar"), then returns true only if all classes match. + * + * @param name The class list to query. + */ + classed(name: string): boolean; + + /** + * Adds (or removes) the given class list. + * + * @param name The class list to toggle. Spaces separate class names: "foo bar" is a list of two classes. + * @param value If true, add the classes. If false, remove them. + */ + classed(name: string, value: boolean): Update<Datum>; + + /** + * Determine if the given class list should be toggled for each node in the selection. + * + * @param name The class list. Spaces separate multiple class names. + * @param value The function to run for each node. Should return true to add the class to the node, or false to remove it. + */ + classed(name: string, value: (datum: Datum, index: number) => boolean): Update<Datum>; + + /** + * Set or derive classes for multiple class lists at once. + * + * @param obj An Object mapping class lists to values that are either plain booleans or functions that return booleans. + */ + classed(obj: { [key: string]: boolean | ((datum: Datum, index: number) => boolean) }): Update<Datum>; + + /** + * Retrieve the computed style value for the first node in the selection. + * @param name The CSS property name to query + */ + style(name: string): string; + + /** + * Set a style property for all nodes in the selection. + * @param name the CSS property name + * @param value the property value + * @param priority if specified, either null or the string "important" (no exclamation mark) + */ + style(name: string, value: Primitive, priority?: string): Update<Datum>; + + /** + * Derive a property value for each node in the selection. + * @param name the CSS property name + * @param value the function to derive the value + * @param priority if specified, either null or the string "important" (no exclamation mark) + */ + style(name: string, value: (datum: Datum, index: number) => Primitive, priority?: string): Update<Datum>; + + /** + * Set a large number of CSS properties from an object. + * + * @param obj an Object whose keys correspond to CSS property names and values are either constants or functions that derive property values + * @param priority if specified, either null or the string "important" (no exclamation mark) + */ + style(obj: { [key: string]: Primitive | ((datum: Datum, index: number) => Primitive) }, priority?: string): Update<Datum>; + + /** + * Retrieve an arbitrary node property such as the 'checked' property of checkboxes, or the 'value' of text boxes. + * + * @param name the node's property to retrieve + */ + property(name: string): any; + + /** + * For each node, set the property value. Internally, this sets the node property directly (e.g., node[name] = value), so take care not to mutate special properties like __proto__. + * + * @param name the property name + * @param value the property value + */ + property(name: string, value: any): Update<Datum>; + + /** + * For each node, derive the property value. Internally, this sets the node property directly (e.g., node[name] = value), so take care not to mutate special properties like __proto__. + * + * @param name the property name + * @param value the function used to derive the property's value + */ + property(name: string, value: (datum: Datum, index: number) => any): Update<Datum>; + + /** + * Set multiple node properties. Caveats apply: take care not to mutate special properties like __proto__. + * + * @param obj an Object whose keys correspond to node properties and values are either constants or functions that will compute a value. + */ + property(obj: { [key: string]: any | ((datum: Datum, index: number) => any) }): Update<Datum>; + + /** + * Retrieve the textContent of the first node in the selection. + */ + text(): string; + + /** + * Set the textContent of each node in the selection. + * @param value the text to use for all nodes + */ + text(value: Primitive): Update<Datum>; + + /** + * Compute the textContent of each node in the selection. + * @param value the function which will compute the text + */ + text(value: (datum: Datum, index: number) => Primitive): Update<Datum>; + + /** + * Retrieve the HTML content of the first node in the selection. Uses 'innerHTML' internally and will not work with SVG or other elements without a polyfill. + */ + html(): string; + + /** + * Set the HTML content of every node in the selection. Uses 'innerHTML' internally and thus will not work with SVG or other elements without a polyfill. + * @param value the HTML content to use. + */ + html(value: string): Selection<Datum>; + + /** + * Compute the HTML content for each node in the selection. Uses 'innerHTML' internally and thus will not work with SVG or other elements without a polyfill. + * @param value the function to compute HTML content + */ + html(value: (datum: Datum, index: number) => string): Selection<Datum>; + + /** + * Appends a new child to each node in the selection. This child will inherit the parent's data (if available). Returns a fresh selection consisting of the newly-appended children. + * + * @param name the element name to append. May be prefixed (see d3.ns.prefix). + */ + append(name: string): Selection<Datum>; + + /** + * Appends a new child to each node in the selection by computing a new node. This child will inherit the parent's data (if available). Returns a fresh selection consisting of the newly-appended children. + * + * @param name the function to compute a new element + */ + append(name: (datum: Datum, index: number) => EventTarget): Update<Datum>; + + /** + * Inserts a new child to each node in the selection. This child will inherit its parent's data (if available). Returns a fresh selection consisting of the newly-inserted children. + * @param name the element name to append. May be prefixed (see d3.ns.prefix). + * @param before the selector to determine position (e.g., ":first-child") + */ + insert(name: string, before: string): Update<Datum>; + + /** + * Inserts a new child to each node in the selection. This child will inherit its parent's data (if available). Returns a fresh selection consisting of the newly-inserted children. + * @param name the element name to append. May be prefixed (see d3.ns.prefix). + * @param before a function to determine the node to use as the next sibling + */ + insert(name: string, before: (datum: Datum, index: number) => EventTarget): Update<Datum>; + + /** + * Inserts a new child to the end of each node in the selection by computing a new node. This child will inherit its parent's data (if available). Returns a fresh selection consisting of the newly-inserted children. + * @param name the function to compute a new child + * @param before the selector to determine position (e.g., ":first-child") + */ + insert(name: (datum: Datum, index: number) => EventTarget, before: string): Update<Datum>; + + /** + * Inserts a new child to the end of each node in the selection by computing a new node. This child will inherit its parent's data (if available). Returns a fresh selection consisting of the newly-inserted children. + * @param name the function to compute a new child + * @param before a function to determine the node to use as the next sibling + */ + insert(name: (datum: Datum, index: number) => EventTarget, before: (datum: Datum, index: number) => EventTarget): Update<Datum>; + + /** + * Removes the elements from the DOM. They are in a detached state and may be re-added (though there is currently no dedicated API for doing so). + */ + remove(): Update<Datum>; + + /** + * Retrieves the data bound to the first group in this selection. + */ + data(): Datum[]; + + /** + * Binds data to this selection. + * @param data the array of data to bind to this selection + * @param key the optional function to determine the unique key for each piece of data. When unspecified, uses the index of the element. + */ + data<NewDatum>(data: NewDatum[], key?: (datum: NewDatum, index: number) => string): Update<NewDatum>; + + /** + * Derives data to bind to this selection. + * @param data the function to derive data. Must return an array. + * @param key the optional function to determine the unique key for each data item. When unspecified, uses the index of the element. + */ + data<NewDatum>(data: (datum: Datum, index: number) => NewDatum[], key?: (datum: NewDatum, index: number) => string): Update<NewDatum>; + + /** + * Filters the selection, returning only those nodes that match the given CSS selector. + * @param selector the CSS selector + */ + filter(selector: string): Update<Datum>; + + /** + * Filters the selection, returning only those nodes for which the given function returned true. + * @param selector the filter function + */ + filter(selector: (datum: Datum, index: number) => boolean): Update<Datum>; + + /** + * Return the data item bound to the first element in the selection. + */ + datum(): Datum; + + /** + * Set the data item for each node in the selection. + * @param value the constant element to use for each node + */ + datum<NewDatum>(value: NewDatum): Update<NewDatum>; + + /** + * Derive the data item for each node in the selection. Useful for situations such as the HTML5 'dataset' attribute. + * @param value the function to compute data for each node + */ + datum<NewDatum>(value: (datum: Datum, index: number) => NewDatum): Update<NewDatum>; + + /** + * Reorders nodes in the selection based on the given comparator. Nodes are re-inserted into the document once sorted. + * @param comparator the comparison function, which defaults to d3.ascending + */ + sort(comparator?: (a: Datum, b: Datum) => number): Update<Datum>; + + /** + * Reorders nodes in the document to match the selection order. More efficient than calling sort() if the selection is already ordered. + */ + order(): Update<Datum>; + + /** + * Returns the listener (if any) for the given event. + * @param type the type of event to load the listener for. May have a namespace (e.g., ".foo") at the end. + */ + on(type: string): (datum: Datum, index: number) => any; + + /** + * Adds a listener for the specified event. If one was already registered, it is removed before the new listener is added. The return value of the listener function is ignored. + * @param type the of event to listen to. May have a namespace (e.g., ".foo") at the end. + * @param listener an event listener function, or null to unregister + * @param capture sets the DOM useCapture flag + */ + on(type: string, listener: (datum: Datum, index: number) => any, capture?: boolean): Update<Datum>; + + /** + * Begins a new transition. Interrupts any active transitions of the same name. + * @param name the transition name (defaults to "") + */ + transition(name?: string): Transition<Datum>; + + /** + * Interrupts the active transition of the provided name. Does not cancel scheduled transitions. + * @param name the transition name (defaults to "") + */ + interrupt(name?: string): Update<Datum>; + + /** + * Creates a subselection by finding the first descendent matching the selector string. Bound data is inherited. + * @param selector the CSS selector to match against + */ + select(selector: string): Update<Datum>; + + /** + * Creates a subselection by using a function to find descendent elements. Bound data is inherited. + * @param selector the function to find matching descendants + */ + select(selector: (datum: Datum, index: number) => EventTarget): Update<Datum>; + + /** + * Creates a subselection by finding all descendents that match the given selector. Bound data is not inherited. + * @param selector the CSS selector to match against + */ + selectAll(selector: string): Update<Datum>; + + /** + * Creates a subselection by using a function to find descendent elements. Bound data is not inherited. + * @param selector the function to find matching descendents + */ + selectAll(selector: (datum: Datum, index: number) => Array<EventTarget> | NodeList): Update<any>; + + /** + * Invoke the given function for each element in the selection. The return value of the function is ignored. + * @param func the function to invoke + */ + each(func: (datum: Datum, index: number) => any): Update<Datum>; + + /** + * Call a function on the selection. sel.call(foo) is equivalent to foo(sel). + * @param func the function to call on the selection + * @param args any optional args + */ + call(func: (sel: Update<Datum>, ...args: any[]) => any, ...args: any[]): Update<Datum>; + + /** + * Returns true if the current selection is empty. + */ + empty(): boolean; + + /** + * Returns the first non-null element in the selection, or null otherwise. + */ + node(): EventTarget; + + /** + * Returns the total number of elements in the selection. + */ + size(): number; + + /** + * Returns the placeholder nodes for each data element for which no corresponding DOM element was found. + */ + enter(): Enter<Datum>; + + /** + * Returns a selection for those DOM nodes for which no new data element was found. + */ + exit(): Selection<Datum>; + } + + interface Enter<Datum> { + append(name: string): Selection<Datum>; + append(name: (datum: Datum, index: number) => EventTarget): Selection<Datum>; + + insert(name: string, before?: string): Selection<Datum>; + insert(name: string, before: (datum: Datum, index: number) => EventTarget): Selection<Datum>; + insert(name: (datum: Datum, index: number) => EventTarget, before?: string): Selection<Datum>; + insert(name: (datum: Datum, index: number) => EventTarget, before: (datum: Datum, index: number) => EventTarget): Selection<Datum>; + + select(name: (datum: Datum, index: number) => EventTarget): Selection<Datum>; + call(func: (selection: Enter<Datum>, ...args: any[]) => any, ...args: any[]): Enter<Datum>; + } + } + + /** + * Administrivia: JavaScript primitive types, or "things that toString() predictably". + */ + export type Primitive = number | string | boolean; + + /** + * Administrivia: anything with a valueOf(): number method is comparable, so we allow it in numeric operations + */ + interface Numeric { + valueOf(): number; + } + + /** + * A grouped array of nodes. + * @param Datum the data bound to this selection. + */ + interface Selection<Datum> { + /** + * Retrieve a grouped selection. + */ + [index: number]: selection.Group; + + /** + * The number of groups in this selection. + */ + length: number; + + /** + * Retrieve the value of the given attribute for the first node in the selection. + * + * @param name The attribute name to query. May be prefixed (see d3.ns.prefix). + */ + attr(name: string): string; + + /** + * For all nodes, set the attribute to the specified constant value. Use null to remove. + * + * @param name The attribute name, optionally prefixed. + * @param value The attribute value to use. Note that this is coerced to a string automatically. + */ + attr(name: string, value: Primitive): Selection<Datum>; + + /** + * Derive an attribute value for each node in the selection based on bound data. + * + * @param name The attribute name, optionally prefixed. + * @param value The function of the datum (the bound data item) and index (the position in the subgrouping) which computes the attribute value. If the function returns null, the attribute is removed. + */ + attr(name: string, value: (datum: Datum, index: number) => Primitive): Selection<Datum>; + + /** + * Set multiple properties at once using an Object. D3 iterates over all enumerable properties and either sets or computes the attribute's value based on the corresponding entry in the Object. + * + * @param obj A key-value mapping corresponding to attributes and values. If the value is a simple string or number, it is taken as a constant. Otherwise, it is a function that derives the attribute value. + */ + attr(obj: { [key: string]: Primitive | ((datum: Datum, index: number) => Primitive) }): Selection<Datum>; + + /** + * Returns true if the first node in this selection has the given class list. If multiple classes are specified (i.e., "foo bar"), then returns true only if all classes match. + * + * @param name The class list to query. + */ + classed(name: string): boolean; + + /** + * Adds (or removes) the given class list. + * + * @param name The class list to toggle. Spaces separate class names: "foo bar" is a list of two classes. + * @param value If true, add the classes. If false, remove them. + */ + classed(name: string, value: boolean): Selection<Datum>; + + /** + * Determine if the given class list should be toggled for each node in the selection. + * + * @param name The class list. Spaces separate multiple class names. + * @param value The function to run for each node. Should return true to add the class to the node, or false to remove it. + */ + classed(name: string, value: (datum: Datum, index: number) => boolean): Selection<Datum>; + + /** + * Set or derive classes for multiple class lists at once. + * + * @param obj An Object mapping class lists to values that are either plain booleans or functions that return booleans. + */ + classed(obj: { [key: string]: boolean | ((datum: Datum, index: number) => boolean) }): Selection<Datum>; + + /** + * Retrieve the computed style value for the first node in the selection. + * @param name The CSS property name to query + */ + style(name: string): string; + + /** + * Set a style property for all nodes in the selection. + * @param name the CSS property name + * @param value the property value + * @param priority if specified, either null or the string "important" (no exclamation mark) + */ + style(name: string, value: Primitive, priority?: string): Selection<Datum>; + + /** + * Derive a property value for each node in the selection. + * @param name the CSS property name + * @param value the function to derive the value + * @param priority if specified, either null or the string "important" (no exclamation mark) + */ + style(name: string, value: (datum: Datum, index: number) => Primitive, priority?: string): Selection<Datum>; + + /** + * Set a large number of CSS properties from an object. + * + * @param obj an Object whose keys correspond to CSS property names and values are either constants or functions that derive property values + * @param priority if specified, either null or the string "important" (no exclamation mark) + */ + style(obj: { [key: string]: Primitive | ((datum: Datum, index: number) => Primitive) }, priority?: string): Selection<Datum>; + + /** + * Retrieve an arbitrary node property such as the 'checked' property of checkboxes, or the 'value' of text boxes. + * + * @param name the node's property to retrieve + */ + property(name: string): any; + + /** + * For each node, set the property value. Internally, this sets the node property directly (e.g., node[name] = value), so take care not to mutate special properties like __proto__. + * + * @param name the property name + * @param value the property value + */ + property(name: string, value: any): Selection<Datum>; + + /** + * For each node, derive the property value. Internally, this sets the node property directly (e.g., node[name] = value), so take care not to mutate special properties like __proto__. + * + * @param name the property name + * @param value the function used to derive the property's value + */ + property(name: string, value: (datum: Datum, index: number) => any): Selection<Datum>; + + /** + * Set multiple node properties. Caveats apply: take care not to mutate special properties like __proto__. + * + * @param obj an Object whose keys correspond to node properties and values are either constants or functions that will compute a value. + */ + property(obj: { [key: string]: any | ((datum: Datum, index: number) => any) }): Selection<Datum>; + + /** + * Retrieve the textContent of the first node in the selection. + */ + text(): string; + + /** + * Set the textContent of each node in the selection. + * @param value the text to use for all nodes + */ + text(value: Primitive): Selection<Datum>; + + /** + * Compute the textContent of each node in the selection. + * @param value the function which will compute the text + */ + text(value: (datum: Datum, index: number) => Primitive): Selection<Datum>; + + /** + * Retrieve the HTML content of the first node in the selection. Uses 'innerHTML' internally and will not work with SVG or other elements without a polyfill. + */ + html(): string; + + /** + * Set the HTML content of every node in the selection. Uses 'innerHTML' internally and thus will not work with SVG or other elements without a polyfill. + * @param value the HTML content to use. + */ + html(value: string): Selection<Datum>; + + /** + * Compute the HTML content for each node in the selection. Uses 'innerHTML' internally and thus will not work with SVG or other elements without a polyfill. + * @param value the function to compute HTML content + */ + html(value: (datum: Datum, index: number) => string): Selection<Datum>; + + /** + * Appends a new child to each node in the selection. This child will inherit the parent's data (if available). Returns a fresh selection consisting of the newly-appended children. + * + * @param name the element name to append. May be prefixed (see d3.ns.prefix). + */ + append(name: string): Selection<Datum>; + + /** + * Appends a new child to each node in the selection by computing a new node. This child will inherit the parent's data (if available). Returns a fresh selection consisting of the newly-appended children. + * + * @param name the function to compute a new element + */ + append(name: (datum: Datum, index: number) => EventTarget): Selection<Datum>; + + /** + * Inserts a new child to each node in the selection. This child will inherit its parent's data (if available). Returns a fresh selection consisting of the newly-inserted children. + * @param name the element name to append. May be prefixed (see d3.ns.prefix). + * @param before the selector to determine position (e.g., ":first-child") + */ + insert(name: string, before: string): Selection<Datum>; + + /** + * Inserts a new child to each node in the selection. This child will inherit its parent's data (if available). Returns a fresh selection consisting of the newly-inserted children. + * @param name the element name to append. May be prefixed (see d3.ns.prefix). + * @param before a function to determine the node to use as the next sibling + */ + insert(name: string, before: (datum: Datum, index: number) => EventTarget): Selection<Datum>; + + /** + * Inserts a new child to the end of each node in the selection by computing a new node. This child will inherit its parent's data (if available). Returns a fresh selection consisting of the newly-inserted children. + * @param name the function to compute a new child + * @param before the selector to determine position (e.g., ":first-child") + */ + insert(name: (datum: Datum, index: number) => EventTarget, before: string): Selection<Datum>; + + /** + * Inserts a new child to the end of each node in the selection by computing a new node. This child will inherit its parent's data (if available). Returns a fresh selection consisting of the newly-inserted children. + * @param name the function to compute a new child + * @param before a function to determine the node to use as the next sibling + */ + insert(name: (datum: Datum, index: number) => EventTarget, before: (datum: Datum, index: number) => EventTarget): Selection<Datum>; + + /** + * Removes the elements from the DOM. They are in a detached state and may be re-added (though there is currently no dedicated API for doing so). + */ + remove(): Selection<Datum>; + + /** + * Retrieves the data bound to the first group in this selection. + */ + data(): Datum[]; + + /** + * Binds data to this selection. + * @param data the array of data to bind to this selection + * @param key the optional function to determine the unique key for each piece of data. When unspecified, uses the index of the element. + */ + data<NewDatum>(data: NewDatum[], key?: (datum: NewDatum, index: number) => string): selection.Update<NewDatum>; + + /** + * Derives data to bind to this selection. + * @param data the function to derive data. Must return an array. + * @param key the optional function to determine the unique key for each data item. When unspecified, uses the index of the element. + */ + data<NewDatum>(data: (datum: Datum, index: number) => NewDatum[], key?: (datum: NewDatum, index: number) => string): selection.Update<NewDatum>; + + /** + * Filters the selection, returning only those nodes that match the given CSS selector. + * @param selector the CSS selector + */ + filter(selector: string): Selection<Datum>; + + /** + * Filters the selection, returning only those nodes for which the given function returned true. + * @param selector the filter function + */ + filter(selector: (datum: Datum, index: number) => boolean): Selection<Datum>; + + /** + * Return the data item bound to the first element in the selection. + */ + datum(): Datum; + + /** + * Derive the data item for each node in the selection. Useful for situations such as the HTML5 'dataset' attribute. + * @param value the function to compute data for each node + */ + datum<NewDatum>(value: (datum: Datum, index: number) => NewDatum): Selection<NewDatum>; + + /** + * Set the data item for each node in the selection. + * @param value the constant element to use for each node + */ + datum<NewDatum>(value: NewDatum): Selection<NewDatum>; + + /** + * Reorders nodes in the selection based on the given comparator. Nodes are re-inserted into the document once sorted. + * @param comparator the comparison function, which defaults to d3.ascending + */ + sort(comparator?: (a: Datum, b: Datum) => number): Selection<Datum>; + + /** + * Reorders nodes in the document to match the selection order. More efficient than calling sort() if the selection is already ordered. + */ + order(): Selection<Datum>; + + /** + * Returns the listener (if any) for the given event. + * @param type the type of event to load the listener for. May have a namespace (e.g., ".foo") at the end. + */ + on(type: string): (datum: Datum, index: number) => any; + + /** + * Adds a listener for the specified event. If one was already registered, it is removed before the new listener is added. The return value of the listener function is ignored. + * @param type the of event to listen to. May have a namespace (e.g., ".foo") at the end. + * @param listener an event listener function, or null to unregister + * @param capture sets the DOM useCapture flag + */ + on(type: string, listener: (datum: Datum, index: number) => any, capture?: boolean): Selection<Datum>; + + /** + * Begins a new transition. Interrupts any active transitions of the same name. + * @param name the transition name (defaults to "") + */ + transition(name?: string): Transition<Datum>; + + /** + * Interrupts the active transition of the provided name. Does not cancel scheduled transitions. + * @param name the transition name (defaults to "") + */ + interrupt(name?: string): Selection<Datum>; + + /** + * Creates a subselection by finding the first descendent matching the selector string. Bound data is inherited. + * @param selector the CSS selector to match against + */ + select(selector: string): Selection<Datum>; + + /** + * Creates a subselection by using a function to find descendent elements. Bound data is inherited. + * @param selector the function to find matching descendants + */ + select(selector: (datum: Datum, index: number) => EventTarget): Selection<Datum>; + + /** + * Creates a subselection by finding all descendents that match the given selector. Bound data is not inherited. + * @param selector the CSS selector to match against + */ + selectAll(selector: string): Selection<any>; + + /** + * Creates a subselection by finding all descendants that match the given selector. Bound data is not inherited. + * + * Use this overload when data-binding a subselection (that is, sel.selectAll('.foo').data(d => ...)). The type will carry over. + */ + selectAll<T>(selector: string): Selection<T>; + + /** + * Creates a subselection by using a function to find descendent elements. Bound data is not inherited. + * @param selector the function to find matching descendents + */ + selectAll(selector: (datum: Datum, index: number) => Array<EventTarget> | NodeList): Selection<any>; + + /** + * Creates a subselection by using a function to find descendent elements. Bound data is not inherited. + * + * Use this overload when data-binding a subselection (that is, sel.selectAll('.foo').data(d => ...)). The type will carry over. + * @param selector the function to find matching descendents + */ + selectAll<T>(selector: (datum: Datum, index: number) => Array<EventTarget> | NodeList): Selection<T>; + + /** + * Invoke the given function for each element in the selection. The return value of the function is ignored. + * @param func the function to invoke + */ + each(func: (datum: Datum, index: number) => any): Selection<Datum>; + + /** + * Call a function on the selection. sel.call(foo) is equivalent to foo(sel). + * @param func the function to call on the selection + * @param args any optional args + */ + call(func: (sel: Selection<Datum>, ...args: any[]) => any, ...args: any[]): Selection<Datum>; + + /** + * Returns true if the current selection is empty. + */ + empty(): boolean; + + /** + * Returns the first non-null element in the selection, or null otherwise. + */ + node(): EventTarget; + + /** + * Returns the total number of elements in the selection. + */ + size(): number; + } + + export function transition(): Transition<any>; + module transition { + export var prototype: Transition<any>; + } + + interface Transition<Datum> { + delay(): number; + delay(delay: number): Transition<Datum>; + delay(delay: (datum: Datum, index: number) => number): Transition<Datum>; + + duration(): number; + duration(duration: number): Transition<Datum>; + duration(duration: (datum: Datum, index: number) => number): Transition<Datum>; + + ease(): (t: number) => number; + ease(value: string, ...args: any[]): Transition<Datum>; + ease(value: (t: number) => number): Transition<Datum>; + + attr(name: string, value: Primitive): Transition<Datum>; + attr(name: string, value: (datum: Datum, index: number) => Primitive): Transition<Datum>; + attr(obj: { [key: string]: Primitive | ((datum: Datum, index: number) => Primitive) }): Transition<Datum>; + + attrTween(name: string, tween: (datum: Datum, index: number, attr: string) => Primitive): Transition<Datum>; + + style(name: string, value: Primitive, priority?: string): Transition<Datum>; + style(name: string, value: (datum: Datum, index: number) => Primitive, priority?: string): Transition<Datum>; + style(obj: { [key: string]: Primitive | ((datum: Datum, index: number) => Primitive) }, priority?: string): Transition<Datum>; + + styleTween(name: string, tween: (datum: Datum, index: number, attr: string) => Primitive, priority?: string): Transition<Datum>; + + text(value: Primitive): Transition<Datum>; + text(value: (datum: Datum, index: number) => Primitive): Transition<Datum>; + + tween(name: string, factory: () => (t: number) => any): Transition<Datum>; + + remove(): Transition<Datum>; + + select(selector: string): Transition<Datum>; + select(selector: (d: Datum, i: number) => EventTarget): Transition<Datum>; + + selectAll(selector: string): Transition<any>; + selectAll(selector: (d: Datum, i: number) => EventTarget[]): Transition<any>; + + filter(selector: string): Transition<Datum>; + filter(selector: (d: Datum, i: number) => boolean): Transition<Datum>; + + each(type: string, listener: (d: Datum, i: number) => any): Transition<Datum>; + each(listener: (d: Datum, i: number) => any): Transition<Datum>; + + call(func: (transition: Transition<Datum>, ...args: any[]) => any, ...args: any[]): Transition<Datum>; + + empty(): boolean; + node(): EventTarget; + size(): number; + } + + export function ease(type: 'linear'): (t: number) => number; + export function ease(type: 'linear-in'): (t: number) => number; + export function ease(type: 'linear-out'): (t: number) => number; + export function ease(type: 'linear-in-out'): (t: number) => number; + export function ease(type: 'linear-out-in'): (t: number) => number; + + export function ease(type: 'poly', k: number): (t: number) => number; + export function ease(type: 'poly-in', k: number): (t: number) => number; + export function ease(type: 'poly-out', k: number): (t: number) => number; + export function ease(type: 'poly-in-out', k: number): (t: number) => number; + export function ease(type: 'poly-out-in', k: number): (t: number) => number; + + export function ease(type: 'quad'): (t: number) => number; + export function ease(type: 'quad-in'): (t: number) => number; + export function ease(type: 'quad-out'): (t: number) => number; + export function ease(type: 'quad-in-out'): (t: number) => number; + export function ease(type: 'quad-out-in'): (t: number) => number; + + export function ease(type: 'cubic'): (t: number) => number; + export function ease(type: 'cubic-in'): (t: number) => number; + export function ease(type: 'cubic-out'): (t: number) => number; + export function ease(type: 'cubic-in-out'): (t: number) => number; + export function ease(type: 'cubic-out-in'): (t: number) => number; + + export function ease(type: 'sin'): (t: number) => number; + export function ease(type: 'sin-in'): (t: number) => number; + export function ease(type: 'sin-out'): (t: number) => number; + export function ease(type: 'sin-in-out'): (t: number) => number; + export function ease(type: 'sin-out-in'): (t: number) => number; + + export function ease(type: 'circle'): (t: number) => number; + export function ease(type: 'circle-in'): (t: number) => number; + export function ease(type: 'circle-out'): (t: number) => number; + export function ease(type: 'circle-in-out'): (t: number) => number; + export function ease(type: 'circle-out-in'): (t: number) => number; + + export function ease(type: 'elastic', a?: number, b?: number): (t: number) => number; + export function ease(type: 'elastic-in', a?: number, b?: number): (t: number) => number; + export function ease(type: 'elastic-out', a?: number, b?: number): (t: number) => number; + export function ease(type: 'elastic-in-out', a?: number, b?: number): (t: number) => number; + export function ease(type: 'elastic-out-in', a?: number, b?: number): (t: number) => number; + + export function ease(type: 'back', s: number): (t: number) => number; + export function ease(type: 'back-in', s: number): (t: number) => number; + export function ease(type: 'back-out', s: number): (t: number) => number; + export function ease(type: 'back-in-out', s: number): (t: number) => number; + export function ease(type: 'back-out-in', s: number): (t: number) => number; + + export function ease(type: 'bounce'): (t: number) => number; + export function ease(type: 'bounce-in'): (t: number) => number; + export function ease(type: 'bounce-out'): (t: number) => number; + export function ease(type: 'bounce-in-out'): (t: number) => number; + export function ease(type: 'bounce-out-in'): (t: number) => number; + + export function ease(type: string, ...args: any[]): (t: number) => number; + + export function timer(func: () => any, delay?: number, time?: number): void; + + module timer { + export function flush(): void; + } + + /** + * The current event's value. Use this variable in a handler registered with selection.on. + */ + export var event: Event; + + /** + * Returns the x and y coordinates of the mouse relative to the provided container element, using d3.event for the mouse's position on the page. + * @param container the container element (e.g. an SVG <g> element) + */ + export function mouse(container: EventTarget): [number, number]; + + /** + * Given a container element and a touch identifier, determine the x and y coordinates of the touch. + * @param container the container element (e.g., an SVG <svg> element) + * @param identifier the given touch identifier + */ + export function touch(container: EventTarget, identifer: number): [number, number]; + + /** + * Given a container element, a list of touches, and a touch identifier, determine the x and y coordinates of the touch. + * @param container the container element (e.g., an SVG <svg> element) + * @param identifier the given touch identifier + */ + export function touch(container: EventTarget, touches: TouchList, identifer: number): [number, number]; + + /** + * Given a container element and an optional list of touches, return the position of every touch relative to the container. + * @param container the container element + * @param touches an optional list of touches (defaults to d3.event.touches) + */ + export function touches(container: EventTarget, touches?: TouchList): Array<[number, number]>; + + // NB. this is limited to primitive values due to D3's use of the <, >, and >= operators. Results get weird for object instances. + /** + * Compares two primitive values for sorting (in ascending order). + */ + export function ascending(a: Primitive, b: Primitive): number; + + /** + * Compares two primitive values for sorting (in ascending order). + */ + export function descending(a: Primitive, b: Primitive): number; + + /** + * Return the minimum value in the array using natural order. + */ + export function min(array: number[]): number; + + /** + * Return the minimum value in the array using natural order. + */ + export function min(array: string[]): string; + + /** + * Return the minimum value in the array using natural order. + */ + export function min<T extends Numeric>(array: T[]): T; + + /** + * Return the minimum value in the array using natural order. + */ + export function min<T>(array: T[], accessor: (datum: T, index: number) => number): number; + + /** + * Return the minimum value in the array using natural order. + */ + export function min<T>(array: T[], accessor: (datum: T, index: number) => string): string; + + /** + * Return the minimum value in the array using natural order. + */ + export function min<T, U extends Numeric>(array: T[], accessor: (datum: T, index: number) => U): U; + + /** + * Return the maximum value in the array of numbers using natural order. + */ + export function max(array: number[]): number; + + /** + * Return the maximum value in the array of strings using natural order. + */ + export function max(array: string[]): string; + + /** + * Return the maximum value in the array of numbers using natural order. + */ + export function max<T extends Numeric>(array: T[]): T; + + /** + * Return the maximum value in the array using natural order and a projection function to map values to numbers. + */ + export function max<T>(array: T[], accessor: (datum: T, index: number) => number): number; + + /** + * Return the maximum value in the array using natural order and a projection function to map values to strings. + */ + export function max<T>(array: T[], accessor: (datum: T, index: number) => string): string; + + /** + * Return the maximum value in the array using natural order and a projection function to map values to easily-sorted values. + */ + export function max<T, U extends Numeric>(array: T[], accessor: (datum: T, index: number) => U): U; + + /** + * Return the min and max simultaneously. + */ + export function extent(array: number[]): [number, number]; + + /** + * Return the min and max simultaneously. + */ + export function extent(array: string[]): [string, string]; + + /** + * Return the min and max simultaneously. + */ + export function extent<T extends Numeric>(array: T[]): [T, T]; + + /** + * Return the min and max simultaneously. + */ + export function extent<T extends Numeric>(array: Array<T | Primitive>): [T | Primitive, T | Primitive]; + + /** + * Return the min and max simultaneously. + */ + export function extent<T>(array: T[], accessor: (datum: T, index: number) => number): [number, number]; + + /** + * Return the min and max simultaneously. + */ + export function extent<T>(array: T[], accessor: (datum: T, index: number) => string): [string, string]; + + /** + * Return the min and max simultaneously. + */ + export function extent<T, U extends Numeric>(array: U[], accessor: (datum: T, index: number) => U): [U | Primitive, U | Primitive]; + + /** + * Compute the sum of an array of numbers. + */ + export function sum(array: number[]): number; + + /** + * Compute the sum of an array, using the given accessor to convert values to numbers. + */ + export function sum<T>(array: T[], accessor: (datum: T, index: number) => number): number; + + export function mean(array: number[]): number; + export function mean<T>(array: T[], accessor: (datum: T, index: number) => number): number; + + export function quantile(array: number[], p: number): number; + + export function variance(array: number[]): number; + export function variance<T>(array: T[], accessor: (datum: T, index: number) => number): number; + + export function deviation(array: number[]): number; + export function deviation<T>(array: T[], accessor: (datum: T, index: number) => number): number; + + export function bisectLeft(array: number[], x: number, lo?: number, hi?: number): number; + export function bisectLeft(array: string[], x: string, lo?: number, hi?: number): number; + + export var bisect: typeof bisectRight; + + export function bisectRight<T>(array: T[], x: T, lo?: number, hi?: number): number; + + export function bisector<T, U>(accessor: (x: T) => U): { + left: (array: T[], x: T, lo?: number, hi?: number) => number; + right: (array: T[], x: T, lo?: number, hi?: number) => number; + } + + export function bisector<T, U>(comparator: (a: T, b: U) => number): { + left: (array: T[], x: U, lo?: number, hi?: number) => number; + right: (array: T[], x: U, lo?: number, hi?: number) => number; + } + + export function shuffle<T>(array: T[], lo?: number, hi?: number): T[]; + + /** + * Returns the enumerable property names of the specified object. + * @param object a JavaScript object + */ + export function keys(object: Object): string[]; + + /** + * Returns an array containing the property values of the specified object. + */ + export function values<T>(object: { [key: string]: T }): T[]; + /** + * Returns an array containing the property values of the specified object. + */ + export function values<T>(object: { [key: number]: T }): T[]; + /** + * Returns an array containing the property values of the specified object. + */ + export function values(object: Object): any[]; + + /** + * Returns an array of key-value pairs containing the property values of the specified object. + */ + export function entries<T>(object: { [key: string]: T }): { key: string; value: T }[]; + + /** + * Returns an array of key-value pairs containing the property values of the specified object. + */ + export function entries<T>(object: { [key: number]: T }): { key: string; value: T }[]; + + /** + * Returns an array of key-value pairs containing the property values of the specified object. + */ + export function entries(object: Object): { key: string; value: any }[]; + + /** + * A shim for ES6 maps. The implementation uses a JavaScript object internally, and thus keys are limited to strings. + */ + interface Map<T> { + /** + * Does the map contain the given key? + */ + has(key: string): boolean; + + /** + * Retrieve the value for the given key. Returns undefined if there is no value stored. + */ + get(key: string): T; + + /** + * Set the value for the given key. Returns the new value. + */ + set(key: string, value: T): T; + + /** + * Remove the value for the given key. Returns true if there was a value and false otherwise. + */ + remove(key: string): boolean; + + /** + * Returns an array of all keys in arbitrary order. + */ + keys(): string[]; + + /** + * Returns an array of all values in arbitrary order. + */ + values(): T[]; + + /** + * Returns an array of key-value objects in arbitrary order. + */ + entries(): { key: string; value: T }[]; + + /** + * Calls the function for each key and value pair in the map. The 'this' context is the map itself. + */ + forEach(func: (key: string, value: T) => any): void; + + /** + * Is this map empty? + */ + empty(): boolean; + + /** + * Returns the number of elements stored in the map. + */ + size(): number; + } + + /** + * Constructs an initially empty map. + */ + export function map<T>(): Map<T>; + + /** + * Construct a new map by copying keys and values from the given one. + */ + export function map<T>(object: Map<T>): Map<T>; + + /** + * Construct a new map by copying enumerable properties and values from the given object. + */ + export function map<T>(object: { [key: string]: T }): Map<T>; + + /** + * Construct a new map by copying enumerable properties and values from the given object. + */ + export function map<T>(object: { [key: number]: T }): Map<T>; + + /** + * Construct a new map by copying elements from the array. The key function is used to identify each object. + */ + export function map<T>(array: T[], key: (datum: T, index: number) => string): Map<T>; + + /** + * Construct a new map by copying enumerable properties and values from the given object. + */ + export function map(object: Object): Map<any>; + + /** + * A shim for ES6 sets. Is only able to store strings. + */ + interface Set { + /** + * Is the given string stored in this set? + */ + has(value: string): boolean; + + /** + * Add the string to this set. Returns the value. + */ + add(value: string): string; + + /** + * Remove the given value from the set. Returns true if it was stored, and false otherwise. + */ + remove(value: string): boolean; + + /** + * Returns an array of the strings stored in this set. + */ + values(): string[]; + + /** + * Calls a given function for each value in the set. The return value of the function is ignored. The this context of the function is the set itself. + */ + forEach(func: (value: string) => any): void; + + /** + * Is this set empty? + */ + empty(): boolean; + + /** + * Returns the number of values stored in this set. + */ + size(): number; + } + + /** + * Creates an initially-empty set. + */ + export function set(): Set; + + /** + * Initializes a set from the given array of strings. + */ + export function set(array: string[]): Set; + + /** + * Merges the specified arrays into a single array. + */ + export function merge<T>(arrays: T[][]): T[]; + + /** + * Generates a 0-based numeric sequence. The output range does not include 'stop'. + */ + export function range(stop: number): number[]; + + /** + * Generates a numeric sequence starting from the given start and stop values. 'step' defaults to 1. The output range does not include 'stop'. + */ + export function range(start: number, stop: number, step?: number): number[]; + + /** + * Given the specified array, return an array corresponding to the list of indices in 'keys'. + */ + export function permute<T>(array: { [key: number]: T }, keys: number[]): T[]; + + /** + * Given the specified object, return an array corresponding to the list of property names in 'keys'. + */ + export function permute<T>(object: { [key: string]: T }, keys: string[]): T[]; + + // TODO construct n-tuples from n input arrays + export function zip<T>(...arrays: T[][]): T[][]; + + export function transpose<T>(matrix: T[][]): T[][]; + + /** + * For each adjacent pair of elements in the specified array, returns a new array of tuples of elements i and i - 1. + * Returns the empty array if the input array has fewer than two elements. + */ + export function pairs<T>(array: T[]): Array<[T, T]>; + + interface Nest<T> { + key(func: (datum: T) => string): Nest<T>; + sortKeys(comparator: (a: string, b: string) => number): Nest<T>; + sortValues(comparator: (a: T, b: T) => number): Nest<T>; + rollup<U>(func: (values: T[]) => U): Nest<T>; + map(array: T[]): { [key: string]: any }; + map(array: T[], mapType: typeof d3.map): Map<any>; + entries(array: T[]): { key: string; values: any }[]; + } + + export function nest<T>(): Nest<T>; + + export module random { + export function normal(mean?: number, deviation?: number): () => number; + export function logNormal(mean?: number, deviation?: number): () => number; + export function bates(count: number): () => number; + export function irwinHall(count: number): () => number; + } + + interface Transform { + rotate: number; + translate: [number, number]; + skew: number; + scale: [number, number]; + toString(): string; + } + + export function transform(transform: string): Transform; + + export function format(specifier: string): (n: number) => string; + + interface FormatPrefix { + symbol: string; + scale(n: number): number; + } + + export function formatPrefix(value: number, precision?: number): FormatPrefix; + + export function round(x: number, n?: number): number; + + export function requote(string: string): string; + + export var rgb: { + new (r: number, g: number, b: number): Rgb; + new (color: string): Rgb; + + (r: number, g: number, b: number): Rgb; + (color: string): Rgb; + }; + + interface Rgb extends Color { + r: number; + g: number; + b: number; + + brighter(k?: number): Rgb; + darker(k?: number): Rgb; + + hsl(): Hsl; + + toString(): string; + } + + export var hsl: { + new (h: number, s: number, l: number): Hsl; + new (color: string): Hsl; + + (h: number, s: number, l: number): Hsl; + (color: string): Hsl; + }; + + interface Hsl extends Color { + h: number; + s: number; + l: number; + + brighter(k?: number): Hsl; + darker(k?: number): Hsl; + + rgb(): Rgb; + + toString(): string; + } + + export var hcl: { + new (h: number, c: number, l: number): Hcl; + new (color: string): Hcl; + + (h: number, c: number, l: number): Hcl; + (color: string): Hcl; + }; + + interface Hcl extends Color { + h: number; + c: number; + l: number; + + brighter(k?: number): Hcl; + darker(k?: number): Hcl; + } + + export var lab: { + new (l: number, a: number, b: number): Lab; + new (color: string): Lab; + + (l: number, a: number, b: number): Lab; + (color: string): Lab; + } + + interface Lab extends Color { + l: number; + a: number; + b: number; + + brighter(k?: number): Lab; + darker(k?: number): Lab; + + rgb(): Rgb; + toString(): string; + } + + export var color: { + (): Color; + new (): Color; + }; + + interface Color { + rgb(): Rgb; + } + + export module ns { + interface Qualified { + space: string; + local: string; + } + + export var prefix: { [key: string]: string }; + export function qualify(name: string): Qualified | string; + } + + export function functor<T extends Function>(value: T): T; + export function functor<T>(value: T): () => T; + + export function rebind(target: {}, source: {}, ...names: string[]): any; + + export function dispatch(...names: string[]): Dispatch; + + interface Dispatch { + on(type: string): (...args: any[]) => void; + on(type: string, listener: (...args: any[]) => any): Dispatch; + [event: string]: (...args: any[]) => void; + } + + export module scale { + export function identity(): Identity; + + interface Identity { + (n: number): number; + invert(n: number): number; + + domain(): number[]; + domain(numbers: number[]): Identity; + + range(): number[]; + range(numbers: number[]): Identity; + + ticks(count?: number): number[]; + + tickFormat(count?: number, format?: string): (n: number) => string; + + copy(): Identity; + } + + export function linear(): Linear<number, number>; + export function linear<Output>(): Linear<Output, Output>; + export function linear<Range, Output>(): Linear<Range, Output>; + + interface Linear<Range, Output> { + (x: number): Output; + invert(y: number): number; + + domain(): number[]; + domain(numbers: number[]): Linear<Range, Output>; + + range(): Range[]; + range(values: Range[]): Linear<Range, Output>; + + rangeRound(values: number[]): Linear<number, number>; + + interpolate(): (a: Range, b: Range) => (t: number) => Output; + interpolate(factory: (a: Range, b: Range) => (t: number) => Output): Linear<Range, Output>; + + clamp(): boolean; + clamp(clamp: boolean): Linear<Range, Output>; + + nice(count?: number): Linear<Range, Output>; + + ticks(count?: number): number[]; + + tickFormat(count?: number, format?: string): (n: number) => string; + + copy(): Linear<Range, Output>; + } + + export function sqrt(): Pow<number, number>; + export function sqrt<Output>(): Pow<Output, Output>; + export function sqrt<Range, Output>(): Pow<Range, Output>; + + export function pow(): Pow<number, number>; + export function pow<Output>(): Pow<Output, Output>; + export function pow<Range, Output>(): Pow<Range, Output>; + + interface Pow<Range, Output> { + (x: number): Output; + + invert(y: number): number; + + domain(): number[]; + domain(numbers: number[]): Pow<Range, Output>; + + range(): Range[]; + range(values: Range[]): Pow<Range, Output>; + + rangeRound(values: number[]): Pow<number, number>; + + exponent(): number; + exponent(k: number): Pow<Range, Output>; + + interpolate(): (a: Range, b: Range) => (t: number) => Output; + interpolate(factory: (a: Range, b: Range) => (t: number) => Output): Pow<Range, Output>; + + clamp(): boolean; + clamp(clamp: boolean): Pow<Range, Output>; + + nice(m?: number): Pow<Range, Output>; + + ticks(count?: number): number[]; + + tickFormat(count?: number, format?: string): (n: number) => string; + + copy(): Pow<Range, Output>; + } + + export function log(): Log<number, number>; + export function log<Output>(): Log<Output, Output>; + export function log<Range, Output>(): Log<Range, Output>; + + interface Log<Range, Output> { + (x: number): Output; + + invert(y: number): number; + + domain(): number[]; + domain(numbers: number[]): Log<Range, Output>; + + range(): Range[]; + range(values: Range[]): Log<Range, Output>; + + rangeRound(values: number[]): Log<number, number>; + + base(): number; + base(base: number): Log<Range, Output>; + + interpolate(): (a: Range, b: Range) => (t: number) => Output; + interpolate(factory: (a: Range, b: Range) => (t: number) => Output): Log<Range, Output>; + + clamp(): boolean; + clamp(clamp: boolean): Log<Range, Output>; + + nice(): Log<Range, Output>; + + ticks(): number[]; + + tickFormat(count?: number, format?: string): (t: number) => string; + + copy(): Log<Range, Output>; + } + + export function quantize<T>(): Quantize<T>; + + interface Quantize<T> { + (x: number): T; + + invertExtent(y: T): [number, number]; + + domain(): number[]; + domain(numbers: number[]): Quantize<T>; + + range(): T[]; + range(values: T[]): Quantize<T>; + + copy(): Quantize<T>; + } + + export function quantile<T>(): Quantile<T>; + + interface Quantile<T> { + (x: number): T; + + invertExtent(y: T): [number, number]; + + domain(): number[]; + domain(numbers: number[]): Quantile<T>; + + range(): T[]; + range(values: T[]): Quantile<T>; + + quantiles(): number[]; + + copy(): Quantile<T>; + } + + export function threshold<Range>(): Threshold<number, Range>; + export function threshold<Domain, Range>(): Threshold<Domain, Range>; + + interface Threshold<Domain, Range> { + (x: number): Range; + + invertExtent(y: Range): [Domain, Domain]; + + domain(): Domain[]; + domain(domain: Domain[]): Threshold<Domain, Range>; + + range(): Range[]; + range(values: Range[]): Threshold<Domain, Range>; + + copy(): Threshold<Domain, Range>; + } + + export function ordinal<Range>(): Ordinal<string, Range>; + export function ordinal<Domain extends { toString(): string }, Range>(): Ordinal<Domain, Range>; + export function category10(): Ordinal<string, string>; + export function category10<Domain extends { toString(): string }>(): Ordinal<Domain, string>; + export function category20(): Ordinal<string, string>; + export function category20<Domain extends { toString(): string }>(): Ordinal<Domain, string>; + export function category20b(): Ordinal<string, string>; + export function category20b<Domain extends { toString(): string }>(): Ordinal<Domain, string>; + export function category20c(): Ordinal<string,string>; + export function category20c<Domain extends { toString(): string }>(): Ordinal<Domain, string>; + + interface Ordinal<Domain extends { toString(): string }, Range> { + (x: Domain): Range; + + domain(): Domain[]; + domain(values: Domain[]): Ordinal<Domain, Range>; + + range(): Range[]; + range(values: Range[]): Ordinal<Domain, Range>; + + rangePoints(interval: [number, number], padding?: number): Ordinal<Domain, number>; + rangeRoundPoints(interval: [number, number], padding?: number): Ordinal<Domain, number>; + + rangeBands(interval: [number, number], padding?: number, outerPadding?: number): Ordinal<Domain, number>; + rangeRoundBands(interval: [number, number], padding?: number, outerPadding?: number): Ordinal<Domain, number>; + + rangeBand(): number; + rangeExtent(): [number, number]; + + copy(): Ordinal<Domain, Range>; + } + } + + export function interpolate(a: number, b: number): (t: number) => number; + export function interpolate(a: string, b: string): (t: number) => string; + export function interpolate(a: string | Color, b: Color): (t: number) => string; + export function interpolate(a: Array<string | Color>, b: Color[]): (t: number) => string; + export function interpolate<Range, Output>(a: Range[], b: Output[]): (t: number) => Output[]; + export function interpolate<Range, Output>(a: Range[], b: Range[]): (t: number) => Output[]; + export function interpolate(a: { [key: string]: string | Color }, b: { [key: string]: Color }): (t: number) => { [key: string]: string }; + export function interpolate<Range, Output>(a: { [key: string]: Range }, b: { [key: string]: Output }): (t: number) => { [key: string]: Output }; + export function interpolate<Range, Output>(a: { [key: string]: Range }, b: { [key: string]: Range }): (t: number) => { [key: string]: Output }; + + export function interpolateNumber(a: number, b: number): (t: number) => number; + + export function interpolateRound(a: number, b: number): (t: number) => number; + + export function interpolateString(a: string, b: string): (t: number) => string; + + export function interpolateRgb(a: string | Color, b: string | Color): (t: number) => string; + + export function interpolateHsl(a: string | Color, b: string | Color): (t: number) => string; + + export function interpolateLab(a: string | Color, b: string | Color): (t: number) => string; + + export function interpolateHcl(a: string | Color, b: string | Color): (t: number) => string; + + export function interpolateArray(a: Array<string | Color>, b: Color[]): (t: number) => string[]; + export function interpolateArray<Range, Output>(a: Range[], b: Range[]): (t: number) => Output[]; + export function interpolateArray<Range, Output>(a: Range[], b: Output[]): (t: number) => Output[]; + + export function interpolateObject(a: { [key: string]: string | Color }, b: { [key: string]: Color }): (t: number) => { [key: string]: string }; + export function interpolateObject<Range, Output>(a: { [key: string]: Range }, b: { [key: string]: Output }): (t: number) => { [key: string]: Output }; + export function interpolateObject<Range, Output>(a: { [key: string]: Range }, b: { [key: string]: Range }): (t: number) => { [key: string]: Output }; + + export function interpolateTransform(a: string | Transform, b: string | Transform): (t: number) => string; + + export function interpolateZoom(a: [number, number, number], b: [number, number, number]): { + (t: number): [number, number, number]; + duration: number; + }; + + export var interpolators: Array<(a: any, b: any) => (t: number) => any>; + + export module time { + export var second: Interval; + export var minute: Interval; + export var hour: Interval; + export var day: Interval; + export var week: Interval; + export var sunday: Interval; + export var monday: Interval; + export var tuesday: Interval; + export var wednesday: Interval; + export var thursday: Interval; + export var friday: Interval; + export var saturday: Interval; + export var month: Interval; + export var year: Interval; + + interface Interval { + (d: Date): Date; + + floor(d: Date): Date; + + round(d: Date): Date; + + ceil(d: Date): Date; + + range(start: Date, stop: Date, step?: number): Date[]; + + offset(date: Date, step: number): Date; + + utc: { + (d: Date): Date; + + floor(d: Date): Date; + + round(d: Date): Date; + + ceil(d: Date): Date; + + range(start: Date, stop: Date, step?: number): Date[]; + + offset(date: Date, step: number): Date; + } + } + + export function seconds(start: Date, stop: Date, step?: number): Date[]; + export function minutes(start: Date, stop: Date, step?: number): Date[]; + export function hours(start: Date, stop: Date, step?: number): Date[]; + export function days(start: Date, stop: Date, step?: number): Date[]; + export function weeks(start: Date, stop: Date, step?: number): Date[]; + export function sundays(start: Date, stop: Date, step?: number): Date[]; + export function mondays(start: Date, stop: Date, step?: number): Date[]; + export function tuesdays(start: Date, stop: Date, step?: number): Date[]; + export function wednesdays(start: Date, stop: Date, step?: number): Date[]; + export function thursdays(start: Date, stop: Date, step?: number): Date[]; + export function fridays(start: Date, stop: Date, step?: number): Date[]; + export function saturdays(start: Date, stop: Date, step?: number): Date[]; + export function months(start: Date, stop: Date, step?: number): Date[]; + export function years(start: Date, stop: Date, step?: number): Date[]; + + export function dayOfYear(d: Date): number; + export function weekOfYear(d: Date): number; + export function sundayOfYear(d: Date): number; + export function mondayOfYear(d: Date): number; + export function tuesdayOfYear(d: Date): number; + export function wednesdayOfYear(d: Date): number; + export function fridayOfYear(d: Date): number; + export function saturdayOfYear(d: Date): number; + + export function format(specifier: string): Format; + + export module format { + export function multi(formats: Array<[string, (d: Date) => boolean]>): Format; + export function utc(specifier: string): Format; + export var iso: Format; + } + + interface Format { + (d: Date): string; + parse(input: string): Date; + } + + export function scale(): Scale<number, number>; + export function scale<Output>(): Scale<Output, Output>; + export function scale<Range, Output>(): Scale<Range, Output>; + + export module scale { + export function utc(): Scale<number, number>; + export function utc<Output>(): Scale<Output, Output>; + export function utc<Range, Output>(): Scale<Range, Output>; + } + + + interface Scale<Range, Output> { + (x: Date): Output; + + invert(y: number): Date; + + domain(): Date[]; + domain(dates: number[]): Scale<Range, Output>; + domain(dates: Date[]): Scale<Range, Output>; + + nice(): Scale<Range, Output>; + nice(interval: Interval, step?: number): Scale<Range, Output>; + + range(): Range[]; + range(values: Range[]): Scale<Range, Output>; + + rangeRound(values: number[]): Scale<number, number>; + + interpolate(): (a: Range, b: Range) => (t: number) => Output; + interpolate(factory: (a: Range, b: Range) => (t: number) => Output): Scale<Range, Output>; + + clamp(): boolean; + clamp(clamp: boolean): Scale<Range, Output>; + + ticks(): Date[]; + ticks(interval: Interval, step?: number): Date[]; + ticks(count: number): Date[]; + + tickFormat(count: number): (d: Date) => string; + + copy(): Scale<Range, Output>; + } + } + + export module behavior { + export function drag<Datum>(): Drag<Datum>; + + interface Drag<Datum> { + (selection: Selection<Datum>): void; + + on(type: string): (d: Datum, i: number) => any; + on(type: string, listener: (d: Datum, i: number) => any): Drag<Datum>; + + origin(): (d: Datum, i: number) => { x: number; y: number }; + origin(accessor: (d: Datum, i: number) => { x: number; y: number }): Drag<Datum>; + } + + export function zoom<Datum>(): Zoom<Datum>; + + module zoom { + interface Scale { + domain(): number[]; + domain(values: number[]): Scale; + + invert(y: number): number; + + range(values: number[]): Scale; + range(): number[]; + } + } + + interface Zoom<Datum> { + (selection: Selection<Datum>): void; + + translate(): [number, number]; + translate(translate: [number, number]): Zoom<Datum>; + + scale(): number; + scale(scale: number): Zoom<Datum>; + + scaleExtent(): [number, number]; + scaleExtent(extent: [number, number]): Zoom<Datum>; + + center(): [number, number]; + center(center: [number, number]): Zoom<Datum>; + + size(): [number, number]; + size(size: [number, number]): Zoom<Datum>; + + x(): zoom.Scale; + x(x: zoom.Scale): Zoom<Datum>; + + y(): zoom.Scale; + y(y: zoom.Scale): Zoom<Datum>; + + on(type: string): (d: Datum, i: number) => any; + on(type: string, listener: (d: Datum, i: number) => any): Zoom<Datum>; + + event(selection: Selection<Datum>): void; + event(transition: Transition<Datum>): void; + } + } + + export module geo { + export function path(): Path; + + interface Path { + (feature: any, index?: number): string; + + area(feature: any): number; + + centroid(feature: any): [number, number]; + + bounds(feature: any): [[number, number], [number, number]]; + + projection(): Transform | ((coordinates: [number, number]) => [number, number]); + projection(stream: Transform): Path; + projection(projection: (coordinates: [number, number]) => [number, number]): Path; + + pointRadius(): number | ((datum: any, index: number) => number); + pointRadius(radius: number): Path; + pointRadius(radius: (datum: any, index: number) => number): Path; + + context(): CanvasRenderingContext2D; + context(context: CanvasRenderingContext2D): Path; + } + + export function graticule(): Graticule; + + interface Graticule { + (): any; + + lines(): any[]; + + outline(): any; + + extent(): [[number, number], [number, number]]; + extent(extent: [[number, number], [number, number]]): Graticule; + + majorExtent(): [[number, number], [number, number]]; + majorExtent(extent: [[number, number], [number, number]]): Graticule; + + minorExtent(): [[number, number], [number, number]]; + minorExtent(extent: [[number, number], [number, number]]): Graticule; + + step(): [number, number]; + step(step: [number, number]): Graticule; + + majorStep(): [number, number]; + majorStep(step: [number, number]): Graticule; + + minorStep(): [number, number]; + minorStep(step: [number, number]): Graticule; + + precision(): number; + precision(precision: number): Graticule; + } + + export function circle(): Circle; + + interface Circle { + (...args: any[]): any; + + origin(): [number, number] | ((...args: any[]) => [number, number]); + origin(origin: [number, number]): Circle; + origin(origin: (...args: any[]) => [number, number]): Circle; + + angle(): number; + angle(angle: number): Circle; + + precision(): number; + precision(precision: number): Circle; + } + + export function area(feature: any): number; + export function centroid(feature: any): [number, number]; + export function bounds(feature: any): [[number, number], [number, number]]; + export function distance(a: [number, number], b: [number, number]): number; + export function length(feature: any): number; + export function interpolate(a: [number, number], b: [number, number]): (t: number) => [number, number]; + + export function rotation(rotate: [number, number] | [number, number, number]): Rotation; + + interface Rotation { + (location: [number, number]): [number, number]; + invert(location: [number, number]): [number, number]; + } + + export function stream(object: any, listener: Listener): void; + + interface Listener { + point(x: number, y: number, z: number): void; + lineStart(): void; + lineEnd(): void; + polygonStart(): void; + polygonEnd(): void; + sphere(): void; + } + + export function transform(methods: TransformMethods): Transform; + + interface TransformMethods { + point?(x: number, y: number, z: number): void; + lineStart?(): void; + lineEnd?(): void; + polygonStart?(): void; + polygonEnd?(): void; + sphere?(): void; + } + + interface Transform { + stream(stream: Listener): Listener; + } + + export function clipExtent(): ClipExtent; + + interface ClipExtent extends Transform { + extent(): [[number, number], [number, number]]; + extent(extent: [[number, number], [number, number]]): ClipExtent; + } + + export function projection(raw: RawInvertibleProjection): InvertibleProjection; + export function projection(raw: RawProjection): Projection; + + export function projectionMutator(factory: (...args: any[]) => RawInvertibleProjection): (...args: any[]) => InvertibleProjection; + export function projectionMutator(factory: (...args: any[]) => RawProjection): (...args: any[]) => Projection; + + export function albers(): ConicProjection; + export function albersUsa(): ConicProjection; + export function azimuthalEqualArea(): InvertibleProjection; + module azimuthalEqualArea { + export function raw(lambda: number, phi: number): [number, number]; + module raw { + export function invert(x: number, y: number): [number, number]; + } + } + + export function azimuthalEquidistant(): InvertibleProjection; + module azimuthalEquidistant { + export function raw(lambda: number, phi: number): [number, number]; + module raw { + export function invert(x: number, y: number): [number, number]; + } + } + + export function conicConformal(): ConicProjection; + module conicConformal { + export function raw(phi0: number, phi1: number): RawInvertibleProjection; + } + + export function conicEqualArea(): ConicProjection; + module conicEqualArea { + export function raw(phi0: number, phi1: number): RawInvertibleProjection; + } + + export function conicEquidistant(): ConicProjection; + module conicEquidistant { + export function raw(phi0: number, phi1: number): RawInvertibleProjection; + } + + export function equirectangular(): InvertibleProjection; + module equirectangular { + export function raw(lambda: number, phi: number): [number, number]; + module raw { + export function invert(x: number, y: number): [number, number]; + } + } + + export function gnomonic(): InvertibleProjection; + module gnomonic { + export function raw(lambda: number, phi: number): [number, number]; + module raw { + export function invert(x: number, y: number): [number, number]; + } + } + + export function mercator(): InvertibleProjection; + module mercator { + export function raw(lambda: number, phi: number): [number, number]; + module raw { + export function invert(x: number, y: number): [number, number]; + } + } + + export function orthographic(): InvertibleProjection; + module orthographic { + export function raw(lambda: number, phi: number): [number, number]; + module raw { + export function invert(x: number, y: number): [number, number]; + } + } + + export function stereographic(): InvertibleProjection; + module stereographic { + export function raw(lambda: number, phi: number): [number, number]; + module raw { + export function invert(x: number, y: number): [number, number]; + } + } + + export function transverseMercator(): InvertibleProjection; + module transverseMercator { + export function raw(lambda: number, phi: number): [number, number]; + module raw { + export function invert(x: number, y: number): [number, number]; + } + } + + interface Projection { + (location: [number, number]): [number, number]; + + rotate(): [number, number, number]; + rotate(rotation: [number, number, number]): Projection; + + center(): [number, number]; + center(location: [number, number]): Projection; + + translate(): [number, number]; + translate(point: [number, number]): Projection; + + scale(): number; + scale(scale: number): Projection; + + clipAngle(): number; + clipAngle(angle: number): Projection; + + clipExtent(): [[number, number], [number, number]]; + clipExtent(extent: [[number, number], [number, number]]): Projection; + + precision(): number; + precision(precision: number): Projection; + + stream(listener: Listener): Listener; + } + + interface InvertibleProjection extends Projection { + invert(point: [number, number]): [number, number]; + } + + interface ConicProjection extends InvertibleProjection { + parallels(): [number, number]; + parallels(parallels: [number, number]): ConicProjection; + + rotate(): [number, number, number]; + rotate(rotation: [number, number, number]): ConicProjection; + + center(): [number, number]; + center(location: [number, number]): ConicProjection; + + translate(): [number, number]; + translate(point: [number, number]): ConicProjection; + + scale(): number; + scale(scale: number): ConicProjection; + + clipAngle(): number; + clipAngle(angle: number): ConicProjection; + + clipExtent(): [[number, number], [number, number]]; + clipExtent(extent: [[number, number], [number, number]]): ConicProjection; + + precision(): number; + precision(precision: number): ConicProjection; + } + + interface RawProjection { + (lambda: number, phi: number): [number, number]; + } + + interface RawInvertibleProjection extends RawProjection { + invert(x: number, y: number): [number, number]; + } + } + + module svg { + export function line(): Line<[number, number]>; + export function line<T>(): Line<T>; + + interface Line<T> { + (data: T[]): string; + + x(): number | ((d: T, i: number) => number); + x(x: number): Line<T>; + x(x: (d: T, i: number) => number): Line<T>; + + y(): number | ((d: T, i: number) => number); + y(x: number): Line<T>; + y(y: (d: T, i: number) => number): Line<T>; + + interpolate(): string | ((points: Array<[number, number]>) => string); + interpolate(interpolate: "linear"): Line<T>; + interpolate(interpolate: "linear-closed"): Line<T>; + interpolate(interpolate: "step"): Line<T>; + interpolate(interpolate: "step-before"): Line<T>; + interpolate(interpolate: "step-after"): Line<T>; + interpolate(interpolate: "basis"): Line<T>; + interpolate(interpolate: "basis-open"): Line<T>; + interpolate(interpolate: "basis-closed"): Line<T>; + interpolate(interpolate: "bundle"): Line<T>; + interpolate(interpolate: "cardinal"): Line<T>; + interpolate(interpolate: "cardinal-open"): Line<T>; + interpolate(interpolate: "cardinal-closed"): Line<T>; + interpolate(interpolate: "monotone"): Line<T>; + interpolate(interpolate: string): Line<T>; + interpolate(interpolate: (points: Array<[number, number]>) => string): Line<T>; + + tension(): number; + tension(tension: number): Line<T>; + + defined(): (d: T, i: number) => boolean; + defined(defined: (d: T, i: number) => boolean): Line<T>; + } + + module line { + export function radial(): Radial<[number, number]>; + export function radial<T>(): Radial<T>; + + interface Radial<T> { + (data: T[]): string; + + radius(): number | ((d: T, i: number) => number); + radius(radius: number): Radial<T>; + radius(radius: (d: T, i: number) => number): Radial<T>; + + angle(): number | ((d: T, i: number) => number); + angle(angle: number): Radial<T>; + angle(angle: (d: T, i: number) => number): Radial<T>; + + interpolate(): string | ((points: Array<[number, number]>) => string); + interpolate(interpolate: "linear"): Radial<T>; + interpolate(interpolate: "linear-closed"): Radial<T>; + interpolate(interpolate: "step"): Radial<T>; + interpolate(interpolate: "step-before"): Radial<T>; + interpolate(interpolate: "step-after"): Radial<T>; + interpolate(interpolate: "basis"): Radial<T>; + interpolate(interpolate: "basis-open"): Radial<T>; + interpolate(interpolate: "basis-closed"): Radial<T>; + interpolate(interpolate: "bundle"): Radial<T>; + interpolate(interpolate: "cardinal"): Radial<T>; + interpolate(interpolate: "cardinal-open"): Radial<T>; + interpolate(interpolate: "cardinal-closed"): Radial<T>; + interpolate(interpolate: "monotone"): Radial<T>; + interpolate(interpolate: string): Radial<T>; + interpolate(interpolate: (points: Array<[number, number]>) => string): Radial<T>; + + tension(): number; + tension(tension: number): Radial<T>; + + defined(): (d: T, i: number) => boolean; + defined(defined: (d: T, i: number) => boolean): Radial<T>; + } + } + + export function area(): Area<[number, number]>; + export function area<T>(): Area<T>; + + interface Area<T> { + (data: T[]): string; + + x(): number | ((d: T, i: number) => number); + x(x: number): Area<T>; + x(x: (d: T, i: number) => number): Area<T>; + + x0(): number | ((d: T, i: number) => number); + x0(x0: number): Area<T>; + x0(x0: (d: T, i: number) => number): Area<T>; + + x1(): number | ((d: T, i: number) => number); + x1(x1: number): Area<T>; + x1(x1: (d: T, i: number) => number): Area<T>; + + y(): number | ((d: T, i: number) => number); + y(y: number): Area<T>; + y(y: (d: T, i: number) => number): Area<T>; + + y0(): number | ((d: T, i: number) => number); + y0(y0: number): Area<T>; + y0(y0: (d: T, i: number) => number): Area<T>; + + y1(): number | ((d: T, i: number) => number); + y1(y1: number): Area<T>; + y1(y1: (d: T, i: number) => number): Area<T>; + + interpolate(): string | ((points: Array<[number, number]>) => string); + interpolate(interpolate: "linear"): Area<T>; + interpolate(interpolate: "step"): Area<T>; + interpolate(interpolate: "step-before"): Area<T>; + interpolate(interpolate: "step-after"): Area<T>; + interpolate(interpolate: "basis"): Area<T>; + interpolate(interpolate: "basis-open"): Area<T>; + interpolate(interpolate: "cardinal"): Area<T>; + interpolate(interpolate: "cardinal-open"): Area<T>; + interpolate(interpolate: "monotone"): Area<T>; + interpolate(interpolate: string): Area<T>; + + tension(): number; + tension(tension: number): Area<T>; + + defined(): (d: T, i: number) => boolean; + defined(defined: (d: T, i: number) => boolean): Area<T>; + } + + module area { + export function radial(): Radial<[number, number]>; + export function radial<T>(): Radial<T>; + + interface Radial<T> { + (data: T[]): string; + + radius(): number | ((d: T, i: number) => number); + radius(radius: number): Radial<T>; + radius(radius: (d: T, i: number) => number): Radial<T>; + + innerRadius(): number | ((d: T, i: number) => number); + innerRadius(innerRadius: number): Radial<T>; + innerRadius(innerRadius: (d: T, i: number) => number): Radial<T>; + + outerRadius(): number | ((d: T, i: number) => number); + outerRadius(outerRadius: number): Radial<T>; + outerRadius(outerRadius: (d: T, i: number) => number): Radial<T>; + + angle(): number | ((d: T, i: number) => number); + angle(angle: number): Radial<T>; + angle(angle: (d: T, i: number) => number): Radial<T>; + + startAngle(): number | ((d: T, i: number) => number); + startAngle(startAngle: number): Radial<T>; + startAngle(startAngle: (d: T, i: number) => number): Radial<T>; + + endAngle(): number | ((d: T, i: number) => number); + endAngle(endAngle: number): Radial<T>; + endAngle(endAngle: (d: T, i: number) => number): Radial<T>; + + interpolate(): string | ((points: Array<[number, number]>) => string); + interpolate(interpolate: "linear"): Radial<T>; + interpolate(interpolate: "step"): Radial<T>; + interpolate(interpolate: "step-before"): Radial<T>; + interpolate(interpolate: "step-after"): Radial<T>; + interpolate(interpolate: "basis"): Radial<T>; + interpolate(interpolate: "basis-open"): Radial<T>; + interpolate(interpolate: "cardinal"): Radial<T>; + interpolate(interpolate: "cardinal-open"): Radial<T>; + interpolate(interpolate: "monotone"): Radial<T>; + interpolate(interpolate: string): Radial<T>; + interpolate(interpolate: (points: Array<[number, number]>) => string): Radial<T>; + + tension(): number; + tension(tension: number): Radial<T>; + + defined(): (d: T, i: number) => boolean; + defined(defined: (d: T, i: number) => boolean): Radial<T>; + } + } + + export function arc(): Arc<arc.Arc>; + export function arc<T>(): Arc<T>; + + module arc { + interface Arc { + innerRadius: number; + outerRadius: number; + startAngle: number; + endAngle: number; + padAngle: number + } + } + + interface Arc<T> { + (d: T, i: number): string; + + innerRadius(): (d: T, i: number) => number; + innerRadius(radius: number): Arc<T>; + innerRadius(radius: (d: T, i: number) => number): Arc<T>; + + outerRadius(): (d: T, i: number) => number; + outerRadius(radius: number): Arc<T>; + outerRadius(radius: (d: T, i: number) => number): Arc<T>; + + cornerRadius(): (d: T, i: number) => number; + cornerRadius(radius: number): Arc<T>; + cornerRadius(radius: (d: T, i: number) => number): Arc<T>; + + padRadius(): string | ((d: T, i: number) => number); + padRadius(radius: "auto"): Arc<T>; + padRadius(radius: string): Arc<T>; + padRadius(radius: (d: T, i: number) => number): Arc<T>; + + startAngle(): (d: T, i: number) => number; + startAngle(angle: number): Arc<T>; + startAngle(angle: (d: T, i: number) => number): Arc<T>; + + endAngle(): (d: T, i: number) => number; + endAngle(angle: number): Arc<T>; + endAngle(angle: (d: T, i: number) => number): Arc<T>; + + padAngle(): (d: T, i: number) => number; + padAngle(angle: number): Arc<T>; + padAngle(angle: (d: T, i: number) => number): Arc<T>; + + centroid(d: T, i?: number): [number, number]; + } + + export function symbol(): Symbol<{}>; + export function symbol<T>(): Symbol<T>; + + interface Symbol<T> { + (d: T, i?: number): string; + + type(): (d: T, i: number) => string; + type(type: string): Symbol<T>; + type(type: (d: T, i: number) => string): Symbol<T>; + + size(): (d: T, i: string) => number; + size(size: number): Symbol<T>; + size(size: (d: T, i: number) => number): Symbol<T>; + } + + export var symbolTypes: string[]; + + export function chord(): Chord<chord.Link<chord.Node>, chord.Node>; + export function chord<Node>(): Chord<chord.Link<Node>, Node>; + export function chord<Link, Node>(): Chord<Link, Node>; + + module chord { + interface Link<Node> { + source: Node; + target: Node; + } + + interface Node { + radius: number; + startAngle: number; + endAngle: number + } + } + + interface Chord<Link, Node> { + (d: Link, i: number): string; + + source(): (d: Link, i: number) => Node; + source(source: Node): Chord<Link, Node>; + source(source: (d: Link, i: number) => Node): Chord<Link, Node>; + + target(): (d: Link, i: number) => Node; + target(target: Node): Chord<Link, Node>; + target(target: (d: Link, i: number) => Node): Chord<Link, Node>; + + radius(): (d: Node, i: number) => number; + radius(radius: number): Chord<Link, Node>; + radius(radius: (d: Node, i: number) => number): Chord<Link, Node>; + + startAngle(): (d: Node, i: number) => number; + startAngle(angle: number): Chord<Link, Node>; + startAngle(angle: (d: Node, i: number) => number): Chord<Link, Node>; + + endAngle(): (d: Node, i: number) => number; + endAngle(angle: number): Chord<Link, Node>; + endAngle(angle: (d: Node, i: number) => number): Chord<Link, Node>; + } + + export function diagonal(): Diagonal<diagonal.Link<diagonal.Node>, diagonal.Node>; + export function diagonal<Node>(): Diagonal<diagonal.Link<Node>, Node>; + export function diagonal<Link, Node>(): Diagonal<Link, Node>; + + module diagonal { + interface Link<Node> { + source: Node; + target: Node; + } + + interface Node { + x: number; + y: number; + } + } + + interface Diagonal<Link, Node> { + (d: Link, i: number): string; + + source(): (d: Link, i: number) => Node; + source(source: Node): Diagonal<Link, Node>; + source(source: (d: Link, i: number) => Node): Diagonal<Link, Node>; + + target(): (d: Link, i: number) => Node; + target(target: Node): Diagonal<Link, Node>; + target(target: (d: Link, i: number) => Node): Diagonal<Link, Node>; + + projection(): (d: Node, i: number) => [number, number]; + projection(projection: (d: Node, i: number) => [number, number]): Diagonal<Link, Node>; + } + + module diagonal { + export function radial(): Radial<Link<Node>, Node>; + export function radial<Node>(): Radial<Link<Node>, Node>; + export function radial<Link, Node>(): Radial<Link, Node>; + + interface Radial<Link, Node> { + (d: Link, i: number): string; + + source(): (d: Link, i: number) => Node; + source(source: Node): Radial<Link, Node>; + source(source: (d: Link, i: number) => Node): Radial<Link, Node>; + + target(): (d: Link, i: number) => Node; + target(target: Node): Radial<Link, Node>; + target(target: (d: Link, i: number) => Node): Radial<Link, Node>; + + projection(): (d: Node, i: number) => [number, number]; + projection(projection: (d: Node, i: number) => [number, number]): Radial<Link, Node>; + } + } + + export function axis(): Axis; + + interface Axis { + (selection: Selection<any>): void; + (selection: Transition<any>): void; + + scale(): any; + scale(scale: any): Axis; + + orient(): string; + orient(orientation: string): Axis; + + ticks(): any[]; + ticks(...args: any[]): Axis; + + tickValues(): any[]; + tickValues(values: any[]): Axis; + + tickSize(): number; + tickSize(size: number): Axis; + tickSize(inner: number, outer: number): Axis; + + innerTickSize(): number; + innerTickSize(size: number): Axis; + + outerTickSize(): number; + outerTickSize(size: number): Axis; + + tickPadding(): number; + tickPadding(padding: number): Axis; + + tickFormat(): (t: any) => string; + tickFormat(format: (t: any) => string): Axis; + } + + export function brush(): Brush<any>; + export function brush<T>(): Brush<T>; + + module brush { + interface Scale { + domain(): number[]; + domain(domain: number[]): Scale; + + range(): number[]; + range(range: number[]): Scale; + + invert?(y: number): number; + } + } + + interface Brush<T> { + (selection: Selection<T>): void; + (selection: Transition<T>): void; + + event(selection: Selection<T>): void; + event(selection: Transition<T>): void; + + x(): brush.Scale; + x(x: brush.Scale): Brush<T>; + + y(): brush.Scale; + y(y: brush.Scale): Brush<T>; + + extent(): [number, number] | [[number, number], [number, number]]; + extent(extent: [number, number] | [[number, number], [number, number]]): Brush<T>; + + clamp(): boolean | [boolean, boolean]; + clamp(clamp: boolean | [boolean, boolean]): Brush<T>; + + clear(): void; + + empty(): boolean; + + on(type: 'brushstart'): (datum: T, index: number) => void; + on(type: 'brush'): (datum: T, index: number) => void; + on(type: 'brushend'): (datum: T, index: number) => void; + on(type: string): (datum: T, index: number) => void; + + on(type: 'brushstart', listener: (datum: T, index: number) => void): Brush<T>; + on(type: 'brush', listener: (datum: T, index: number) => void): Brush<T>; + on(type: 'brushend', listener: (datum: T, index: number) => void): Brush<T>; + on(type: string, listener: (datum: T, index: number) => void): Brush<T>; + } + } + + export function xhr(url: string, mimeType?: string, callback?: (err: any, data: any) => void): Xhr; + export function xhr(url: string, callback: (err: any, data: any) => void): Xhr; + + interface Xhr { + header(name: string): string; + header(name: string, value: string): Xhr; + + mimeType(): string; + mimeType(type: string): Xhr; + + responseType(): string; + responseType(type: string): Xhr; + + response(): (request: XMLHttpRequest) => any; + response(value: (request: XMLHttpRequest) => any): Xhr; + + get(callback?: (err: any, data: any) => void): Xhr; + + post(data?: any, callback?: (err: any, data: any) => void): Xhr; + post(callback: (err: any, data: any) => void): Xhr; + + send(method: string, data?: any, callback?: (err: any, data: any) => void): Xhr; + send(method: string, callback: (err: any, data: any) => void): Xhr; + + abort(): Xhr; + + on(type: "beforesend"): (request: XMLHttpRequest) => void; + on(type: "progress"): (request: XMLHttpRequest) => void; + on(type: "load"): (response: any) => void; + on(type: "error"): (err: any) => void; + on(type: string): (...args: any[]) => void; + + on(type: "beforesend", listener: (request: XMLHttpRequest) => void): Xhr; + on(type: "progress", listener: (request: XMLHttpRequest) => void): Xhr; + on(type: "load", listener: (response: any) => void): Xhr; + on(type: "error", listener: (err: any) => void): Xhr; + on(type: string, listener: (...args: any[]) => void): Xhr; + } + + export function text(url: string, mimeType?: string, callback?: (err: any, data: string) => void): Xhr; + export function text(url: string, callback: (err: any, data: string) => void): Xhr; + + export function json(url: string, callback?: (err: any, data: any) => void): Xhr; + + export function xml(url: string, mimeType?: string, callback?: (err: any, data: any) => void): Xhr; + export function xml(url: string, callback: (err: any, data: any) => void): Xhr; + + export function html(url: string, callback?: (err: any, data: DocumentFragment) => void): Xhr; + + export var csv: Dsv; + export var tsv: Dsv; + export function dsv(delimiter: string, mimeType: string): Dsv; + + interface Dsv { + (url: string, callback: (rows: { [key: string]: string }[]) => void): DsvXhr<{ [key: string]: string }>; + (url: string, callback: (error: any, rows: { [key: string]: string }[]) => void): DsvXhr<{ [key: string]: string }>; + (url: string): DsvXhr<{ [key: string]: string }>; + <T>(url: string, accessor: (row: { [key: string]: string }) => T, callback: (rows: T[]) => void): DsvXhr<T>; + <T>(url: string, accessor: (row: { [key: string]: string }) => T, callback: (error: any, rows: T[]) => void): DsvXhr<T>; + <T>(url: string, accessor: (row: { [key: string]: string }) => T): DsvXhr<T>; + + parse(string: string): { [key: string]: string }[]; + parse<T>(string: string, accessor: (row: { [key: string]: string }, index: number) => T): T[]; + + parseRows(string: string): string[][]; + parseRows<T>(string: string, accessor: (row: string[], index: number) => T): T[]; + + format(rows: Object[]): string; + + formatRows(rows: string[][]): string; + } + + interface DsvXhr<T> extends Xhr { + row(): (row: { [key: string]: string }) => T; + row<U>(accessor: (row: { [key: string]: string }) => U): DsvXhr<U>; + + header(name: string): string; + header(name: string, value: string): DsvXhr<T>; + + mimeType(): string; + mimeType(type: string): DsvXhr<T>; + + responseType(): string; + responseType(type: string): DsvXhr<T>; + + response(): (request: XMLHttpRequest) => any; + response(value: (request: XMLHttpRequest) => any): DsvXhr<T>; + + get(callback?: (err: any, data: T) => void): DsvXhr<T>; + post(data?: any, callback?: (err: any, data: T) => void): DsvXhr<T>; + post(callback: (err: any, data: T) => void): DsvXhr<T>; + + send(method: string, data?: any, callback?: (err: any, data: T) => void): DsvXhr<T>; + send(method: string, callback: (err: any, data: T) => void): DsvXhr<T>; + + abort(): DsvXhr<T>; + + on(type: "beforesend"): (request: XMLHttpRequest) => void; + on(type: "progress"): (request: XMLHttpRequest) => void; + on(type: "load"): (response: T) => void; + on(type: "error"): (err: any) => void; + on(type: string): (...args: any[]) => void; + + on(type: "beforesend", listener: (request: XMLHttpRequest) => void): DsvXhr<T>; + on(type: "progress", listener: (request: XMLHttpRequest) => void): DsvXhr<T>; + on(type: "load", listener: (response: T) => void): DsvXhr<T>; + on(type: "error", listener: (err: any) => void): DsvXhr<T>; + on(type: string, listener: (...args: any[]) => void): DsvXhr<T>; + } + + export function locale(definition: LocaleDefinition): Locale; + + interface LocaleDefinition { + decimal: string; + thousands: string; + grouping: number[]; + currency: [string, string]; + dateTime: string; + date: string; + time: string; + periods: [string, string]; + days: [string, string, string, string, string, string, string]; + shortDays: [string, string, string, string, string, string, string]; + months: [string, string, string, string, string, string, string, string, string, string, string, string]; + shortMonths: [string, string, string, string, string, string, string, string, string, string, string, string]; + } + + interface Locale { + numberFormat(specifier: string): (n: number) => string; + timeFormat: { + (specifier: string): time.Format; + utc(specifier: string): time.Format; + } + } + + module layout { + export function bundle(): Bundle<bundle.Node>; + export function bundle<T extends bundle.Node>(): Bundle<T> + + module bundle { + interface Node { + parent: Node; + } + + interface Link<T extends Node> { + source: T; + target: T; + } + } + + interface Bundle<T extends bundle.Node> { + (links: bundle.Link<T>[]): T[][]; + } + + export function chord(): Chord; + + module chord { + interface Link { + source: Node; + target: Node; + } + + interface Node { + index: number; + subindex: number; + startAngle: number; + endAngle: number; + value: number; + } + + interface Group { + index: number; + startAngle: number; + endAngle: number; + value: number; + } + } + + interface Chord { + matrix(): number[][]; + matrix(matrix: number[][]): Chord; + + padding(): number; + padding(padding: number): Chord; + + sortGroups(): (a: number, b: number) => number; + sortGroups(comparator: (a: number, b: number) => number): Chord; + + sortSubgroups(): (a: number, b: number) => number; + sortSubgroups(comparator: (a: number, b: number) => number): Chord; + + sortChords(): (a: number, b: number) => number; + sortChords(comparator: (a: number, b: number) => number): Chord; + + chords(): chord.Link[]; + groups(): chord.Group[]; + } + + export function cluster(): Cluster<cluster.Result>; + export function cluster<T extends cluster.Result>(): Cluster<T>; + + module cluster { + interface Result { + parent?: Result; + children?: Result[]; + depth?: number; + x?: number; + y?: number; + } + + interface Link<T extends Result> { + source: T; + target: T; + } + } + + interface Cluster<T extends cluster.Result> { + (root: T): T[]; + + nodes(root: T): T[]; + + links(nodes: T[]): cluster.Link<T>; + + children(): (node: T) => T[]; + children(accessor: (node: T) => T[]): Cluster<T>; + + sort(): (a: T, b: T) => number; + sort(comparator: (a: T, b: T) => number): Cluster<T>; + + separation(): (a: T, b: T) => number; + separation(separation: (a: T, b: T) => number): Cluster<T>; + + size(): [number, number]; + size(size: [number, number]): Cluster<T>; + + nodeSize(): [number, number]; + nodeSize(nodeSize: [number, number]): Cluster<T>; + + value(): (a: T) => number; + value(value: (a: T) => number): Cluster<T>; + } + + export function force(): Force<force.Link<force.Node>, force.Node>; + export function force<Node extends force.Node>(): Force<force.Link<Node>, Node>; + export function force<Link extends force.Link<force.Node>, Node extends force.Node>(): Force<Link, Node>; + + module force { + interface Link<T extends Node> { + source: T; + target: T; + } + + interface Node { + index?: number; + x?: number; + y?: number; + px?: number; + py?: number; + fixed?: boolean; + weight?: number; + } + + interface Event { + type: string; + alpha: number; + } + } + + interface Force<Link extends force.Link<force.Node>, Node extends force.Node> { + size(): [number, number]; + size(size: [number, number]): Force<Link, Node>; + + linkDistance(): number | ((link: Link, index: number) => number); + linkDistance(distance: number): Force<Link, Node>; + linkDistance(distance: (link: Link, index: number) => number): Force<Link, Node>; + + linkStrength(): number | ((link: Link, index: number) => number); + linkStrength(strength: number): Force<Link, Node>; + linkStrength(strength: (link: Link, index: number) => number): Force<Link, Node>; + + friction(): number; + friction(friction: number): Force<Link, Node>; + + charge(): number | ((node: Node, index: number) => number); + charge(charge: number): Force<Link, Node>; + charge(charge: (node: Node, index: number) => number): Force<Link, Node>; + + chargeDistance(): number; + chargeDistance(distance: number): Force<Link, Node>; + + theta(): number; + theta(theta: number): Force<Link, Node>; + + gravity(): number; + gravity(gravity: number): Force<Link, Node>; + + nodes(): Node[]; + nodes(nodes: Node[]): Force<Link, Node>; + + links(): Link[]; + links(links: { source: number; target: number }[]): Force<Link, Node>; + links(links: Link[]): Force<Link, Node>; + + start(): Force<Link, Node>; + + alpha(): number; + alpha(value: number): Force<Link, Node>; + + resume(): Force<Link, Node>; + + stop(): Force<Link, Node>; + + on(type: string): (event: force.Event) => void; + on(type: string, listener: (event: force.Event) => void): Force<Link, Node>; + + drag(): behavior.Drag<Node>; + drag(selection: Selection<Node>): void; + } + + export function hierarchy(): Hierarchy<hierarchy.Result>; + export function hierarchy<T extends hierarchy.Result>(): Hierarchy<T>; + + module hierarchy { + interface Result { + parent?: Result; + children?: Result[]; + value?: number; + depth?: number; + } + } + + interface Hierarchy<T extends hierarchy.Result> { + (root: T): T[]; + + children(): (node: T) => T[]; + children(accessor: (node: T) => T[]): Hierarchy<T>; + + sort(): (a: T, b: T) => number; + sort(comparator: (a: T, b: T) => number): Hierarchy<T>; + + value(): (node: T) => number; + value(accessor: (node: T) => number): Hierarchy<T>; + + revalue(root: T): T[]; + } + + export function histogram(): Histogram<number>; + export function histogram<T>(): Histogram<T>; + + module histogram { + interface Bin<T> extends Array<T> { + x: number; + dx: number; + y: number; + } + } + + interface Histogram<T> { + (values: T[], index?: number): histogram.Bin<T>[]; + + value(): (datum: T, index: number) => number; + value(value: (datum: T, index: number) => number): Histogram<T>; + + range(): (values: T[], index: number) => [number, number]; + range(range: (values: T[], index: number) => [number, number]): Histogram<T>; + + bins(): (range: [number, number], values: T[], index: number) => number[]; + bins(count: number): Histogram<T>; + bins(thresholds: number[]): Histogram<T>; + bins(func: (range: [number, number], values: T[], index: number) => number[]): Histogram<T>; + + frequency(): boolean; + frequency(frequency: boolean): Histogram<T>; + } + + export function pack(): Pack<pack.Node>; + export function pack<T extends pack.Node>(): Pack<T>; + + module pack { + interface Node { + parent?: Node; + children?: Node[]; + value?: number; + depth?: number; + x?: number; + y?: number; + r?: number; + } + + interface Link<T extends Node> { + source: Node; + target: Node; + } + } + + interface Pack<T extends pack.Node> { + (root: T): T[]; + + nodes(root: T): T[]; + + links(nodes: T[]): pack.Link<T>[]; + + children(): (node: T, depth: number) => T[]; + children(children: (node: T, depth: number) => T[]): Pack<T>; + + sort(): (a: T, b: T) => number; + sort(comparator: (a: T, b: T) => number): Pack<T>; + + value(): (node: T) => number; + value(value: (node: T) => number): Pack<T>; + + size(): [number, number]; + size(size: [number, number]): Pack<T>; + + radius(): number | ((node: T) => number); + radius(radius: number): Pack<T>; + radius(radius: (node: T) => number): Pack<T>; + + padding(): number; + padding(padding: number): Pack<T>; + } + + export function pie(): Pie<number>; + export function pie<T>(): Pie<T>; + + module pie { + interface Arc<T> { + value: number; + startAngle: number; + endAngle: number; + padAngle: number; + data: T; + } + } + + interface Pie<T> { + (data: T[], index?: number): pie.Arc<T>[]; + + value(): (datum: T, index: number) => number; + value(accessor: (datum: T, index: number) => number): Pie<T>; + + sort(): (a: T, b: T) => number; + sort(comparator: (a: T, b: T) => number): Pie<T>; + + startAngle(): number | ((data: T[], index: number) => number); + startAngle(angle: number): Pie<T>; + startAngle(angle: (data: T[], index: number) => number): Pie<T>; + + endAngle(): number | ((data: T[], index: number) => number); + endAngle(angle: number): Pie<T>; + endAngle(angle: (data: T[], index: number) => number): Pie<T>; + + padAngle(): number | ((data: T[], index: number) => number); + padAngle(angle: number): Pie<T>; + padAngle(angle: (data: T[], index: number) => number): Pie<T>; + } + + export function stack(): Stack<stack.Value[], stack.Value>; + export function stack<Value>(): Stack<Value[], Value>; + export function stack<Series, Value>(): Stack<Series, Value>; + module stack { + interface Value { + x: number; + y: number; + y0?: number; + } + } + + interface Stack<Series, Value> { + (layers: Series[], index?: number): Series[]; + + values(): (layer: Series, index: number) => Value[]; + values(accessor: (layer: Series, index: number) => Value[]): Stack<Series, Value>; + + offset(): (data: Array<[number, number]>) => number[]; + offset(offset: "silhouette"): Stack<Series, Value>; + offset(offset: "wiggle"): Stack<Series, Value>; + offset(offset: "expand"): Stack<Series, Value>; + offset(offset: "zero"): Stack<Series, Value>; + offset(offset: string): Stack<Series, Value>; + offset(offset: (data: Array<[number, number]>) => number[]): Stack<Series, Value>; + + order(): (data: Array<[number, number]>) => number[]; + order(order: "inside-out"): Stack<Series, Value>; + order(order: "reverse"): Stack<Series, Value>; + order(order: "default"): Stack<Series, Value>; + order(order: string): Stack<Series, Value>; + order(order: (data: Array<[number, number]>) => number[]): Stack<Series, Value>; + + x(): (value: Value, index: number) => number; + x(accessor: (value: Value, index: number) => number): Stack<Series, Value>; + + y(): (value: Value, index: number) => number; + y(accesor: (value: Value, index: number) => number): Stack<Series, Value>; + + out(): (value: Value, y0: number, y: number) => void; + out(setter: (value: Value, y0: number, y: number) => void): Stack<Series, Value>; + } + + export function tree(): Tree<tree.Node>; + export function tree<T extends tree.Node>(): Tree<T>; + + module tree { + interface Link<T extends Node> { + source: T; + target: T; + } + + interface Node { + parent?: Node; + children?: Node[]; + depth?: number; + x?: number; + y?: number; + } + } + + interface Tree<T> { + (root: T, index?: number): T[]; + + nodes(root: T, index?: number): T[]; + + links(nodes: T[]): tree.Link<T>[]; + + children(): (datum: T, index: number) => T[]; + children(children: (datum: T, index: number) => T[]): Tree<T>; + + separation(): (a: T, b: T) => number; + separation(separation: (a: T, b: T) => number): Tree<T>; + + size(): [number, number]; + size(size: [number, number]): Tree<T>; + + nodeSize(): [number, number]; + nodeSize(size: [number, number]): Tree<T>; + + sort(): (a: T, b: T) => number; + sort(comparator: (a: T, b: T) => number): Tree<T>; + + value(): (datum: T, index: number) => number; + value(value: (datum: T, index: number) => number): Tree<T>; + } + + export function treemap(): Treemap<treemap.Node>; + export function treemap<T extends treemap.Node>(): Treemap<T>; + + module treemap { + interface Node { + parent?: Node; + children?: Node[]; + value?: number; + depth?: number; + x?: number; + y?: number; + dx?: number; + dy?: number; + } + + interface Link<T extends Node> { + source: T; + target: T; + } + + type Padding = number | [number, number, number, number]; + } + + interface Treemap<T extends treemap.Node> { + (root: T, index?: number): T[]; + + nodes(root: T, index?: number): T[]; + + links(nodes: T[]): treemap.Link<T>[]; + + children(): (node: T, depth: number) => T[]; + children(children: (node: T, depth: number) => T[]): Treemap<T>; + + sort(): (a: T, b: T) => number; + sort(comparator: (a: T, b: T) => number): Treemap<T>; + + value(): (node: T, index: number) => number; + value(value: (node: T, index: number) => number): Treemap<T>; + + size(): [number, number]; + size(size: [number, number]): Treemap<T>; + + padding(): (node: T, depth: number) => treemap.Padding; + padding(padding: treemap.Padding): Treemap<T>; + padding(padding: (node: T, depth: number) => treemap.Padding): Treemap<T>; + + round(): boolean; + round(round: boolean): Treemap<T>; + + sticky(): boolean; + sticky(sticky: boolean): boolean; + + mode(): string; + mode(mode: "squarify"): Treemap<T>; + mode(mode: "slice"): Treemap<T>; + mode(mode: "dice"): Treemap<T>; + mode(mode: "slice-dice"): Treemap<T>; + mode(mode: string): Treemap<T>; + + ratio(): number; + ratio(ratio: number): Treemap<T>; + } + } + + module geom { + export function voronoi(): Voronoi<[number, number]>; + export function voronoi<T>(): Voronoi<T>; + + module voronoi { + interface Link<T> { + source: T; + target: T; + } + } + + interface Voronoi<T> { + (data: T[]): Array<[number, number]>; + + x(): (vertex: T) => number; + x(x: (vertex: T) => number): Voronoi<T>; + + y(): (vertex: T) => number; + y(y: (vertex: T) => number): Voronoi<T>; + + clipExtent(): [[number, number], [number, number]]; + clipExtent(extent: [[number, number], [number, number]]): Voronoi<T>; + + links(data: T[]): voronoi.Link<T>[]; + + triangles(data: T[]): Array<[T, T, T]>; + } + + /** + * @deprecated use d3.geom.voronoi().triangles() instead + */ + export function delaunay(vertices: Array<[number, number]>): Array<[[number, number], [number, number], [number, number]]>; + + export function quadtree(): Quadtree<[number, number]>; + export function quadtree<T>(): Quadtree<T>; + + module quadtree { + interface Node<T> { + nodes: [Node<T>, Node<T>, Node<T>, Node<T>]; + leaf: boolean; + point: T; + x: number; + y: number; + } + + interface Quadtree<T> extends Node<T> { + add(point: T): void; + visit(callback: (node: Node<T>, x1: number, y1: number, x2: number, y2: number) => boolean | void): void; + find(point: [number, number]): T; + } + } + + interface Quadtree<T> { + (points: T[]): quadtree.Quadtree<T>; + + x(): (datum: T, index: number) => number; + x(x: number): Quadtree<T>; + x(x: (datum: T, index: number) => number): Quadtree<T>; + + y(): (datum: T, index: number) => number; + y(y: number): Quadtree<T>; + y(y: (datum: T, index: number) => number): Quadtree<T>; + + extent(): [[number, number], [number, number]]; + extent(extent: [[number, number], [number, number]]): Quadtree<T>; + } + + export function hull(vertices: Array<[number, number]>): Array<[number, number]>; + export function hull(): Hull<[number, number]>; + export function hull<T>(): Hull<T>; + + interface Hull<T> { + (vertices: T[]): Array<[number, number]>; + + x(): (datum: T) => number; + x(x: (datum: T) => number): Hull<T>; + + y(): (datum: T) => number; + y(y: (datum: T) => number): Hull<T>; + } + + export function polygon(vertices: Array<[number, number]>): Polygon; + + interface Polygon { + area(): number; + + centroid(): [number, number]; + + clip(subject: Array<[number, number]>): Array<[number, number]>; + } + } +} + +// we need this to exist +interface TouchList { } + +declare module 'd3' { + export = d3; +} diff --git a/catalog-ui/typings/jasmine/jasmine.d.ts b/catalog-ui/typings/jasmine/jasmine.d.ts new file mode 100644 index 0000000000..99ccb91fed --- /dev/null +++ b/catalog-ui/typings/jasmine/jasmine.d.ts @@ -0,0 +1,515 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ +// Type definitions for Jasmine 2.2 +// Project: http://jasmine.github.io/ +// Definitions by: Boris Yankov <https://github.com/borisyankov/>, Theodore Brown <https://github.com/theodorejb>, David Pärsson <https://github.com/davidparsson/> +// Definitions: https://github.com/borisyankov/DefinitelyTyped + + +// For ddescribe / iit use : https://github.com/borisyankov/DefinitelyTyped/blob/master/karma-jasmine/karma-jasmine.d.ts + +declare function describe(description: string, specDefinitions: () => void): void; +declare function fdescribe(description: string, specDefinitions: () => void): void; +declare function xdescribe(description: string, specDefinitions: () => void): void; + +declare function it(expectation: string, assertion?: () => void, timeout?: number): void; +declare function it(expectation: string, assertion?: (done: () => void) => void, timeout?: number): void; +declare function fit(expectation: string, assertion?: () => void, timeout?: number): void; +declare function fit(expectation: string, assertion?: (done: () => void) => void, timeout?: number): void; +declare function xit(expectation: string, assertion?: () => void, timeout?: number): void; +declare function xit(expectation: string, assertion?: (done: () => void) => void, timeout?: number): void; + +/** If you call the function pending anywhere in the spec body, no matter the expectations, the spec will be marked pending. */ +declare function pending(reason?: string): void; + +declare function beforeEach(action: () => void, timeout?: number): void; +declare function beforeEach(action: (done: () => void) => void, timeout?: number): void; +declare function afterEach(action: () => void, timeout?: number): void; +declare function afterEach(action: (done: () => void) => void, timeout?: number): void; + +declare function beforeAll(action: () => void, timeout?: number): void; +declare function beforeAll(action: (done: () => void) => void, timeout?: number): void; +declare function afterAll(action: () => void, timeout?: number): void; +declare function afterAll(action: (done: () => void) => void, timeout?: number): void; + +declare function expect(spy: Function): jasmine.Matchers; +declare function expect(actual: any): jasmine.Matchers; + +declare function fail(e?: any): void; + +declare function spyOn(object: any, method: string): jasmine.Spy; + +declare function runs(asyncMethod: Function): void; +declare function waitsFor(latchMethod: () => boolean, failureMessage?: string, timeout?: number): void; +declare function waits(timeout?: number): void; + +declare module jasmine { + + var clock: () => Clock; + + function any(aclass: any): Any; + function anything(): Any; + function arrayContaining(sample: any[]): ArrayContaining; + function objectContaining(sample: any): ObjectContaining; + function createSpy(name: string, originalFn?: Function): Spy; + function createSpyObj(baseName: string, methodNames: any[]): any; + function createSpyObj<T>(baseName: string, methodNames: any[]): T; + function pp(value: any): string; + function getEnv(): Env; + function addCustomEqualityTester(equalityTester: CustomEqualityTester): void; + function addMatchers(matchers: CustomMatcherFactories): void; + function stringMatching(str: string): Any; + function stringMatching(str: RegExp): Any; + + interface Any { + + new (expectedClass: any): any; + + jasmineMatches(other: any): boolean; + jasmineToString(): string; + } + + // taken from TypeScript lib.core.es6.d.ts, applicable to CustomMatchers.contains() + interface ArrayLike<T> { + length: number; + [n: number]: T; + } + + interface ArrayContaining { + new (sample: any[]): any; + + asymmetricMatch(other: any): boolean; + jasmineToString(): string; + } + + interface ObjectContaining { + new (sample: any): any; + + jasmineMatches(other: any, mismatchKeys: any[], mismatchValues: any[]): boolean; + jasmineToString(): string; + } + + interface Block { + + new (env: Env, func: SpecFunction, spec: Spec): any; + + execute(onComplete: () => void): void; + } + + interface WaitsBlock extends Block { + new (env: Env, timeout: number, spec: Spec): any; + } + + interface WaitsForBlock extends Block { + new (env: Env, timeout: number, latchFunction: SpecFunction, message: string, spec: Spec): any; + } + + interface Clock { + install(): void; + uninstall(): void; + /** Calls to any registered callback are triggered when the clock is ticked forward via the jasmine.clock().tick function, which takes a number of milliseconds. */ + tick(ms: number): void; + mockDate(date?: Date): void; + } + + interface CustomEqualityTester { + (first: any, second: any): boolean; + } + + interface CustomMatcher { + compare<T>(actual: T, expected: T): CustomMatcherResult; + compare(actual: any, expected: any): CustomMatcherResult; + } + + interface CustomMatcherFactory { + (util: MatchersUtil, customEqualityTesters: Array<CustomEqualityTester>): CustomMatcher; + } + + interface CustomMatcherFactories { + [index: string]: CustomMatcherFactory; + } + + interface CustomMatcherResult { + pass: boolean; + message: string; + } + + interface MatchersUtil { + equals(a: any, b: any, customTesters?: Array<CustomEqualityTester>): boolean; + contains<T>(haystack: ArrayLike<T> | string, needle: any, customTesters?: Array<CustomEqualityTester>): boolean; + buildFailureMessage(matcherName: string, isNot: boolean, actual: any, ...expected: Array<any>): string; + } + + interface Env { + setTimeout: any; + clearTimeout: void; + setInterval: any; + clearInterval: void; + updateInterval: number; + + currentSpec: Spec; + + matchersClass: Matchers; + + version(): any; + versionString(): string; + nextSpecId(): number; + addReporter(reporter: Reporter): void; + execute(): void; + describe(description: string, specDefinitions: () => void): Suite; + // ddescribe(description: string, specDefinitions: () => void): Suite; Not a part of jasmine. Angular team adds these + beforeEach(beforeEachFunction: () => void): void; + beforeAll(beforeAllFunction: () => void): void; + currentRunner(): Runner; + afterEach(afterEachFunction: () => void): void; + afterAll(afterAllFunction: () => void): void; + xdescribe(desc: string, specDefinitions: () => void): XSuite; + it(description: string, func: () => void): Spec; + // iit(description: string, func: () => void): Spec; Not a part of jasmine. Angular team adds these + xit(desc: string, func: () => void): XSpec; + compareRegExps_(a: RegExp, b: RegExp, mismatchKeys: string[], mismatchValues: string[]): boolean; + compareObjects_(a: any, b: any, mismatchKeys: string[], mismatchValues: string[]): boolean; + equals_(a: any, b: any, mismatchKeys: string[], mismatchValues: string[]): boolean; + contains_(haystack: any, needle: any): boolean; + addCustomEqualityTester(equalityTester: CustomEqualityTester): void; + addMatchers(matchers: CustomMatcherFactories): void; + specFilter(spec: Spec): boolean; + } + + interface FakeTimer { + + new (): any; + + reset(): void; + tick(millis: number): void; + runFunctionsWithinRange(oldMillis: number, nowMillis: number): void; + scheduleFunction(timeoutKey: any, funcToCall: () => void, millis: number, recurring: boolean): void; + } + + interface HtmlReporter { + new (): any; + } + + interface HtmlSpecFilter { + new (): any; + } + + interface Result { + type: string; + } + + interface NestedResults extends Result { + description: string; + + totalCount: number; + passedCount: number; + failedCount: number; + + skipped: boolean; + + rollupCounts(result: NestedResults): void; + log(values: any): void; + getItems(): Result[]; + addResult(result: Result): void; + passed(): boolean; + } + + interface MessageResult extends Result { + values: any; + trace: Trace; + } + + interface ExpectationResult extends Result { + matcherName: string; + passed(): boolean; + expected: any; + actual: any; + message: string; + trace: Trace; + } + + interface Trace { + name: string; + message: string; + stack: any; + } + + interface PrettyPrinter { + + new (): any; + + format(value: any): void; + iterateObject(obj: any, fn: (property: string, isGetter: boolean) => void): void; + emitScalar(value: any): void; + emitString(value: string): void; + emitArray(array: any[]): void; + emitObject(obj: any): void; + append(value: any): void; + } + + interface StringPrettyPrinter extends PrettyPrinter { + } + + interface Queue { + + new (env: any): any; + + env: Env; + ensured: boolean[]; + blocks: Block[]; + running: boolean; + index: number; + offset: number; + abort: boolean; + + addBefore(block: Block, ensure?: boolean): void; + add(block: any, ensure?: boolean): void; + insertNext(block: any, ensure?: boolean): void; + start(onComplete?: () => void): void; + isRunning(): boolean; + next_(): void; + results(): NestedResults; + } + + interface Matchers { + + new (env: Env, actual: any, spec: Env, isNot?: boolean): any; + + env: Env; + actual: any; + spec: Env; + isNot?: boolean; + message(): any; + + toBe(expected: any, expectationFailOutput?: any): boolean; + toEqual(expected: any, expectationFailOutput?: any): boolean; + toMatch(expected: any, expectationFailOutput?: any): boolean; + toBeDefined(expectationFailOutput?: any): boolean; + toBeUndefined(expectationFailOutput?: any): boolean; + toBeNull(expectationFailOutput?: any): boolean; + toBeNaN(): boolean; + toBeTruthy(expectationFailOutput?: any): boolean; + toBeFalsy(expectationFailOutput?: any): boolean; + toHaveBeenCalled(): boolean; + toHaveBeenCalledWith(...params: any[]): boolean; + toContain(expected: any, expectationFailOutput?: any): boolean; + toBeLessThan(expected: any, expectationFailOutput?: any): boolean; + toBeGreaterThan(expected: any, expectationFailOutput?: any): boolean; + toBeCloseTo(expected: any, precision: any, expectationFailOutput?: any): boolean; + toContainHtml(expected: string): boolean; + toContainText(expected: string): boolean; + toThrow(expected?: any): boolean; + toThrowError(expected?: any, message?: string): boolean; + not: Matchers; + + Any: Any; + } + + interface Reporter { + reportRunnerStarting(runner: Runner): void; + reportRunnerResults(runner: Runner): void; + reportSuiteResults(suite: Suite): void; + reportSpecStarting(spec: Spec): void; + reportSpecResults(spec: Spec): void; + log(str: string): void; + } + + interface MultiReporter extends Reporter { + addReporter(reporter: Reporter): void; + } + + interface Runner { + + new (env: Env): any; + + execute(): void; + beforeEach(beforeEachFunction: SpecFunction): void; + afterEach(afterEachFunction: SpecFunction): void; + beforeAll(beforeAllFunction: SpecFunction): void; + afterAll(afterAllFunction: SpecFunction): void; + finishCallback(): void; + addSuite(suite: Suite): void; + add(block: Block): void; + specs(): Spec[]; + suites(): Suite[]; + topLevelSuites(): Suite[]; + results(): NestedResults; + } + + interface SpecFunction { + (spec?: Spec): void; + } + + interface SuiteOrSpec { + id: number; + env: Env; + description: string; + queue: Queue; + } + + interface Spec extends SuiteOrSpec { + + new (env: Env, suite: Suite, description: string): any; + + suite: Suite; + + afterCallbacks: SpecFunction[]; + spies_: Spy[]; + + results_: NestedResults; + matchersClass: Matchers; + + getFullName(): string; + results(): NestedResults; + log(arguments: any): any; + runs(func: SpecFunction): Spec; + addToQueue(block: Block): void; + addMatcherResult(result: Result): void; + expect(actual: any): any; + waits(timeout: number): Spec; + waitsFor(latchFunction: SpecFunction, timeoutMessage?: string, timeout?: number): Spec; + fail(e?: any): void; + getMatchersClass_(): Matchers; + addMatchers(matchersPrototype: CustomMatcherFactories): void; + finishCallback(): void; + finish(onComplete?: () => void): void; + after(doAfter: SpecFunction): void; + execute(onComplete?: () => void): any; + addBeforesAndAftersToQueue(): void; + explodes(): void; + spyOn(obj: any, methodName: string, ignoreMethodDoesntExist: boolean): Spy; + removeAllSpies(): void; + } + + interface XSpec { + id: number; + runs(): void; + } + + interface Suite extends SuiteOrSpec { + + new (env: Env, description: string, specDefinitions: () => void, parentSuite: Suite): any; + + parentSuite: Suite; + + getFullName(): string; + finish(onComplete?: () => void): void; + beforeEach(beforeEachFunction: SpecFunction): void; + afterEach(afterEachFunction: SpecFunction): void; + beforeAll(beforeAllFunction: SpecFunction): void; + afterAll(afterAllFunction: SpecFunction): void; + results(): NestedResults; + add(suiteOrSpec: SuiteOrSpec): void; + specs(): Spec[]; + suites(): Suite[]; + children(): any[]; + execute(onComplete?: () => void): void; + } + + interface XSuite { + execute(): void; + } + + interface Spy { + (...params: any[]): any; + + identity: string; + and: SpyAnd; + calls: Calls; + mostRecentCall: { args: any[]; }; + argsForCall: any[]; + wasCalled: boolean; + } + + interface SpyAnd { + /** By chaining the spy with and.callThrough, the spy will still track all calls to it but in addition it will delegate to the actual implementation. */ + callThrough(): Spy; + /** By chaining the spy with and.returnValue, all calls to the function will return a specific value. */ + returnValue(val: any): void; + /** By chaining the spy with and.callFake, all calls to the spy will delegate to the supplied function. */ + callFake(fn: Function): Spy; + /** By chaining the spy with and.throwError, all calls to the spy will throw the specified value. */ + throwError(msg: string): void; + /** When a calling strategy is used for a spy, the original stubbing behavior can be returned at any time with and.stub. */ + stub(): Spy; + } + + interface Calls { + /** By chaining the spy with calls.any(), will return false if the spy has not been called at all, and then true once at least one call happens. **/ + any(): boolean; + /** By chaining the spy with calls.count(), will return the number of times the spy was called **/ + count(): number; + /** By chaining the spy with calls.argsFor(), will return the arguments passed to call number index **/ + argsFor(index: number): any[]; + /** By chaining the spy with calls.allArgs(), will return the arguments to all calls **/ + allArgs(): any[]; + /** By chaining the spy with calls.all(), will return the context (the this) and arguments passed all calls **/ + all(): CallInfo[]; + /** By chaining the spy with calls.mostRecent(), will return the context (the this) and arguments for the most recent call **/ + mostRecent(): CallInfo; + /** By chaining the spy with calls.first(), will return the context (the this) and arguments for the first call **/ + first(): CallInfo; + /** By chaining the spy with calls.reset(), will clears all tracking for a spy **/ + reset(): void; + } + + interface CallInfo { + /** The context (the this) for the call */ + object: any; + /** All arguments passed to the call */ + args: any[]; + } + + interface Util { + inherit(childClass: Function, parentClass: Function): any; + formatException(e: any): any; + htmlEscape(str: string): string; + argsToArray(args: any): any; + extend(destination: any, source: any): any; + } + + interface JsApiReporter extends Reporter { + + started: boolean; + finished: boolean; + result: any; + messages: any; + + new (): any; + + suites(): Suite[]; + summarize_(suiteOrSpec: SuiteOrSpec): any; + results(): any; + resultsForSpec(specId: any): any; + log(str: any): any; + resultsForSpecs(specIds: any): any; + summarizeResult_(result: any): any; + } + + interface Jasmine { + Spec: Spec; + clock: Clock; + util: Util; + } + + export var HtmlReporter: HtmlReporter; + export var HtmlSpecFilter: HtmlSpecFilter; + export var DEFAULT_TIMEOUT_INTERVAL: number; +} diff --git a/catalog-ui/typings/jquery/jquery.d.ts b/catalog-ui/typings/jquery/jquery.d.ts new file mode 100644 index 0000000000..cc20de588b --- /dev/null +++ b/catalog-ui/typings/jquery/jquery.d.ts @@ -0,0 +1,3181 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ +// Type definitions for jQuery 1.10.x / 2.0.x +// Project: http://jquery.com/ +// Definitions by: Boris Yankov <https://github.com/borisyankov/>, Christian Hoffmeister <https://github.com/choffmeister>, Steve Fenton <https://github.com/Steve-Fenton>, Diullei Gomes <https://github.com/Diullei>, Tass Iliopoulos <https://github.com/tasoili>, Jason Swearingen <https://github.com/jasons-novaleaf>, Sean Hill <https://github.com/seanski>, Guus Goossens <https://github.com/Guuz>, Kelly Summerlin <https://github.com/ksummerlin>, Basarat Ali Syed <https://github.com/basarat>, Nicholas Wolverson <https://github.com/nwolverson>, Derek Cicerone <https://github.com/derekcicerone>, Andrew Gaspar <https://github.com/AndrewGaspar>, James Harrison Fisher <https://github.com/jameshfisher>, Seikichi Kondo <https://github.com/seikichi>, Benjamin Jackman <https://github.com/benjaminjackman>, Poul Sorensen <https://github.com/s093294>, Josh Strobl <https://github.com/JoshStrobl>, John Reilly <https://github.com/johnnyreilly/>, Dick van den Brink <https://github.com/DickvdBrink> +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +/* ***************************************************************************** +Copyright (c) Microsoft Corporation. All rights reserved. +Licensed under the Apache License, Version 2.0 (the "License"); you may not use +this file except in compliance with the License. You may obtain a copy of the +License at http://www.apache.org/licenses/LICENSE-2.0 + +THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED +WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, +MERCHANTABLITY OR NON-INFRINGEMENT. + +See the Apache Version 2.0 License for specific language governing permissions +and limitations under the License. +***************************************************************************** */ + + +/** + * Interface for the AJAX setting that will configure the AJAX request + */ +interface JQueryAjaxSettings { + /** + * The content type sent in the request header that tells the server what kind of response it will accept in return. If the accepts setting needs modification, it is recommended to do so once in the $.ajaxSetup() method. + */ + accepts?: any; + /** + * By default, all requests are sent asynchronously (i.e. this is set to true by default). If you need synchronous requests, set this option to false. Cross-domain requests and dataType: "jsonp" requests do not support synchronous operation. Note that synchronous requests may temporarily lock the browser, disabling any actions while the request is active. As of jQuery 1.8, the use of async: false with jqXHR ($.Deferred) is deprecated; you must use the success/error/complete callback options instead of the corresponding methods of the jqXHR object such as jqXHR.done() or the deprecated jqXHR.success(). + */ + async?: boolean; + /** + * A pre-request callback function that can be used to modify the jqXHR (in jQuery 1.4.x, XMLHTTPRequest) object before it is sent. Use this to set custom headers, etc. The jqXHR and settings objects are passed as arguments. This is an Ajax Event. Returning false in the beforeSend function will cancel the request. As of jQuery 1.5, the beforeSend option will be called regardless of the type of request. + */ + beforeSend? (jqXHR: JQueryXHR, settings: JQueryAjaxSettings): any; + /** + * If set to false, it will force requested pages not to be cached by the browser. Note: Setting cache to false will only work correctly with HEAD and GET requests. It works by appending "_={timestamp}" to the GET parameters. The parameter is not needed for other types of requests, except in IE8 when a POST is made to a URL that has already been requested by a GET. + */ + cache?: boolean; + /** + * A function to be called when the request finishes (after success and error callbacks are executed). The function gets passed two arguments: The jqXHR (in jQuery 1.4.x, XMLHTTPRequest) object and a string categorizing the status of the request ("success", "notmodified", "error", "timeout", "abort", or "parsererror"). As of jQuery 1.5, the complete setting can accept an array of functions. Each function will be called in turn. This is an Ajax Event. + */ + complete? (jqXHR: JQueryXHR, textStatus: string): any; + /** + * An object of string/regular-expression pairs that determine how jQuery will parse the response, given its content type. (version added: 1.5) + */ + contents?: { [key: string]: any; }; + //According to jQuery.ajax source code, ajax's option actually allows contentType to set to "false" + // https://github.com/borisyankov/DefinitelyTyped/issues/742 + /** + * When sending data to the server, use this content type. Default is "application/x-www-form-urlencoded; charset=UTF-8", which is fine for most cases. If you explicitly pass in a content-type to $.ajax(), then it is always sent to the server (even if no data is sent). The W3C XMLHttpRequest specification dictates that the charset is always UTF-8; specifying another charset will not force the browser to change the encoding. + */ + contentType?: any; + /** + * This object will be made the context of all Ajax-related callbacks. By default, the context is an object that represents the ajax settings used in the call ($.ajaxSettings merged with the settings passed to $.ajax). + */ + context?: any; + /** + * An object containing dataType-to-dataType converters. Each converter's value is a function that returns the transformed value of the response. (version added: 1.5) + */ + converters?: { [key: string]: any; }; + /** + * If you wish to force a crossDomain request (such as JSONP) on the same domain, set the value of crossDomain to true. This allows, for example, server-side redirection to another domain. (version added: 1.5) + */ + crossDomain?: boolean; + /** + * Data to be sent to the server. It is converted to a query string, if not already a string. It's appended to the url for GET-requests. See processData option to prevent this automatic processing. Object must be Key/Value pairs. If value is an Array, jQuery serializes multiple values with same key based on the value of the traditional setting (described below). + */ + data?: any; + /** + * A function to be used to handle the raw response data of XMLHttpRequest.This is a pre-filtering function to sanitize the response. You should return the sanitized data. The function accepts two arguments: The raw data returned from the server and the 'dataType' parameter. + */ + dataFilter? (data: any, ty: any): any; + /** + * The type of data that you're expecting back from the server. If none is specified, jQuery will try to infer it based on the MIME type of the response (an XML MIME type will yield XML, in 1.4 JSON will yield a JavaScript object, in 1.4 script will execute the script, and anything else will be returned as a string). + */ + dataType?: string; + /** + * A function to be called if the request fails. The function receives three arguments: The jqXHR (in jQuery 1.4.x, XMLHttpRequest) object, a string describing the type of error that occurred and an optional exception object, if one occurred. Possible values for the second argument (besides null) are "timeout", "error", "abort", and "parsererror". When an HTTP error occurs, errorThrown receives the textual portion of the HTTP status, such as "Not Found" or "Internal Server Error." As of jQuery 1.5, the error setting can accept an array of functions. Each function will be called in turn. Note: This handler is not called for cross-domain script and cross-domain JSONP requests. This is an Ajax Event. + */ + error? (jqXHR: JQueryXHR, textStatus: string, errorThrown: string): any; + /** + * Whether to trigger global Ajax event handlers for this request. The default is true. Set to false to prevent the global handlers like ajaxStart or ajaxStop from being triggered. This can be used to control various Ajax Events. + */ + global?: boolean; + /** + * An object of additional header key/value pairs to send along with requests using the XMLHttpRequest transport. The header X-Requested-With: XMLHttpRequest is always added, but its default XMLHttpRequest value can be changed here. Values in the headers setting can also be overwritten from within the beforeSend function. (version added: 1.5) + */ + headers?: { [key: string]: any; }; + /** + * Allow the request to be successful only if the response has changed since the last request. This is done by checking the Last-Modified header. Default value is false, ignoring the header. In jQuery 1.4 this technique also checks the 'etag' specified by the server to catch unmodified data. + */ + ifModified?: boolean; + /** + * Allow the current environment to be recognized as "local," (e.g. the filesystem), even if jQuery does not recognize it as such by default. The following protocols are currently recognized as local: file, *-extension, and widget. If the isLocal setting needs modification, it is recommended to do so once in the $.ajaxSetup() method. (version added: 1.5.1) + */ + isLocal?: boolean; + /** + * Override the callback function name in a jsonp request. This value will be used instead of 'callback' in the 'callback=?' part of the query string in the url. So {jsonp:'onJSONPLoad'} would result in 'onJSONPLoad=?' passed to the server. As of jQuery 1.5, setting the jsonp option to false prevents jQuery from adding the "?callback" string to the URL or attempting to use "=?" for transformation. In this case, you should also explicitly set the jsonpCallback setting. For example, { jsonp: false, jsonpCallback: "callbackName" } + */ + jsonp?: any; + /** + * Specify the callback function name for a JSONP request. This value will be used instead of the random name automatically generated by jQuery. It is preferable to let jQuery generate a unique name as it'll make it easier to manage the requests and provide callbacks and error handling. You may want to specify the callback when you want to enable better browser caching of GET requests. As of jQuery 1.5, you can also use a function for this setting, in which case the value of jsonpCallback is set to the return value of that function. + */ + jsonpCallback?: any; + /** + * A mime type to override the XHR mime type. (version added: 1.5.1) + */ + mimeType?: string; + /** + * A password to be used with XMLHttpRequest in response to an HTTP access authentication request. + */ + password?: string; + /** + * By default, data passed in to the data option as an object (technically, anything other than a string) will be processed and transformed into a query string, fitting to the default content-type "application/x-www-form-urlencoded". If you want to send a DOMDocument, or other non-processed data, set this option to false. + */ + processData?: boolean; + /** + * Only applies when the "script" transport is used (e.g., cross-domain requests with "jsonp" or "script" dataType and "GET" type). Sets the charset attribute on the script tag used in the request. Used when the character set on the local page is not the same as the one on the remote script. + */ + scriptCharset?: string; + /** + * An object of numeric HTTP codes and functions to be called when the response has the corresponding code. f the request is successful, the status code functions take the same parameters as the success callback; if it results in an error (including 3xx redirect), they take the same parameters as the error callback. (version added: 1.5) + */ + statusCode?: { [key: string]: any; }; + /** + * A function to be called if the request succeeds. The function gets passed three arguments: The data returned from the server, formatted according to the dataType parameter; a string describing the status; and the jqXHR (in jQuery 1.4.x, XMLHttpRequest) object. As of jQuery 1.5, the success setting can accept an array of functions. Each function will be called in turn. This is an Ajax Event. + */ + success? (data: any, textStatus: string, jqXHR: JQueryXHR): any; + /** + * Set a timeout (in milliseconds) for the request. This will override any global timeout set with $.ajaxSetup(). The timeout period starts at the point the $.ajax call is made; if several other requests are in progress and the browser has no connections available, it is possible for a request to time out before it can be sent. In jQuery 1.4.x and below, the XMLHttpRequest object will be in an invalid state if the request times out; accessing any object members may throw an exception. In Firefox 3.0+ only, script and JSONP requests cannot be cancelled by a timeout; the script will run even if it arrives after the timeout period. + */ + timeout?: number; + /** + * Set this to true if you wish to use the traditional style of param serialization. + */ + traditional?: boolean; + /** + * The type of request to make ("POST" or "GET"), default is "GET". Note: Other HTTP request methods, such as PUT and DELETE, can also be used here, but they are not supported by all browsers. + */ + type?: string; + /** + * A string containing the URL to which the request is sent. + */ + url?: string; + /** + * A username to be used with XMLHttpRequest in response to an HTTP access authentication request. + */ + username?: string; + /** + * Callback for creating the XMLHttpRequest object. Defaults to the ActiveXObject when available (IE), the XMLHttpRequest otherwise. Override to provide your own implementation for XMLHttpRequest or enhancements to the factory. + */ + xhr?: any; + /** + * An object of fieldName-fieldValue pairs to set on the native XHR object. For example, you can use it to set withCredentials to true for cross-domain requests if needed. In jQuery 1.5, the withCredentials property was not propagated to the native XHR and thus CORS requests requiring it would ignore this flag. For this reason, we recommend using jQuery 1.5.1+ should you require the use of it. (version added: 1.5.1) + */ + xhrFields?: { [key: string]: any; }; +} + +/** + * Interface for the jqXHR object + */ +interface JQueryXHR extends XMLHttpRequest, JQueryPromise<any> { + /** + * The .overrideMimeType() method may be used in the beforeSend() callback function, for example, to modify the response content-type header. As of jQuery 1.5.1, the jqXHR object also contains the overrideMimeType() method (it was available in jQuery 1.4.x, as well, but was temporarily removed in jQuery 1.5). + */ + overrideMimeType(mimeType: string): any; + /** + * Cancel the request. + * + * @param statusText A string passed as the textStatus parameter for the done callback. Default value: "canceled" + */ + abort(statusText?: string): void; + /** + * Incorporates the functionality of the .done() and .fail() methods, allowing (as of jQuery 1.8) the underlying Promise to be manipulated. Refer to deferred.then() for implementation details. + */ + then(doneCallback: (data: any, textStatus: string, jqXHR: JQueryXHR) => void, failCallback?: (jqXHR: JQueryXHR, textStatus: string, errorThrown: any) => void): JQueryPromise<any>; + /** + * Property containing the parsed response if the response Content-Type is json + */ + responseJSON?: any; +} + +/** + * Interface for the JQuery callback + */ +interface JQueryCallback { + /** + * Add a callback or a collection of callbacks to a callback list. + * + * @param callbacks A function, or array of functions, that are to be added to the callback list. + */ + add(callbacks: Function): JQueryCallback; + /** + * Add a callback or a collection of callbacks to a callback list. + * + * @param callbacks A function, or array of functions, that are to be added to the callback list. + */ + add(callbacks: Function[]): JQueryCallback; + + /** + * Disable a callback list from doing anything more. + */ + disable(): JQueryCallback; + + /** + * Determine if the callbacks list has been disabled. + */ + disabled(): boolean; + + /** + * Remove all of the callbacks from a list. + */ + empty(): JQueryCallback; + + /** + * Call all of the callbacks with the given arguments + * + * @param arguments The argument or list of arguments to pass back to the callback list. + */ + fire(...arguments: any[]): JQueryCallback; + + /** + * Determine if the callbacks have already been called at least once. + */ + fired(): boolean; + + /** + * Call all callbacks in a list with the given context and arguments. + * + * @param context A reference to the context in which the callbacks in the list should be fired. + * @param arguments An argument, or array of arguments, to pass to the callbacks in the list. + */ + fireWith(context?: any, ...args: any[]): JQueryCallback; + + /** + * Determine whether a supplied callback is in a list + * + * @param callback The callback to search for. + */ + has(callback: Function): boolean; + + /** + * Lock a callback list in its current state. + */ + lock(): JQueryCallback; + + /** + * Determine if the callbacks list has been locked. + */ + locked(): boolean; + + /** + * Remove a callback or a collection of callbacks from a callback list. + * + * @param callbacks A function, or array of functions, that are to be removed from the callback list. + */ + remove(callbacks: Function): JQueryCallback; + /** + * Remove a callback or a collection of callbacks from a callback list. + * + * @param callbacks A function, or array of functions, that are to be removed from the callback list. + */ + remove(callbacks: Function[]): JQueryCallback; +} + +/** + * Allows jQuery Promises to interop with non-jQuery promises + */ +interface JQueryGenericPromise<T> { + /** + * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress. + * + * @param doneFilter A function that is called when the Deferred is resolved. + * @param failFilter An optional function that is called when the Deferred is rejected. + */ + then<U>(doneFilter: (value?: T, ...values: any[]) => U|JQueryPromise<U>, failFilter?: (...reasons: any[]) => any, progressFilter?: (...progression: any[]) => any): JQueryPromise<U>; + + /** + * Add handlers to be called when the Deferred object is resolved, rejected, or still in progress. + * + * @param doneFilter A function that is called when the Deferred is resolved. + * @param failFilter An optional function that is called when the Deferred is rejected. + */ + then(doneFilter: (value?: T, ...values: any[]) => void, failFilter?: (...reasons: any[]) => any, progressFilter?: (...progression: any[]) => any): JQueryPromise<void>; +} + +/** + * Interface for the JQuery promise/deferred callbacks + */ +interface JQueryPromiseCallback<T> { + (value?: T, ...args: any[]): void; +} + +interface JQueryPromiseOperator<T, U> { + (callback1: JQueryPromiseCallback<T>|JQueryPromiseCallback<T>[], ...callbacksN: Array<JQueryPromiseCallback<any>|JQueryPromiseCallback<any>[]>): JQueryPromise<U>; +} + +/** + * Interface for the JQuery promise, part of callbacks + */ +interface JQueryPromise<T> extends JQueryGenericPromise<T> { + /** + * Determine the current state of a Deferred object. + */ + state(): string; + /** + * Add handlers to be called when the Deferred object is either resolved or rejected. + * + * @param alwaysCallbacks1 A function, or array of functions, that is called when the Deferred is resolved or rejected. + * @param alwaysCallbacks2 Optional additional functions, or arrays of functions, that are called when the Deferred is resolved or rejected. + */ + always(alwaysCallback1?: JQueryPromiseCallback<any>|JQueryPromiseCallback<any>[], ...alwaysCallbacksN: Array<JQueryPromiseCallback<any>|JQueryPromiseCallback<any>[]>): JQueryPromise<T>; + /** + * Add handlers to be called when the Deferred object is resolved. + * + * @param doneCallbacks1 A function, or array of functions, that are called when the Deferred is resolved. + * @param doneCallbacks2 Optional additional functions, or arrays of functions, that are called when the Deferred is resolved. + */ + done(doneCallback1?: JQueryPromiseCallback<T>|JQueryPromiseCallback<T>[], ...doneCallbackN: Array<JQueryPromiseCallback<T>|JQueryPromiseCallback<T>[]>): JQueryPromise<T>; + /** + * Add handlers to be called when the Deferred object is rejected. + * + * @param failCallbacks1 A function, or array of functions, that are called when the Deferred is rejected. + * @param failCallbacks2 Optional additional functions, or arrays of functions, that are called when the Deferred is rejected. + */ + fail(failCallback1?: JQueryPromiseCallback<any>|JQueryPromiseCallback<any>[], ...failCallbacksN: Array<JQueryPromiseCallback<any>|JQueryPromiseCallback<any>[]>): JQueryPromise<T>; + /** + * Add handlers to be called when the Deferred object generates progress notifications. + * + * @param progressCallbacks A function, or array of functions, to be called when the Deferred generates progress notifications. + */ + progress(progressCallback1?: JQueryPromiseCallback<any>|JQueryPromiseCallback<any>[], ...progressCallbackN: Array<JQueryPromiseCallback<any>|JQueryPromiseCallback<any>[]>): JQueryPromise<T>; + + // Deprecated - given no typings + pipe(doneFilter?: (x: any) => any, failFilter?: (x: any) => any, progressFilter?: (x: any) => any): JQueryPromise<any>; +} + +/** + * Interface for the JQuery deferred, part of callbacks + */ +interface JQueryDeferred<T> extends JQueryGenericPromise<T> { + /** + * Determine the current state of a Deferred object. + */ + state(): string; + /** + * Add handlers to be called when the Deferred object is either resolved or rejected. + * + * @param alwaysCallbacks1 A function, or array of functions, that is called when the Deferred is resolved or rejected. + * @param alwaysCallbacks2 Optional additional functions, or arrays of functions, that are called when the Deferred is resolved or rejected. + */ + always(alwaysCallback1?: JQueryPromiseCallback<any>|JQueryPromiseCallback<any>[], ...alwaysCallbacksN: Array<JQueryPromiseCallback<any>|JQueryPromiseCallback<any>[]>): JQueryDeferred<T>; + /** + * Add handlers to be called when the Deferred object is resolved. + * + * @param doneCallbacks1 A function, or array of functions, that are called when the Deferred is resolved. + * @param doneCallbacks2 Optional additional functions, or arrays of functions, that are called when the Deferred is resolved. + */ + done(doneCallback1?: JQueryPromiseCallback<T>|JQueryPromiseCallback<T>[], ...doneCallbackN: Array<JQueryPromiseCallback<T>|JQueryPromiseCallback<T>[]>): JQueryDeferred<T>; + /** + * Add handlers to be called when the Deferred object is rejected. + * + * @param failCallbacks1 A function, or array of functions, that are called when the Deferred is rejected. + * @param failCallbacks2 Optional additional functions, or arrays of functions, that are called when the Deferred is rejected. + */ + fail(failCallback1?: JQueryPromiseCallback<any>|JQueryPromiseCallback<any>[], ...failCallbacksN: Array<JQueryPromiseCallback<any>|JQueryPromiseCallback<any>[]>): JQueryDeferred<T>; + /** + * Add handlers to be called when the Deferred object generates progress notifications. + * + * @param progressCallbacks A function, or array of functions, to be called when the Deferred generates progress notifications. + */ + progress(progressCallback1?: JQueryPromiseCallback<any>|JQueryPromiseCallback<any>[], ...progressCallbackN: Array<JQueryPromiseCallback<any>|JQueryPromiseCallback<any>[]>): JQueryDeferred<T>; + + /** + * Call the progressCallbacks on a Deferred object with the given args. + * + * @param args Optional arguments that are passed to the progressCallbacks. + */ + notify(value?: any, ...args: any[]): JQueryDeferred<T>; + + /** + * Call the progressCallbacks on a Deferred object with the given context and args. + * + * @param context Context passed to the progressCallbacks as the this object. + * @param args Optional arguments that are passed to the progressCallbacks. + */ + notifyWith(context: any, value?: any, ...args: any[]): JQueryDeferred<T>; + + /** + * Reject a Deferred object and call any failCallbacks with the given args. + * + * @param args Optional arguments that are passed to the failCallbacks. + */ + reject(value?: any, ...args: any[]): JQueryDeferred<T>; + /** + * Reject a Deferred object and call any failCallbacks with the given context and args. + * + * @param context Context passed to the failCallbacks as the this object. + * @param args An optional array of arguments that are passed to the failCallbacks. + */ + rejectWith(context: any, value?: any, ...args: any[]): JQueryDeferred<T>; + + /** + * Resolve a Deferred object and call any doneCallbacks with the given args. + * + * @param value First argument passed to doneCallbacks. + * @param args Optional subsequent arguments that are passed to the doneCallbacks. + */ + resolve(value?: T, ...args: any[]): JQueryDeferred<T>; + + /** + * Resolve a Deferred object and call any doneCallbacks with the given context and args. + * + * @param context Context passed to the doneCallbacks as the this object. + * @param args An optional array of arguments that are passed to the doneCallbacks. + */ + resolveWith(context: any, value?: T, ...args: any[]): JQueryDeferred<T>; + + /** + * Return a Deferred's Promise object. + * + * @param target Object onto which the promise methods have to be attached + */ + promise(target?: any): JQueryPromise<T>; + + // Deprecated - given no typings + pipe(doneFilter?: (x: any) => any, failFilter?: (x: any) => any, progressFilter?: (x: any) => any): JQueryPromise<any>; +} + +/** + * Interface of the JQuery extension of the W3C event object + */ +interface BaseJQueryEventObject extends Event { + data: any; + delegateTarget: Element; + isDefaultPrevented(): boolean; + isImmediatePropagationStopped(): boolean; + isPropagationStopped(): boolean; + namespace: string; + originalEvent: Event; + preventDefault(): any; + relatedTarget: Element; + result: any; + stopImmediatePropagation(): void; + stopPropagation(): void; + target: Element; + pageX: number; + pageY: number; + which: number; + metaKey: boolean; +} + +interface JQueryInputEventObject extends BaseJQueryEventObject { + altKey: boolean; + ctrlKey: boolean; + metaKey: boolean; + shiftKey: boolean; +} + +interface JQueryMouseEventObject extends JQueryInputEventObject { + button: number; + clientX: number; + clientY: number; + offsetX: number; + offsetY: number; + pageX: number; + pageY: number; + screenX: number; + screenY: number; +} + +interface JQueryKeyEventObject extends JQueryInputEventObject { + char: any; + charCode: number; + key: any; + keyCode: number; +} + +interface JQueryEventObject extends BaseJQueryEventObject, JQueryInputEventObject, JQueryMouseEventObject, JQueryKeyEventObject{ +} + +/* + Collection of properties of the current browser +*/ + +interface JQuerySupport { + ajax?: boolean; + boxModel?: boolean; + changeBubbles?: boolean; + checkClone?: boolean; + checkOn?: boolean; + cors?: boolean; + cssFloat?: boolean; + hrefNormalized?: boolean; + htmlSerialize?: boolean; + leadingWhitespace?: boolean; + noCloneChecked?: boolean; + noCloneEvent?: boolean; + opacity?: boolean; + optDisabled?: boolean; + optSelected?: boolean; + scriptEval? (): boolean; + style?: boolean; + submitBubbles?: boolean; + tbody?: boolean; +} + +interface JQueryParam { + /** + * Create a serialized representation of an array or object, suitable for use in a URL query string or Ajax request. + * + * @param obj An array or object to serialize. + */ + (obj: any): string; + + /** + * Create a serialized representation of an array or object, suitable for use in a URL query string or Ajax request. + * + * @param obj An array or object to serialize. + * @param traditional A Boolean indicating whether to perform a traditional "shallow" serialization. + */ + (obj: any, traditional: boolean): string; +} + +/** + * The interface used to construct jQuery events (with $.Event). It is + * defined separately instead of inline in JQueryStatic to allow + * overriding the construction function with specific strings + * returning specific event objects. + */ +interface JQueryEventConstructor { + (name: string, eventProperties?: any): JQueryEventObject; + new (name: string, eventProperties?: any): JQueryEventObject; +} + +/** + * The interface used to specify coordinates. + */ +interface JQueryCoordinates { + left: number; + top: number; +} + +/** + * Elements in the array returned by serializeArray() + */ +interface JQuerySerializeArrayElement { + name: string; + value: string; +} + +interface JQueryAnimationOptions { + /** + * A string or number determining how long the animation will run. + */ + duration?: any; + /** + * A string indicating which easing function to use for the transition. + */ + easing?: string; + /** + * A function to call once the animation is complete. + */ + complete?: Function; + /** + * A function to be called for each animated property of each animated element. This function provides an opportunity to modify the Tween object to change the value of the property before it is set. + */ + step?: (now: number, tween: any) => any; + /** + * A function to be called after each step of the animation, only once per animated element regardless of the number of animated properties. (version added: 1.8) + */ + progress?: (animation: JQueryPromise<any>, progress: number, remainingMs: number) => any; + /** + * A function to call when the animation begins. (version added: 1.8) + */ + start?: (animation: JQueryPromise<any>) => any; + /** + * A function to be called when the animation completes (its Promise object is resolved). (version added: 1.8) + */ + done?: (animation: JQueryPromise<any>, jumpedToEnd: boolean) => any; + /** + * A function to be called when the animation fails to complete (its Promise object is rejected). (version added: 1.8) + */ + fail?: (animation: JQueryPromise<any>, jumpedToEnd: boolean) => any; + /** + * A function to be called when the animation completes or stops without completing (its Promise object is either resolved or rejected). (version added: 1.8) + */ + always?: (animation: JQueryPromise<any>, jumpedToEnd: boolean) => any; + /** + * A Boolean indicating whether to place the animation in the effects queue. If false, the animation will begin immediately. As of jQuery 1.7, the queue option can also accept a string, in which case the animation is added to the queue represented by that string. When a custom queue name is used the animation does not automatically start; you must call .dequeue("queuename") to start it. + */ + queue?: any; + /** + * A map of one or more of the CSS properties defined by the properties argument and their corresponding easing functions. (version added: 1.4) + */ + specialEasing?: Object; +} + +/** + * Static members of jQuery (those on $ and jQuery themselves) + */ +interface JQueryStatic { + + /** + * Perform an asynchronous HTTP (Ajax) request. + * + * @param settings A set of key/value pairs that configure the Ajax request. All settings are optional. A default can be set for any option with $.ajaxSetup(). + */ + ajax(settings: JQueryAjaxSettings): JQueryXHR; + /** + * Perform an asynchronous HTTP (Ajax) request. + * + * @param url A string containing the URL to which the request is sent. + * @param settings A set of key/value pairs that configure the Ajax request. All settings are optional. A default can be set for any option with $.ajaxSetup(). + */ + ajax(url: string, settings?: JQueryAjaxSettings): JQueryXHR; + + /** + * Handle custom Ajax options or modify existing options before each request is sent and before they are processed by $.ajax(). + * + * @param dataTypes An optional string containing one or more space-separated dataTypes + * @param handler A handler to set default values for future Ajax requests. + */ + ajaxPrefilter(dataTypes: string, handler: (opts: any, originalOpts: JQueryAjaxSettings, jqXHR: JQueryXHR) => any): void; + /** + * Handle custom Ajax options or modify existing options before each request is sent and before they are processed by $.ajax(). + * + * @param handler A handler to set default values for future Ajax requests. + */ + ajaxPrefilter(handler: (opts: any, originalOpts: JQueryAjaxSettings, jqXHR: JQueryXHR) => any): void; + + ajaxSettings: JQueryAjaxSettings; + + /** + * Set default values for future Ajax requests. Its use is not recommended. + * + * @param options A set of key/value pairs that configure the default Ajax request. All options are optional. + */ + ajaxSetup(options: JQueryAjaxSettings): void; + + /** + * Load data from the server using a HTTP GET request. + * + * @param url A string containing the URL to which the request is sent. + * @param success A callback function that is executed if the request succeeds. + * @param dataType The type of data expected from the server. Default: Intelligent Guess (xml, json, script, or html). + */ + get(url: string, success?: (data: any, textStatus: string, jqXHR: JQueryXHR) => any, dataType?: string): JQueryXHR; + /** + * Load data from the server using a HTTP GET request. + * + * @param url A string containing the URL to which the request is sent. + * @param data A plain object or string that is sent to the server with the request. + * @param success A callback function that is executed if the request succeeds. + * @param dataType The type of data expected from the server. Default: Intelligent Guess (xml, json, script, or html). + */ + get(url: string, data?: Object|string, success?: (data: any, textStatus: string, jqXHR: JQueryXHR) => any, dataType?: string): JQueryXHR; + /** + * Load JSON-encoded data from the server using a GET HTTP request. + * + * @param url A string containing the URL to which the request is sent. + * @param success A callback function that is executed if the request succeeds. + */ + getJSON(url: string, success?: (data: any, textStatus: string, jqXHR: JQueryXHR) => any): JQueryXHR; + /** + * Load JSON-encoded data from the server using a GET HTTP request. + * + * @param url A string containing the URL to which the request is sent. + * @param data A plain object or string that is sent to the server with the request. + * @param success A callback function that is executed if the request succeeds. + */ + getJSON(url: string, data?: Object|string, success?: (data: any, textStatus: string, jqXHR: JQueryXHR) => any): JQueryXHR; + /** + * Load a JavaScript file from the server using a GET HTTP request, then execute it. + * + * @param url A string containing the URL to which the request is sent. + * @param success A callback function that is executed if the request succeeds. + */ + getScript(url: string, success?: (script: string, textStatus: string, jqXHR: JQueryXHR) => any): JQueryXHR; + + /** + * Create a serialized representation of an array or object, suitable for use in a URL query string or Ajax request. + */ + param: JQueryParam; + + /** + * Load data from the server using a HTTP POST request. + * + * @param url A string containing the URL to which the request is sent. + * @param success A callback function that is executed if the request succeeds. Required if dataType is provided, but can be null in that case. + * @param dataType The type of data expected from the server. Default: Intelligent Guess (xml, json, script, text, html). + */ + post(url: string, success?: (data: any, textStatus: string, jqXHR: JQueryXHR) => any, dataType?: string): JQueryXHR; + /** + * Load data from the server using a HTTP POST request. + * + * @param url A string containing the URL to which the request is sent. + * @param data A plain object or string that is sent to the server with the request. + * @param success A callback function that is executed if the request succeeds. Required if dataType is provided, but can be null in that case. + * @param dataType The type of data expected from the server. Default: Intelligent Guess (xml, json, script, text, html). + */ + post(url: string, data?: Object|string, success?: (data: any, textStatus: string, jqXHR: JQueryXHR) => any, dataType?: string): JQueryXHR; + + /** + * A multi-purpose callbacks list object that provides a powerful way to manage callback lists. + * + * @param flags An optional list of space-separated flags that change how the callback list behaves. + */ + Callbacks(flags?: string): JQueryCallback; + + /** + * Holds or releases the execution of jQuery's ready event. + * + * @param hold Indicates whether the ready hold is being requested or released + */ + holdReady(hold: boolean): void; + + /** + * Accepts a string containing a CSS selector which is then used to match a set of elements. + * + * @param selector A string containing a selector expression + * @param context A DOM Element, Document, or jQuery to use as context + */ + (selector: string, context?: Element|JQuery): JQuery; + + /** + * Accepts a string containing a CSS selector which is then used to match a set of elements. + * + * @param element A DOM element to wrap in a jQuery object. + */ + (element: Element): JQuery; + + /** + * Accepts a string containing a CSS selector which is then used to match a set of elements. + * + * @param elementArray An array containing a set of DOM elements to wrap in a jQuery object. + */ + (elementArray: Element[]): JQuery; + + /** + * Binds a function to be executed when the DOM has finished loading. + * + * @param callback A function to execute after the DOM is ready. + */ + (callback: (jQueryAlias?: JQueryStatic) => any): JQuery; + + /** + * Accepts a string containing a CSS selector which is then used to match a set of elements. + * + * @param object A plain object to wrap in a jQuery object. + */ + (object: {}): JQuery; + + /** + * Accepts a string containing a CSS selector which is then used to match a set of elements. + * + * @param object An existing jQuery object to clone. + */ + (object: JQuery): JQuery; + + /** + * Specify a function to execute when the DOM is fully loaded. + */ + (): JQuery; + + /** + * Creates DOM elements on the fly from the provided string of raw HTML. + * + * @param html A string of HTML to create on the fly. Note that this parses HTML, not XML. + * @param ownerDocument A document in which the new elements will be created. + */ + (html: string, ownerDocument?: Document): JQuery; + + /** + * Creates DOM elements on the fly from the provided string of raw HTML. + * + * @param html A string defining a single, standalone, HTML element (e.g. <div/> or <div></div>). + * @param attributes An object of attributes, events, and methods to call on the newly-created element. + */ + (html: string, attributes: Object): JQuery; + + /** + * Relinquish jQuery's control of the $ variable. + * + * @param removeAll A Boolean indicating whether to remove all jQuery variables from the global scope (including jQuery itself). + */ + noConflict(removeAll?: boolean): Object; + + /** + * Provides a way to execute callback functions based on one or more objects, usually Deferred objects that represent asynchronous events. + * + * @param deferreds One or more Deferred objects, or plain JavaScript objects. + */ + when<T>(...deferreds: Array<T|JQueryPromise<T>/* as JQueryDeferred<T> */>): JQueryPromise<T>; + + /** + * Hook directly into jQuery to override how particular CSS properties are retrieved or set, normalize CSS property naming, or create custom properties. + */ + cssHooks: { [key: string]: any; }; + cssNumber: any; + + /** + * Store arbitrary data associated with the specified element. Returns the value that was set. + * + * @param element The DOM element to associate with the data. + * @param key A string naming the piece of data to set. + * @param value The new data value. + */ + data<T>(element: Element, key: string, value: T): T; + /** + * Returns value at named data store for the element, as set by jQuery.data(element, name, value), or the full data store for the element. + * + * @param element The DOM element to associate with the data. + * @param key A string naming the piece of data to set. + */ + data(element: Element, key: string): any; + /** + * Returns value at named data store for the element, as set by jQuery.data(element, name, value), or the full data store for the element. + * + * @param element The DOM element to associate with the data. + */ + data(element: Element): any; + + /** + * Execute the next function on the queue for the matched element. + * + * @param element A DOM element from which to remove and execute a queued function. + * @param queueName A string containing the name of the queue. Defaults to fx, the standard effects queue. + */ + dequeue(element: Element, queueName?: string): void; + + /** + * Determine whether an element has any jQuery data associated with it. + * + * @param element A DOM element to be checked for data. + */ + hasData(element: Element): boolean; + + /** + * Show the queue of functions to be executed on the matched element. + * + * @param element A DOM element to inspect for an attached queue. + * @param queueName A string containing the name of the queue. Defaults to fx, the standard effects queue. + */ + queue(element: Element, queueName?: string): any[]; + /** + * Manipulate the queue of functions to be executed on the matched element. + * + * @param element A DOM element where the array of queued functions is attached. + * @param queueName A string containing the name of the queue. Defaults to fx, the standard effects queue. + * @param newQueue An array of functions to replace the current queue contents. + */ + queue(element: Element, queueName: string, newQueue: Function[]): JQuery; + /** + * Manipulate the queue of functions to be executed on the matched element. + * + * @param element A DOM element on which to add a queued function. + * @param queueName A string containing the name of the queue. Defaults to fx, the standard effects queue. + * @param callback The new function to add to the queue. + */ + queue(element: Element, queueName: string, callback: Function): JQuery; + + /** + * Remove a previously-stored piece of data. + * + * @param element A DOM element from which to remove data. + * @param name A string naming the piece of data to remove. + */ + removeData(element: Element, name?: string): JQuery; + + /** + * A constructor function that returns a chainable utility object with methods to register multiple callbacks into callback queues, invoke callback queues, and relay the success or failure state of any synchronous or asynchronous function. + * + * @param beforeStart A function that is called just before the constructor returns. + */ + Deferred<T>(beforeStart?: (deferred: JQueryDeferred<T>) => any): JQueryDeferred<T>; + + /** + * Effects + */ + fx: { + tick: () => void; + /** + * The rate (in milliseconds) at which animations fire. + */ + interval: number; + stop: () => void; + speeds: { slow: number; fast: number; }; + /** + * Globally disable all animations. + */ + off: boolean; + step: any; + }; + + /** + * Takes a function and returns a new one that will always have a particular context. + * + * @param fnction The function whose context will be changed. + * @param context The object to which the context (this) of the function should be set. + * @param additionalArguments Any number of arguments to be passed to the function referenced in the function argument. + */ + proxy(fnction: (...args: any[]) => any, context: Object, ...additionalArguments: any[]): any; + /** + * Takes a function and returns a new one that will always have a particular context. + * + * @param context The object to which the context (this) of the function should be set. + * @param name The name of the function whose context will be changed (should be a property of the context object). + * @param additionalArguments Any number of arguments to be passed to the function named in the name argument. + */ + proxy(context: Object, name: string, ...additionalArguments: any[]): any; + + Event: JQueryEventConstructor; + + /** + * Takes a string and throws an exception containing it. + * + * @param message The message to send out. + */ + error(message: any): JQuery; + + expr: any; + fn: any; //TODO: Decide how we want to type this + + isReady: boolean; + + // Properties + support: JQuerySupport; + + /** + * Check to see if a DOM element is a descendant of another DOM element. + * + * @param container The DOM element that may contain the other element. + * @param contained The DOM element that may be contained by (a descendant of) the other element. + */ + contains(container: Element, contained: Element): boolean; + + /** + * A generic iterator function, which can be used to seamlessly iterate over both objects and arrays. Arrays and array-like objects with a length property (such as a function's arguments object) are iterated by numeric index, from 0 to length-1. Other objects are iterated via their named properties. + * + * @param collection The object or array to iterate over. + * @param callback The function that will be executed on every object. + */ + each<T>( + collection: T[], + callback: (indexInArray: number, valueOfElement: T) => any + ): any; + + /** + * A generic iterator function, which can be used to seamlessly iterate over both objects and arrays. Arrays and array-like objects with a length property (such as a function's arguments object) are iterated by numeric index, from 0 to length-1. Other objects are iterated via their named properties. + * + * @param collection The object or array to iterate over. + * @param callback The function that will be executed on every object. + */ + each( + collection: any, + callback: (indexInArray: any, valueOfElement: any) => any + ): any; + + /** + * Merge the contents of two or more objects together into the first object. + * + * @param target An object that will receive the new properties if additional objects are passed in or that will extend the jQuery namespace if it is the sole argument. + * @param object1 An object containing additional properties to merge in. + * @param objectN Additional objects containing properties to merge in. + */ + extend(target: any, object1?: any, ...objectN: any[]): any; + /** + * Merge the contents of two or more objects together into the first object. + * + * @param deep If true, the merge becomes recursive (aka. deep copy). + * @param target The object to extend. It will receive the new properties. + * @param object1 An object containing additional properties to merge in. + * @param objectN Additional objects containing properties to merge in. + */ + extend(deep: boolean, target: any, object1?: any, ...objectN: any[]): any; + + /** + * Execute some JavaScript code globally. + * + * @param code The JavaScript code to execute. + */ + globalEval(code: string): any; + + /** + * Finds the elements of an array which satisfy a filter function. The original array is not affected. + * + * @param array The array to search through. + * @param func The function to process each item against. The first argument to the function is the item, and the second argument is the index. The function should return a Boolean value. this will be the global window object. + * @param invert If "invert" is false, or not provided, then the function returns an array consisting of all elements for which "callback" returns true. If "invert" is true, then the function returns an array consisting of all elements for which "callback" returns false. + */ + grep<T>(array: T[], func: (elementOfArray: T, indexInArray: number) => boolean, invert?: boolean): T[]; + + /** + * Search for a specified value within an array and return its index (or -1 if not found). + * + * @param value The value to search for. + * @param array An array through which to search. + * @param fromIndex he index of the array at which to begin the search. The default is 0, which will search the whole array. + */ + inArray<T>(value: T, array: T[], fromIndex?: number): number; + + /** + * Determine whether the argument is an array. + * + * @param obj Object to test whether or not it is an array. + */ + isArray(obj: any): boolean; + /** + * Check to see if an object is empty (contains no enumerable properties). + * + * @param obj The object that will be checked to see if it's empty. + */ + isEmptyObject(obj: any): boolean; + /** + * Determine if the argument passed is a Javascript function object. + * + * @param obj Object to test whether or not it is a function. + */ + isFunction(obj: any): boolean; + /** + * Determines whether its argument is a number. + * + * @param obj The value to be tested. + */ + isNumeric(value: any): boolean; + /** + * Check to see if an object is a plain object (created using "{}" or "new Object"). + * + * @param obj The object that will be checked to see if it's a plain object. + */ + isPlainObject(obj: any): boolean; + /** + * Determine whether the argument is a window. + * + * @param obj Object to test whether or not it is a window. + */ + isWindow(obj: any): boolean; + /** + * Check to see if a DOM node is within an XML document (or is an XML document). + * + * @param node he DOM node that will be checked to see if it's in an XML document. + */ + isXMLDoc(node: Node): boolean; + + /** + * Convert an array-like object into a true JavaScript array. + * + * @param obj Any object to turn into a native Array. + */ + makeArray(obj: any): any[]; + + /** + * Translate all items in an array or object to new array of items. + * + * @param array The Array to translate. + * @param callback The function to process each item against. The first argument to the function is the array item, the second argument is the index in array The function can return any value. Within the function, this refers to the global (window) object. + */ + map<T, U>(array: T[], callback: (elementOfArray: T, indexInArray: number) => U): U[]; + /** + * Translate all items in an array or object to new array of items. + * + * @param arrayOrObject The Array or Object to translate. + * @param callback The function to process each item against. The first argument to the function is the value; the second argument is the index or key of the array or object property. The function can return any value to add to the array. A returned array will be flattened into the resulting array. Within the function, this refers to the global (window) object. + */ + map(arrayOrObject: any, callback: (value: any, indexOrKey: any) => any): any; + + /** + * Merge the contents of two arrays together into the first array. + * + * @param first The first array to merge, the elements of second added. + * @param second The second array to merge into the first, unaltered. + */ + merge<T>(first: T[], second: T[]): T[]; + + /** + * An empty function. + */ + noop(): any; + + /** + * Return a number representing the current time. + */ + now(): number; + + /** + * Takes a well-formed JSON string and returns the resulting JavaScript object. + * + * @param json The JSON string to parse. + */ + parseJSON(json: string): any; + + /** + * Parses a string into an XML document. + * + * @param data a well-formed XML string to be parsed + */ + parseXML(data: string): XMLDocument; + + /** + * Remove the whitespace from the beginning and end of a string. + * + * @param str Remove the whitespace from the beginning and end of a string. + */ + trim(str: string): string; + + /** + * Determine the internal JavaScript [[Class]] of an object. + * + * @param obj Object to get the internal JavaScript [[Class]] of. + */ + type(obj: any): string; + + /** + * Sorts an array of DOM elements, in place, with the duplicates removed. Note that this only works on arrays of DOM elements, not strings or numbers. + * + * @param array The Array of DOM elements. + */ + unique(array: Element[]): Element[]; + + /** + * Parses a string into an array of DOM nodes. + * + * @param data HTML string to be parsed + * @param context DOM element to serve as the context in which the HTML fragment will be created + * @param keepScripts A Boolean indicating whether to include scripts passed in the HTML string + */ + parseHTML(data: string, context?: HTMLElement, keepScripts?: boolean): any[]; + + /** + * Parses a string into an array of DOM nodes. + * + * @param data HTML string to be parsed + * @param context DOM element to serve as the context in which the HTML fragment will be created + * @param keepScripts A Boolean indicating whether to include scripts passed in the HTML string + */ + parseHTML(data: string, context?: Document, keepScripts?: boolean): any[]; +} + +/** + * The jQuery instance members + */ +interface JQuery { + /** + * Register a handler to be called when Ajax requests complete. This is an AjaxEvent. + * + * @param handler The function to be invoked. + */ + ajaxComplete(handler: (event: JQueryEventObject, XMLHttpRequest: XMLHttpRequest, ajaxOptions: any) => any): JQuery; + /** + * Register a handler to be called when Ajax requests complete with an error. This is an Ajax Event. + * + * @param handler The function to be invoked. + */ + ajaxError(handler: (event: JQueryEventObject, jqXHR: JQueryXHR, ajaxSettings: JQueryAjaxSettings, thrownError: any) => any): JQuery; + /** + * Attach a function to be executed before an Ajax request is sent. This is an Ajax Event. + * + * @param handler The function to be invoked. + */ + ajaxSend(handler: (event: JQueryEventObject, jqXHR: JQueryXHR, ajaxOptions: JQueryAjaxSettings) => any): JQuery; + /** + * Register a handler to be called when the first Ajax request begins. This is an Ajax Event. + * + * @param handler The function to be invoked. + */ + ajaxStart(handler: () => any): JQuery; + /** + * Register a handler to be called when all Ajax requests have completed. This is an Ajax Event. + * + * @param handler The function to be invoked. + */ + ajaxStop(handler: () => any): JQuery; + /** + * Attach a function to be executed whenever an Ajax request completes successfully. This is an Ajax Event. + * + * @param handler The function to be invoked. + */ + ajaxSuccess(handler: (event: JQueryEventObject, XMLHttpRequest: XMLHttpRequest, ajaxOptions: JQueryAjaxSettings) => any): JQuery; + + /** + * Load data from the server and place the returned HTML into the matched element. + * + * @param url A string containing the URL to which the request is sent. + * @param data A plain object or string that is sent to the server with the request. + * @param complete A callback function that is executed when the request completes. + */ + load(url: string, data?: string|Object, complete?: (responseText: string, textStatus: string, XMLHttpRequest: XMLHttpRequest) => any): JQuery; + + /** + * Encode a set of form elements as a string for submission. + */ + serialize(): string; + /** + * Encode a set of form elements as an array of names and values. + */ + serializeArray(): JQuerySerializeArrayElement[]; + + /** + * Adds the specified class(es) to each of the set of matched elements. + * + * @param className One or more space-separated classes to be added to the class attribute of each matched element. + */ + addClass(className: string): JQuery; + /** + * Adds the specified class(es) to each of the set of matched elements. + * + * @param function A function returning one or more space-separated class names to be added to the existing class name(s). Receives the index position of the element in the set and the existing class name(s) as arguments. Within the function, this refers to the current element in the set. + */ + addClass(func: (index: number, className: string) => string): JQuery; + + /** + * Add the previous set of elements on the stack to the current set, optionally filtered by a selector. + */ + addBack(selector?: string): JQuery; + + /** + * Get the value of an attribute for the first element in the set of matched elements. + * + * @param attributeName The name of the attribute to get. + */ + attr(attributeName: string): string; + /** + * Set one or more attributes for the set of matched elements. + * + * @param attributeName The name of the attribute to set. + * @param value A value to set for the attribute. + */ + attr(attributeName: string, value: string|number): JQuery; + /** + * Set one or more attributes for the set of matched elements. + * + * @param attributeName The name of the attribute to set. + * @param func A function returning the value to set. this is the current element. Receives the index position of the element in the set and the old attribute value as arguments. + */ + attr(attributeName: string, func: (index: number, attr: string) => string|number): JQuery; + /** + * Set one or more attributes for the set of matched elements. + * + * @param attributes An object of attribute-value pairs to set. + */ + attr(attributes: Object): JQuery; + + /** + * Determine whether any of the matched elements are assigned the given class. + * + * @param className The class name to search for. + */ + hasClass(className: string): boolean; + + /** + * Get the HTML contents of the first element in the set of matched elements. + */ + html(): string; + /** + * Set the HTML contents of each element in the set of matched elements. + * + * @param htmlString A string of HTML to set as the content of each matched element. + */ + html(htmlString: string): JQuery; + /** + * Set the HTML contents of each element in the set of matched elements. + * + * @param func A function returning the HTML content to set. Receives the index position of the element in the set and the old HTML value as arguments. jQuery empties the element before calling the function; use the oldhtml argument to reference the previous content. Within the function, this refers to the current element in the set. + */ + html(func: (index: number, oldhtml: string) => string): JQuery; + /** + * Set the HTML contents of each element in the set of matched elements. + * + * @param func A function returning the HTML content to set. Receives the index position of the element in the set and the old HTML value as arguments. jQuery empties the element before calling the function; use the oldhtml argument to reference the previous content. Within the function, this refers to the current element in the set. + */ + + /** + * Get the value of a property for the first element in the set of matched elements. + * + * @param propertyName The name of the property to get. + */ + prop(propertyName: string): any; + /** + * Set one or more properties for the set of matched elements. + * + * @param propertyName The name of the property to set. + * @param value A value to set for the property. + */ + prop(propertyName: string, value: string|number|boolean): JQuery; + /** + * Set one or more properties for the set of matched elements. + * + * @param properties An object of property-value pairs to set. + */ + prop(properties: Object): JQuery; + /** + * Set one or more properties for the set of matched elements. + * + * @param propertyName The name of the property to set. + * @param func A function returning the value to set. Receives the index position of the element in the set and the old property value as arguments. Within the function, the keyword this refers to the current element. + */ + prop(propertyName: string, func: (index: number, oldPropertyValue: any) => any): JQuery; + + /** + * Remove an attribute from each element in the set of matched elements. + * + * @param attributeName An attribute to remove; as of version 1.7, it can be a space-separated list of attributes. + */ + removeAttr(attributeName: string): JQuery; + + /** + * Remove a single class, multiple classes, or all classes from each element in the set of matched elements. + * + * @param className One or more space-separated classes to be removed from the class attribute of each matched element. + */ + removeClass(className?: string): JQuery; + /** + * Remove a single class, multiple classes, or all classes from each element in the set of matched elements. + * + * @param function A function returning one or more space-separated class names to be removed. Receives the index position of the element in the set and the old class value as arguments. + */ + removeClass(func: (index: number, className: string) => string): JQuery; + + /** + * Remove a property for the set of matched elements. + * + * @param propertyName The name of the property to remove. + */ + removeProp(propertyName: string): JQuery; + + /** + * Add or remove one or more classes from each element in the set of matched elements, depending on either the class's presence or the value of the switch argument. + * + * @param className One or more class names (separated by spaces) to be toggled for each element in the matched set. + * @param swtch A Boolean (not just truthy/falsy) value to determine whether the class should be added or removed. + */ + toggleClass(className: string, swtch?: boolean): JQuery; + /** + * Add or remove one or more classes from each element in the set of matched elements, depending on either the class's presence or the value of the switch argument. + * + * @param swtch A boolean value to determine whether the class should be added or removed. + */ + toggleClass(swtch?: boolean): JQuery; + /** + * Add or remove one or more classes from each element in the set of matched elements, depending on either the class's presence or the value of the switch argument. + * + * @param func A function that returns class names to be toggled in the class attribute of each element in the matched set. Receives the index position of the element in the set, the old class value, and the switch as arguments. + * @param swtch A boolean value to determine whether the class should be added or removed. + */ + toggleClass(func: (index: number, className: string, swtch: boolean) => string, swtch?: boolean): JQuery; + + /** + * Get the current value of the first element in the set of matched elements. + */ + val(): any; + /** + * Set the value of each element in the set of matched elements. + * + * @param value A string of text or an array of strings corresponding to the value of each matched element to set as selected/checked. + */ + val(value: string|string[]): JQuery; + /** + * Set the value of each element in the set of matched elements. + * + * @param func A function returning the value to set. this is the current element. Receives the index position of the element in the set and the old value as arguments. + */ + val(func: (index: number, value: string) => string): JQuery; + + + /** + * Get the value of style properties for the first element in the set of matched elements. + * + * @param propertyName A CSS property. + */ + css(propertyName: string): string; + /** + * Set one or more CSS properties for the set of matched elements. + * + * @param propertyName A CSS property name. + * @param value A value to set for the property. + */ + css(propertyName: string, value: string|number): JQuery; + /** + * Set one or more CSS properties for the set of matched elements. + * + * @param propertyName A CSS property name. + * @param value A function returning the value to set. this is the current element. Receives the index position of the element in the set and the old value as arguments. + */ + css(propertyName: string, value: (index: number, value: string) => string|number): JQuery; + /** + * Set one or more CSS properties for the set of matched elements. + * + * @param properties An object of property-value pairs to set. + */ + css(properties: Object): JQuery; + + /** + * Get the current computed height for the first element in the set of matched elements. + */ + height(): number; + /** + * Set the CSS height of every matched element. + * + * @param value An integer representing the number of pixels, or an integer with an optional unit of measure appended (as a string). + */ + height(value: number|string): JQuery; + /** + * Set the CSS height of every matched element. + * + * @param func A function returning the height to set. Receives the index position of the element in the set and the old height as arguments. Within the function, this refers to the current element in the set. + */ + height(func: (index: number, height: number) => number|string): JQuery; + + /** + * Get the current computed height for the first element in the set of matched elements, including padding but not border. + */ + innerHeight(): number; + + /** + * Sets the inner height on elements in the set of matched elements, including padding but not border. + * + * @param value An integer representing the number of pixels, or an integer along with an optional unit of measure appended (as a string). + */ + innerHeight(height: number|string): JQuery; + + /** + * Get the current computed width for the first element in the set of matched elements, including padding but not border. + */ + innerWidth(): number; + + /** + * Sets the inner width on elements in the set of matched elements, including padding but not border. + * + * @param value An integer representing the number of pixels, or an integer along with an optional unit of measure appended (as a string). + */ + innerWidth(width: number|string): JQuery; + + /** + * Get the current coordinates of the first element in the set of matched elements, relative to the document. + */ + offset(): JQueryCoordinates; + /** + * An object containing the properties top and left, which are integers indicating the new top and left coordinates for the elements. + * + * @param coordinates An object containing the properties top and left, which are integers indicating the new top and left coordinates for the elements. + */ + offset(coordinates: JQueryCoordinates): JQuery; + /** + * An object containing the properties top and left, which are integers indicating the new top and left coordinates for the elements. + * + * @param func A function to return the coordinates to set. Receives the index of the element in the collection as the first argument and the current coordinates as the second argument. The function should return an object with the new top and left properties. + */ + offset(func: (index: number, coords: JQueryCoordinates) => JQueryCoordinates): JQuery; + + /** + * Get the current computed height for the first element in the set of matched elements, including padding, border, and optionally margin. Returns an integer (without "px") representation of the value or null if called on an empty set of elements. + * + * @param includeMargin A Boolean indicating whether to include the element's margin in the calculation. + */ + outerHeight(includeMargin?: boolean): number; + + /** + * Sets the outer height on elements in the set of matched elements, including padding and border. + * + * @param value An integer representing the number of pixels, or an integer along with an optional unit of measure appended (as a string). + */ + outerHeight(height: number|string): JQuery; + + /** + * Get the current computed width for the first element in the set of matched elements, including padding and border. + * + * @param includeMargin A Boolean indicating whether to include the element's margin in the calculation. + */ + outerWidth(includeMargin?: boolean): number; + + /** + * Sets the outer width on elements in the set of matched elements, including padding and border. + * + * @param value An integer representing the number of pixels, or an integer along with an optional unit of measure appended (as a string). + */ + outerWidth(width: number|string): JQuery; + + /** + * Get the current coordinates of the first element in the set of matched elements, relative to the offset parent. + */ + position(): JQueryCoordinates; + + /** + * Get the current horizontal position of the scroll bar for the first element in the set of matched elements or set the horizontal position of the scroll bar for every matched element. + */ + scrollLeft(): number; + /** + * Set the current horizontal position of the scroll bar for each of the set of matched elements. + * + * @param value An integer indicating the new position to set the scroll bar to. + */ + scrollLeft(value: number): JQuery; + + /** + * Get the current vertical position of the scroll bar for the first element in the set of matched elements or set the vertical position of the scroll bar for every matched element. + */ + scrollTop(): number; + /** + * Set the current vertical position of the scroll bar for each of the set of matched elements. + * + * @param value An integer indicating the new position to set the scroll bar to. + */ + scrollTop(value: number): JQuery; + + /** + * Get the current computed width for the first element in the set of matched elements. + */ + width(): number; + /** + * Set the CSS width of each element in the set of matched elements. + * + * @param value An integer representing the number of pixels, or an integer along with an optional unit of measure appended (as a string). + */ + width(value: number|string): JQuery; + /** + * Set the CSS width of each element in the set of matched elements. + * + * @param func A function returning the width to set. Receives the index position of the element in the set and the old width as arguments. Within the function, this refers to the current element in the set. + */ + width(func: (index: number, width: number) => number|string): JQuery; + + /** + * Remove from the queue all items that have not yet been run. + * + * @param queueName A string containing the name of the queue. Defaults to fx, the standard effects queue. + */ + clearQueue(queueName?: string): JQuery; + + /** + * Store arbitrary data associated with the matched elements. + * + * @param key A string naming the piece of data to set. + * @param value The new data value; it can be any Javascript type including Array or Object. + */ + data(key: string, value: any): JQuery; + /** + * Store arbitrary data associated with the matched elements. + * + * @param obj An object of key-value pairs of data to update. + */ + data(obj: { [key: string]: any; }): JQuery; + /** + * Return the value at the named data store for the first element in the jQuery collection, as set by data(name, value) or by an HTML5 data-* attribute. + * + * @param key Name of the data stored. + */ + data(key: string): any; + /** + * Return the value at the named data store for the first element in the jQuery collection, as set by data(name, value) or by an HTML5 data-* attribute. + */ + data(): any; + + /** + * Execute the next function on the queue for the matched elements. + * + * @param queueName A string containing the name of the queue. Defaults to fx, the standard effects queue. + */ + dequeue(queueName?: string): JQuery; + + /** + * Remove a previously-stored piece of data. + * + * @param name A string naming the piece of data to delete or space-separated string naming the pieces of data to delete. + */ + removeData(name: string): JQuery; + /** + * Remove a previously-stored piece of data. + * + * @param list An array of strings naming the pieces of data to delete. + */ + removeData(list: string[]): JQuery; + + /** + * Return a Promise object to observe when all actions of a certain type bound to the collection, queued or not, have finished. + * + * @param type The type of queue that needs to be observed. (default: fx) + * @param target Object onto which the promise methods have to be attached + */ + promise(type?: string, target?: Object): JQueryPromise<any>; + + /** + * Perform a custom animation of a set of CSS properties. + * + * @param properties An object of CSS properties and values that the animation will move toward. + * @param duration A string or number determining how long the animation will run. + * @param complete A function to call once the animation is complete. + */ + animate(properties: Object, duration?: string|number, complete?: Function): JQuery; + /** + * Perform a custom animation of a set of CSS properties. + * + * @param properties An object of CSS properties and values that the animation will move toward. + * @param duration A string or number determining how long the animation will run. + * @param easing A string indicating which easing function to use for the transition. (default: swing) + * @param complete A function to call once the animation is complete. + */ + animate(properties: Object, duration?: string|number, easing?: string, complete?: Function): JQuery; + /** + * Perform a custom animation of a set of CSS properties. + * + * @param properties An object of CSS properties and values that the animation will move toward. + * @param options A map of additional options to pass to the method. + */ + animate(properties: Object, options: JQueryAnimationOptions): JQuery; + + /** + * Set a timer to delay execution of subsequent items in the queue. + * + * @param duration An integer indicating the number of milliseconds to delay execution of the next item in the queue. + * @param queueName A string containing the name of the queue. Defaults to fx, the standard effects queue. + */ + delay(duration: number, queueName?: string): JQuery; + + /** + * Display the matched elements by fading them to opaque. + * + * @param duration A string or number determining how long the animation will run. + * @param complete A function to call once the animation is complete. + */ + fadeIn(duration?: number|string, complete?: Function): JQuery; + /** + * Display the matched elements by fading them to opaque. + * + * @param duration A string or number determining how long the animation will run. + * @param easing A string indicating which easing function to use for the transition. + * @param complete A function to call once the animation is complete. + */ + fadeIn(duration?: number|string, easing?: string, complete?: Function): JQuery; + /** + * Display the matched elements by fading them to opaque. + * + * @param options A map of additional options to pass to the method. + */ + fadeIn(options: JQueryAnimationOptions): JQuery; + + /** + * Hide the matched elements by fading them to transparent. + * + * @param duration A string or number determining how long the animation will run. + * @param complete A function to call once the animation is complete. + */ + fadeOut(duration?: number|string, complete?: Function): JQuery; + /** + * Hide the matched elements by fading them to transparent. + * + * @param duration A string or number determining how long the animation will run. + * @param easing A string indicating which easing function to use for the transition. + * @param complete A function to call once the animation is complete. + */ + fadeOut(duration?: number|string, easing?: string, complete?: Function): JQuery; + /** + * Hide the matched elements by fading them to transparent. + * + * @param options A map of additional options to pass to the method. + */ + fadeOut(options: JQueryAnimationOptions): JQuery; + + /** + * Adjust the opacity of the matched elements. + * + * @param duration A string or number determining how long the animation will run. + * @param opacity A number between 0 and 1 denoting the target opacity. + * @param complete A function to call once the animation is complete. + */ + fadeTo(duration: string|number, opacity: number, complete?: Function): JQuery; + /** + * Adjust the opacity of the matched elements. + * + * @param duration A string or number determining how long the animation will run. + * @param opacity A number between 0 and 1 denoting the target opacity. + * @param easing A string indicating which easing function to use for the transition. + * @param complete A function to call once the animation is complete. + */ + fadeTo(duration: string|number, opacity: number, easing?: string, complete?: Function): JQuery; + + /** + * Display or hide the matched elements by animating their opacity. + * + * @param duration A string or number determining how long the animation will run. + * @param complete A function to call once the animation is complete. + */ + fadeToggle(duration?: number|string, complete?: Function): JQuery; + /** + * Display or hide the matched elements by animating their opacity. + * + * @param duration A string or number determining how long the animation will run. + * @param easing A string indicating which easing function to use for the transition. + * @param complete A function to call once the animation is complete. + */ + fadeToggle(duration?: number|string, easing?: string, complete?: Function): JQuery; + /** + * Display or hide the matched elements by animating their opacity. + * + * @param options A map of additional options to pass to the method. + */ + fadeToggle(options: JQueryAnimationOptions): JQuery; + + /** + * Stop the currently-running animation, remove all queued animations, and complete all animations for the matched elements. + * + * @param queue The name of the queue in which to stop animations. + */ + finish(queue?: string): JQuery; + + /** + * Hide the matched elements. + * + * @param duration A string or number determining how long the animation will run. + * @param complete A function to call once the animation is complete. + */ + hide(duration?: number|string, complete?: Function): JQuery; + /** + * Hide the matched elements. + * + * @param duration A string or number determining how long the animation will run. + * @param easing A string indicating which easing function to use for the transition. + * @param complete A function to call once the animation is complete. + */ + hide(duration?: number|string, easing?: string, complete?: Function): JQuery; + /** + * Hide the matched elements. + * + * @param options A map of additional options to pass to the method. + */ + hide(options: JQueryAnimationOptions): JQuery; + + /** + * Display the matched elements. + * + * @param duration A string or number determining how long the animation will run. + * @param complete A function to call once the animation is complete. + */ + show(duration?: number|string, complete?: Function): JQuery; + /** + * Display the matched elements. + * + * @param duration A string or number determining how long the animation will run. + * @param easing A string indicating which easing function to use for the transition. + * @param complete A function to call once the animation is complete. + */ + show(duration?: number|string, easing?: string, complete?: Function): JQuery; + /** + * Display the matched elements. + * + * @param options A map of additional options to pass to the method. + */ + show(options: JQueryAnimationOptions): JQuery; + + /** + * Display the matched elements with a sliding motion. + * + * @param duration A string or number determining how long the animation will run. + * @param complete A function to call once the animation is complete. + */ + slideDown(duration?: number|string, complete?: Function): JQuery; + /** + * Display the matched elements with a sliding motion. + * + * @param duration A string or number determining how long the animation will run. + * @param easing A string indicating which easing function to use for the transition. + * @param complete A function to call once the animation is complete. + */ + slideDown(duration?: number|string, easing?: string, complete?: Function): JQuery; + /** + * Display the matched elements with a sliding motion. + * + * @param options A map of additional options to pass to the method. + */ + slideDown(options: JQueryAnimationOptions): JQuery; + + /** + * Display or hide the matched elements with a sliding motion. + * + * @param duration A string or number determining how long the animation will run. + * @param complete A function to call once the animation is complete. + */ + slideToggle(duration?: number|string, complete?: Function): JQuery; + /** + * Display or hide the matched elements with a sliding motion. + * + * @param duration A string or number determining how long the animation will run. + * @param easing A string indicating which easing function to use for the transition. + * @param complete A function to call once the animation is complete. + */ + slideToggle(duration?: number|string, easing?: string, complete?: Function): JQuery; + /** + * Display or hide the matched elements with a sliding motion. + * + * @param options A map of additional options to pass to the method. + */ + slideToggle(options: JQueryAnimationOptions): JQuery; + + /** + * Hide the matched elements with a sliding motion. + * + * @param duration A string or number determining how long the animation will run. + * @param complete A function to call once the animation is complete. + */ + slideUp(duration?: number|string, complete?: Function): JQuery; + /** + * Hide the matched elements with a sliding motion. + * + * @param duration A string or number determining how long the animation will run. + * @param easing A string indicating which easing function to use for the transition. + * @param complete A function to call once the animation is complete. + */ + slideUp(duration?: number|string, easing?: string, complete?: Function): JQuery; + /** + * Hide the matched elements with a sliding motion. + * + * @param options A map of additional options to pass to the method. + */ + slideUp(options: JQueryAnimationOptions): JQuery; + + /** + * Stop the currently-running animation on the matched elements. + * + * @param clearQueue A Boolean indicating whether to remove queued animation as well. Defaults to false. + * @param jumpToEnd A Boolean indicating whether to complete the current animation immediately. Defaults to false. + */ + stop(clearQueue?: boolean, jumpToEnd?: boolean): JQuery; + /** + * Stop the currently-running animation on the matched elements. + * + * @param queue The name of the queue in which to stop animations. + * @param clearQueue A Boolean indicating whether to remove queued animation as well. Defaults to false. + * @param jumpToEnd A Boolean indicating whether to complete the current animation immediately. Defaults to false. + */ + stop(queue?: string, clearQueue?: boolean, jumpToEnd?: boolean): JQuery; + + /** + * Display or hide the matched elements. + * + * @param duration A string or number determining how long the animation will run. + * @param complete A function to call once the animation is complete. + */ + toggle(duration?: number|string, complete?: Function): JQuery; + /** + * Display or hide the matched elements. + * + * @param duration A string or number determining how long the animation will run. + * @param easing A string indicating which easing function to use for the transition. + * @param complete A function to call once the animation is complete. + */ + toggle(duration?: number|string, easing?: string, complete?: Function): JQuery; + /** + * Display or hide the matched elements. + * + * @param options A map of additional options to pass to the method. + */ + toggle(options: JQueryAnimationOptions): JQuery; + /** + * Display or hide the matched elements. + * + * @param showOrHide A Boolean indicating whether to show or hide the elements. + */ + toggle(showOrHide: boolean): JQuery; + + /** + * Attach a handler to an event for the elements. + * + * @param eventType A string containing one or more DOM event types, such as "click" or "submit," or custom event names. + * @param eventData An object containing data that will be passed to the event handler. + * @param handler A function to execute each time the event is triggered. + */ + bind(eventType: string, eventData: any, handler: (eventObject: JQueryEventObject) => any): JQuery; + /** + * Attach a handler to an event for the elements. + * + * @param eventType A string containing one or more DOM event types, such as "click" or "submit," or custom event names. + * @param handler A function to execute each time the event is triggered. + */ + bind(eventType: string, handler: (eventObject: JQueryEventObject) => any): JQuery; + /** + * Attach a handler to an event for the elements. + * + * @param eventType A string containing one or more DOM event types, such as "click" or "submit," or custom event names. + * @param eventData An object containing data that will be passed to the event handler. + * @param preventBubble Setting the third argument to false will attach a function that prevents the default action from occurring and stops the event from bubbling. The default is true. + */ + bind(eventType: string, eventData: any, preventBubble: boolean): JQuery; + /** + * Attach a handler to an event for the elements. + * + * @param eventType A string containing one or more DOM event types, such as "click" or "submit," or custom event names. + * @param preventBubble Setting the third argument to false will attach a function that prevents the default action from occurring and stops the event from bubbling. The default is true. + */ + bind(eventType: string, preventBubble: boolean): JQuery; + /** + * Attach a handler to an event for the elements. + * + * @param events An object containing one or more DOM event types and functions to execute for them. + */ + bind(events: any): JQuery; + + /** + * Trigger the "blur" event on an element + */ + blur(): JQuery; + /** + * Bind an event handler to the "blur" JavaScript event + * + * @param handler A function to execute each time the event is triggered. + */ + blur(handler: (eventObject: JQueryEventObject) => any): JQuery; + /** + * Bind an event handler to the "blur" JavaScript event + * + * @param eventData An object containing data that will be passed to the event handler. + * @param handler A function to execute each time the event is triggered. + */ + blur(eventData?: any, handler?: (eventObject: JQueryEventObject) => any): JQuery; + + /** + * Trigger the "change" event on an element. + */ + change(): JQuery; + /** + * Bind an event handler to the "change" JavaScript event + * + * @param handler A function to execute each time the event is triggered. + */ + change(handler: (eventObject: JQueryEventObject) => any): JQuery; + /** + * Bind an event handler to the "change" JavaScript event + * + * @param eventData An object containing data that will be passed to the event handler. + * @param handler A function to execute each time the event is triggered. + */ + change(eventData?: any, handler?: (eventObject: JQueryEventObject) => any): JQuery; + + /** + * Trigger the "click" event on an element. + */ + click(): JQuery; + /** + * Bind an event handler to the "click" JavaScript event + * + * @param eventData An object containing data that will be passed to the event handler. + */ + click(handler: (eventObject: JQueryEventObject) => any): JQuery; + /** + * Bind an event handler to the "click" JavaScript event + * + * @param eventData An object containing data that will be passed to the event handler. + * @param handler A function to execute each time the event is triggered. + */ + click(eventData?: any, handler?: (eventObject: JQueryEventObject) => any): JQuery; + + /** + * Trigger the "dblclick" event on an element. + */ + dblclick(): JQuery; + /** + * Bind an event handler to the "dblclick" JavaScript event + * + * @param handler A function to execute each time the event is triggered. + */ + dblclick(handler: (eventObject: JQueryEventObject) => any): JQuery; + /** + * Bind an event handler to the "dblclick" JavaScript event + * + * @param eventData An object containing data that will be passed to the event handler. + * @param handler A function to execute each time the event is triggered. + */ + dblclick(eventData?: any, handler?: (eventObject: JQueryEventObject) => any): JQuery; + + delegate(selector: any, eventType: string, handler: (eventObject: JQueryEventObject) => any): JQuery; + delegate(selector: any, eventType: string, eventData: any, handler: (eventObject: JQueryEventObject) => any): JQuery; + + /** + * Trigger the "focus" event on an element. + */ + focus(): JQuery; + /** + * Bind an event handler to the "focus" JavaScript event + * + * @param handler A function to execute each time the event is triggered. + */ + focus(handler: (eventObject: JQueryEventObject) => any): JQuery; + /** + * Bind an event handler to the "focus" JavaScript event + * + * @param eventData An object containing data that will be passed to the event handler. + * @param handler A function to execute each time the event is triggered. + */ + focus(eventData?: any, handler?: (eventObject: JQueryEventObject) => any): JQuery; + + /** + * Bind an event handler to the "focusin" JavaScript event + * + * @param handler A function to execute each time the event is triggered. + */ + focusin(handler: (eventObject: JQueryEventObject) => any): JQuery; + /** + * Bind an event handler to the "focusin" JavaScript event + * + * @param eventData An object containing data that will be passed to the event handler. + * @param handler A function to execute each time the event is triggered. + */ + focusin(eventData: Object, handler: (eventObject: JQueryEventObject) => any): JQuery; + + /** + * Bind an event handler to the "focusout" JavaScript event + * + * @param handler A function to execute each time the event is triggered. + */ + focusout(handler: (eventObject: JQueryEventObject) => any): JQuery; + /** + * Bind an event handler to the "focusout" JavaScript event + * + * @param eventData An object containing data that will be passed to the event handler. + * @param handler A function to execute each time the event is triggered. + */ + focusout(eventData: Object, handler: (eventObject: JQueryEventObject) => any): JQuery; + + /** + * Bind two handlers to the matched elements, to be executed when the mouse pointer enters and leaves the elements. + * + * @param handlerIn A function to execute when the mouse pointer enters the element. + * @param handlerOut A function to execute when the mouse pointer leaves the element. + */ + hover(handlerIn: (eventObject: JQueryEventObject) => any, handlerOut: (eventObject: JQueryEventObject) => any): JQuery; + /** + * Bind a single handler to the matched elements, to be executed when the mouse pointer enters or leaves the elements. + * + * @param handlerInOut A function to execute when the mouse pointer enters or leaves the element. + */ + hover(handlerInOut: (eventObject: JQueryEventObject) => any): JQuery; + + /** + * Trigger the "keydown" event on an element. + */ + keydown(): JQuery; + /** + * Bind an event handler to the "keydown" JavaScript event + * + * @param handler A function to execute each time the event is triggered. + */ + keydown(handler: (eventObject: JQueryKeyEventObject) => any): JQuery; + /** + * Bind an event handler to the "keydown" JavaScript event + * + * @param eventData An object containing data that will be passed to the event handler. + * @param handler A function to execute each time the event is triggered. + */ + keydown(eventData?: any, handler?: (eventObject: JQueryKeyEventObject) => any): JQuery; + + /** + * Trigger the "keypress" event on an element. + */ + keypress(): JQuery; + /** + * Bind an event handler to the "keypress" JavaScript event + * + * @param handler A function to execute each time the event is triggered. + */ + keypress(handler: (eventObject: JQueryKeyEventObject) => any): JQuery; + /** + * Bind an event handler to the "keypress" JavaScript event + * + * @param eventData An object containing data that will be passed to the event handler. + * @param handler A function to execute each time the event is triggered. + */ + keypress(eventData?: any, handler?: (eventObject: JQueryKeyEventObject) => any): JQuery; + + /** + * Trigger the "keyup" event on an element. + */ + keyup(): JQuery; + /** + * Bind an event handler to the "keyup" JavaScript event + * + * @param handler A function to execute each time the event is triggered. + */ + keyup(handler: (eventObject: JQueryKeyEventObject) => any): JQuery; + /** + * Bind an event handler to the "keyup" JavaScript event + * + * @param eventData An object containing data that will be passed to the event handler. + * @param handler A function to execute each time the event is triggered. + */ + keyup(eventData?: any, handler?: (eventObject: JQueryKeyEventObject) => any): JQuery; + + /** + * Bind an event handler to the "load" JavaScript event. + * + * @param handler A function to execute when the event is triggered. + */ + load(handler: (eventObject: JQueryEventObject) => any): JQuery; + /** + * Bind an event handler to the "load" JavaScript event. + * + * @param eventData An object containing data that will be passed to the event handler. + * @param handler A function to execute when the event is triggered. + */ + load(eventData?: any, handler?: (eventObject: JQueryEventObject) => any): JQuery; + + /** + * Trigger the "mousedown" event on an element. + */ + mousedown(): JQuery; + /** + * Bind an event handler to the "mousedown" JavaScript event. + * + * @param handler A function to execute when the event is triggered. + */ + mousedown(handler: (eventObject: JQueryMouseEventObject) => any): JQuery; + /** + * Bind an event handler to the "mousedown" JavaScript event. + * + * @param eventData An object containing data that will be passed to the event handler. + * @param handler A function to execute when the event is triggered. + */ + mousedown(eventData: Object, handler: (eventObject: JQueryMouseEventObject) => any): JQuery; + + /** + * Trigger the "mouseenter" event on an element. + */ + mouseenter(): JQuery; + /** + * Bind an event handler to be fired when the mouse enters an element. + * + * @param handler A function to execute when the event is triggered. + */ + mouseenter(handler: (eventObject: JQueryMouseEventObject) => any): JQuery; + /** + * Bind an event handler to be fired when the mouse enters an element. + * + * @param eventData An object containing data that will be passed to the event handler. + * @param handler A function to execute when the event is triggered. + */ + mouseenter(eventData: Object, handler: (eventObject: JQueryMouseEventObject) => any): JQuery; + + /** + * Trigger the "mouseleave" event on an element. + */ + mouseleave(): JQuery; + /** + * Bind an event handler to be fired when the mouse leaves an element. + * + * @param handler A function to execute when the event is triggered. + */ + mouseleave(handler: (eventObject: JQueryMouseEventObject) => any): JQuery; + /** + * Bind an event handler to be fired when the mouse leaves an element. + * + * @param eventData An object containing data that will be passed to the event handler. + * @param handler A function to execute when the event is triggered. + */ + mouseleave(eventData: Object, handler: (eventObject: JQueryMouseEventObject) => any): JQuery; + + /** + * Trigger the "mousemove" event on an element. + */ + mousemove(): JQuery; + /** + * Bind an event handler to the "mousemove" JavaScript event. + * + * @param handler A function to execute when the event is triggered. + */ + mousemove(handler: (eventObject: JQueryMouseEventObject) => any): JQuery; + /** + * Bind an event handler to the "mousemove" JavaScript event. + * + * @param eventData An object containing data that will be passed to the event handler. + * @param handler A function to execute when the event is triggered. + */ + mousemove(eventData: Object, handler: (eventObject: JQueryMouseEventObject) => any): JQuery; + + /** + * Trigger the "mouseout" event on an element. + */ + mouseout(): JQuery; + /** + * Bind an event handler to the "mouseout" JavaScript event. + * + * @param handler A function to execute when the event is triggered. + */ + mouseout(handler: (eventObject: JQueryMouseEventObject) => any): JQuery; + /** + * Bind an event handler to the "mouseout" JavaScript event. + * + * @param eventData An object containing data that will be passed to the event handler. + * @param handler A function to execute when the event is triggered. + */ + mouseout(eventData: Object, handler: (eventObject: JQueryMouseEventObject) => any): JQuery; + + /** + * Trigger the "mouseover" event on an element. + */ + mouseover(): JQuery; + /** + * Bind an event handler to the "mouseover" JavaScript event. + * + * @param handler A function to execute when the event is triggered. + */ + mouseover(handler: (eventObject: JQueryMouseEventObject) => any): JQuery; + /** + * Bind an event handler to the "mouseover" JavaScript event. + * + * @param eventData An object containing data that will be passed to the event handler. + * @param handler A function to execute when the event is triggered. + */ + mouseover(eventData: Object, handler: (eventObject: JQueryMouseEventObject) => any): JQuery; + + /** + * Trigger the "mouseup" event on an element. + */ + mouseup(): JQuery; + /** + * Bind an event handler to the "mouseup" JavaScript event. + * + * @param handler A function to execute when the event is triggered. + */ + mouseup(handler: (eventObject: JQueryMouseEventObject) => any): JQuery; + /** + * Bind an event handler to the "mouseup" JavaScript event. + * + * @param eventData An object containing data that will be passed to the event handler. + * @param handler A function to execute when the event is triggered. + */ + mouseup(eventData: Object, handler: (eventObject: JQueryMouseEventObject) => any): JQuery; + + /** + * Remove an event handler. + */ + off(): JQuery; + /** + * Remove an event handler. + * + * @param events One or more space-separated event types and optional namespaces, or just namespaces, such as "click", "keydown.myPlugin", or ".myPlugin". + * @param selector A selector which should match the one originally passed to .on() when attaching event handlers. + * @param handler A handler function previously attached for the event(s), or the special value false. + */ + off(events: string, selector?: string, handler?: (eventObject: JQueryEventObject) => any): JQuery; + /** + * Remove an event handler. + * + * @param events One or more space-separated event types and optional namespaces, or just namespaces, such as "click", "keydown.myPlugin", or ".myPlugin". + * @param handler A handler function previously attached for the event(s), or the special value false. + */ + off(events: string, handler: (eventObject: JQueryEventObject) => any): JQuery; + /** + * Remove an event handler. + * + * @param events An object where the string keys represent one or more space-separated event types and optional namespaces, and the values represent handler functions previously attached for the event(s). + * @param selector A selector which should match the one originally passed to .on() when attaching event handlers. + */ + off(events: { [key: string]: any; }, selector?: string): JQuery; + + /** + * Attach an event handler function for one or more events to the selected elements. + * + * @param events One or more space-separated event types and optional namespaces, such as "click" or "keydown.myPlugin". + * @param handler A function to execute when the event is triggered. The value false is also allowed as a shorthand for a function that simply does return false. Rest parameter args is for optional parameters passed to jQuery.trigger(). Note that the actual parameters on the event handler function must be marked as optional (? syntax). + */ + on(events: string, handler: (eventObject: JQueryEventObject, ...args: any[]) => any): JQuery; + /** + * Attach an event handler function for one or more events to the selected elements. + * + * @param events One or more space-separated event types and optional namespaces, such as "click" or "keydown.myPlugin". + * @param data Data to be passed to the handler in event.data when an event is triggered. + * @param handler A function to execute when the event is triggered. The value false is also allowed as a shorthand for a function that simply does return false. + */ + on(events: string, data : any, handler: (eventObject: JQueryEventObject, ...args: any[]) => any): JQuery; + /** + * Attach an event handler function for one or more events to the selected elements. + * + * @param events One or more space-separated event types and optional namespaces, such as "click" or "keydown.myPlugin". + * @param selector A selector string to filter the descendants of the selected elements that trigger the event. If the selector is null or omitted, the event is always triggered when it reaches the selected element. + * @param handler A function to execute when the event is triggered. The value false is also allowed as a shorthand for a function that simply does return false. + */ + on(events: string, selector: string, handler: (eventObject: JQueryEventObject, ...eventData: any[]) => any): JQuery; + /** + * Attach an event handler function for one or more events to the selected elements. + * + * @param events One or more space-separated event types and optional namespaces, such as "click" or "keydown.myPlugin". + * @param selector A selector string to filter the descendants of the selected elements that trigger the event. If the selector is null or omitted, the event is always triggered when it reaches the selected element. + * @param data Data to be passed to the handler in event.data when an event is triggered. + * @param handler A function to execute when the event is triggered. The value false is also allowed as a shorthand for a function that simply does return false. + */ + on(events: string, selector: string, data: any, handler: (eventObject: JQueryEventObject, ...eventData: any[]) => any): JQuery; + /** + * Attach an event handler function for one or more events to the selected elements. + * + * @param events An object in which the string keys represent one or more space-separated event types and optional namespaces, and the values represent a handler function to be called for the event(s). + * @param selector A selector string to filter the descendants of the selected elements that will call the handler. If the selector is null or omitted, the handler is always called when it reaches the selected element. + * @param data Data to be passed to the handler in event.data when an event occurs. + */ + on(events: { [key: string]: any; }, selector?: string, data?: any): JQuery; + /** + * Attach an event handler function for one or more events to the selected elements. + * + * @param events An object in which the string keys represent one or more space-separated event types and optional namespaces, and the values represent a handler function to be called for the event(s). + * @param data Data to be passed to the handler in event.data when an event occurs. + */ + on(events: { [key: string]: any; }, data?: any): JQuery; + + /** + * Attach a handler to an event for the elements. The handler is executed at most once per element per event type. + * + * @param events A string containing one or more JavaScript event types, such as "click" or "submit," or custom event names. + * @param handler A function to execute at the time the event is triggered. + */ + one(events: string, handler: (eventObject: JQueryEventObject) => any): JQuery; + /** + * Attach a handler to an event for the elements. The handler is executed at most once per element per event type. + * + * @param events A string containing one or more JavaScript event types, such as "click" or "submit," or custom event names. + * @param data An object containing data that will be passed to the event handler. + * @param handler A function to execute at the time the event is triggered. + */ + one(events: string, data: Object, handler: (eventObject: JQueryEventObject) => any): JQuery; + + /** + * Attach a handler to an event for the elements. The handler is executed at most once per element per event type. + * + * @param events One or more space-separated event types and optional namespaces, such as "click" or "keydown.myPlugin". + * @param selector A selector string to filter the descendants of the selected elements that trigger the event. If the selector is null or omitted, the event is always triggered when it reaches the selected element. + * @param handler A function to execute when the event is triggered. The value false is also allowed as a shorthand for a function that simply does return false. + */ + one(events: string, selector: string, handler: (eventObject: JQueryEventObject) => any): JQuery; + /** + * Attach a handler to an event for the elements. The handler is executed at most once per element per event type. + * + * @param events One or more space-separated event types and optional namespaces, such as "click" or "keydown.myPlugin". + * @param selector A selector string to filter the descendants of the selected elements that trigger the event. If the selector is null or omitted, the event is always triggered when it reaches the selected element. + * @param data Data to be passed to the handler in event.data when an event is triggered. + * @param handler A function to execute when the event is triggered. The value false is also allowed as a shorthand for a function that simply does return false. + */ + one(events: string, selector: string, data: any, handler: (eventObject: JQueryEventObject) => any): JQuery; + + /** + * Attach a handler to an event for the elements. The handler is executed at most once per element per event type. + * + * @param events An object in which the string keys represent one or more space-separated event types and optional namespaces, and the values represent a handler function to be called for the event(s). + * @param selector A selector string to filter the descendants of the selected elements that will call the handler. If the selector is null or omitted, the handler is always called when it reaches the selected element. + * @param data Data to be passed to the handler in event.data when an event occurs. + */ + one(events: { [key: string]: any; }, selector?: string, data?: any): JQuery; + + /** + * Attach a handler to an event for the elements. The handler is executed at most once per element per event type. + * + * @param events An object in which the string keys represent one or more space-separated event types and optional namespaces, and the values represent a handler function to be called for the event(s). + * @param data Data to be passed to the handler in event.data when an event occurs. + */ + one(events: { [key: string]: any; }, data?: any): JQuery; + + + /** + * Specify a function to execute when the DOM is fully loaded. + * + * @param handler A function to execute after the DOM is ready. + */ + ready(handler: (jQueryAlias?: JQueryStatic) => any): JQuery; + + /** + * Trigger the "resize" event on an element. + */ + resize(): JQuery; + /** + * Bind an event handler to the "resize" JavaScript event. + * + * @param handler A function to execute each time the event is triggered. + */ + resize(handler: (eventObject: JQueryEventObject) => any): JQuery; + /** + * Bind an event handler to the "resize" JavaScript event. + * + * @param eventData An object containing data that will be passed to the event handler. + * @param handler A function to execute each time the event is triggered. + */ + resize(eventData: Object, handler: (eventObject: JQueryEventObject) => any): JQuery; + + /** + * Trigger the "scroll" event on an element. + */ + scroll(): JQuery; + /** + * Bind an event handler to the "scroll" JavaScript event. + * + * @param handler A function to execute each time the event is triggered. + */ + scroll(handler: (eventObject: JQueryEventObject) => any): JQuery; + /** + * Bind an event handler to the "scroll" JavaScript event. + * + * @param eventData An object containing data that will be passed to the event handler. + * @param handler A function to execute each time the event is triggered. + */ + scroll(eventData: Object, handler: (eventObject: JQueryEventObject) => any): JQuery; + + /** + * Trigger the "select" event on an element. + */ + select(): JQuery; + /** + * Bind an event handler to the "select" JavaScript event. + * + * @param handler A function to execute each time the event is triggered. + */ + select(handler: (eventObject: JQueryEventObject) => any): JQuery; + /** + * Bind an event handler to the "select" JavaScript event. + * + * @param eventData An object containing data that will be passed to the event handler. + * @param handler A function to execute each time the event is triggered. + */ + select(eventData: Object, handler: (eventObject: JQueryEventObject) => any): JQuery; + + /** + * Trigger the "submit" event on an element. + */ + submit(): JQuery; + /** + * Bind an event handler to the "submit" JavaScript event + * + * @param handler A function to execute each time the event is triggered. + */ + submit(handler: (eventObject: JQueryEventObject) => any): JQuery; + /** + * Bind an event handler to the "submit" JavaScript event + * + * @param eventData An object containing data that will be passed to the event handler. + * @param handler A function to execute each time the event is triggered. + */ + submit(eventData?: any, handler?: (eventObject: JQueryEventObject) => any): JQuery; + + /** + * Execute all handlers and behaviors attached to the matched elements for the given event type. + * + * @param eventType A string containing a JavaScript event type, such as click or submit. + * @param extraParameters Additional parameters to pass along to the event handler. + */ + trigger(eventType: string, extraParameters?: any[]|Object): JQuery; + /** + * Execute all handlers and behaviors attached to the matched elements for the given event type. + * + * @param event A jQuery.Event object. + * @param extraParameters Additional parameters to pass along to the event handler. + */ + trigger(event: JQueryEventObject, extraParameters?: any[]|Object): JQuery; + + /** + * Execute all handlers attached to an element for an event. + * + * @param eventType A string containing a JavaScript event type, such as click or submit. + * @param extraParameters An array of additional parameters to pass along to the event handler. + */ + triggerHandler(eventType: string, ...extraParameters: any[]): Object; + + /** + * Remove a previously-attached event handler from the elements. + * + * @param eventType A string containing a JavaScript event type, such as click or submit. + * @param handler The function that is to be no longer executed. + */ + unbind(eventType?: string, handler?: (eventObject: JQueryEventObject) => any): JQuery; + /** + * Remove a previously-attached event handler from the elements. + * + * @param eventType A string containing a JavaScript event type, such as click or submit. + * @param fls Unbinds the corresponding 'return false' function that was bound using .bind( eventType, false ). + */ + unbind(eventType: string, fls: boolean): JQuery; + /** + * Remove a previously-attached event handler from the elements. + * + * @param evt A JavaScript event object as passed to an event handler. + */ + unbind(evt: any): JQuery; + + /** + * Remove a handler from the event for all elements which match the current selector, based upon a specific set of root elements. + */ + undelegate(): JQuery; + /** + * Remove a handler from the event for all elements which match the current selector, based upon a specific set of root elements. + * + * @param selector A selector which will be used to filter the event results. + * @param eventType A string containing a JavaScript event type, such as "click" or "keydown" + * @param handler A function to execute at the time the event is triggered. + */ + undelegate(selector: string, eventType: string, handler?: (eventObject: JQueryEventObject) => any): JQuery; + /** + * Remove a handler from the event for all elements which match the current selector, based upon a specific set of root elements. + * + * @param selector A selector which will be used to filter the event results. + * @param events An object of one or more event types and previously bound functions to unbind from them. + */ + undelegate(selector: string, events: Object): JQuery; + /** + * Remove a handler from the event for all elements which match the current selector, based upon a specific set of root elements. + * + * @param namespace A string containing a namespace to unbind all events from. + */ + undelegate(namespace: string): JQuery; + + /** + * Bind an event handler to the "unload" JavaScript event. (DEPRECATED from v1.8) + * + * @param handler A function to execute when the event is triggered. + */ + unload(handler: (eventObject: JQueryEventObject) => any): JQuery; + /** + * Bind an event handler to the "unload" JavaScript event. (DEPRECATED from v1.8) + * + * @param eventData A plain object of data that will be passed to the event handler. + * @param handler A function to execute when the event is triggered. + */ + unload(eventData?: any, handler?: (eventObject: JQueryEventObject) => any): JQuery; + + /** + * The DOM node context originally passed to jQuery(); if none was passed then context will likely be the document. (DEPRECATED from v1.10) + */ + context: Element; + + jquery: string; + + /** + * Bind an event handler to the "error" JavaScript event. (DEPRECATED from v1.8) + * + * @param handler A function to execute when the event is triggered. + */ + error(handler: (eventObject: JQueryEventObject) => any): JQuery; + /** + * Bind an event handler to the "error" JavaScript event. (DEPRECATED from v1.8) + * + * @param eventData A plain object of data that will be passed to the event handler. + * @param handler A function to execute when the event is triggered. + */ + error(eventData: any, handler: (eventObject: JQueryEventObject) => any): JQuery; + + /** + * Add a collection of DOM elements onto the jQuery stack. + * + * @param elements An array of elements to push onto the stack and make into a new jQuery object. + */ + pushStack(elements: any[]): JQuery; + /** + * Add a collection of DOM elements onto the jQuery stack. + * + * @param elements An array of elements to push onto the stack and make into a new jQuery object. + * @param name The name of a jQuery method that generated the array of elements. + * @param arguments The arguments that were passed in to the jQuery method (for serialization). + */ + pushStack(elements: any[], name: string, arguments: any[]): JQuery; + + /** + * Insert content, specified by the parameter, after each element in the set of matched elements. + * + * param content1 HTML string, DOM element, array of elements, or jQuery object to insert after each element in the set of matched elements. + * param content2 One or more additional DOM elements, arrays of elements, HTML strings, or jQuery objects to insert after each element in the set of matched elements. + */ + after(content1: JQuery|any[]|Element|Text|string, ...content2: any[]): JQuery; + /** + * Insert content, specified by the parameter, after each element in the set of matched elements. + * + * param func A function that returns an HTML string, DOM element(s), or jQuery object to insert after each element in the set of matched elements. Receives the index position of the element in the set as an argument. Within the function, this refers to the current element in the set. + */ + after(func: (index: number, html: string) => string|Element|JQuery): JQuery; + + /** + * Insert content, specified by the parameter, to the end of each element in the set of matched elements. + * + * param content1 DOM element, array of elements, HTML string, or jQuery object to insert at the end of each element in the set of matched elements. + * param content2 One or more additional DOM elements, arrays of elements, HTML strings, or jQuery objects to insert at the end of each element in the set of matched elements. + */ + append(content1: JQuery|any[]|Element|Text|string, ...content2: any[]): JQuery; + /** + * Insert content, specified by the parameter, to the end of each element in the set of matched elements. + * + * param func A function that returns an HTML string, DOM element(s), or jQuery object to insert at the end of each element in the set of matched elements. Receives the index position of the element in the set and the old HTML value of the element as arguments. Within the function, this refers to the current element in the set. + */ + append(func: (index: number, html: string) => string|Element|JQuery): JQuery; + + /** + * Insert every element in the set of matched elements to the end of the target. + * + * @param target A selector, element, HTML string, array of elements, or jQuery object; the matched set of elements will be inserted at the end of the element(s) specified by this parameter. + */ + appendTo(target: JQuery|any[]|Element|string): JQuery; + + /** + * Insert content, specified by the parameter, before each element in the set of matched elements. + * + * param content1 HTML string, DOM element, array of elements, or jQuery object to insert before each element in the set of matched elements. + * param content2 One or more additional DOM elements, arrays of elements, HTML strings, or jQuery objects to insert before each element in the set of matched elements. + */ + before(content1: JQuery|any[]|Element|Text|string, ...content2: any[]): JQuery; + /** + * Insert content, specified by the parameter, before each element in the set of matched elements. + * + * param func A function that returns an HTML string, DOM element(s), or jQuery object to insert before each element in the set of matched elements. Receives the index position of the element in the set as an argument. Within the function, this refers to the current element in the set. + */ + before(func: (index: number, html: string) => string|Element|JQuery): JQuery; + + /** + * Create a deep copy of the set of matched elements. + * + * param withDataAndEvents A Boolean indicating whether event handlers and data should be copied along with the elements. The default value is false. + * param deepWithDataAndEvents A Boolean indicating whether event handlers and data for all children of the cloned element should be copied. By default its value matches the first argument's value (which defaults to false). + */ + clone(withDataAndEvents?: boolean, deepWithDataAndEvents?: boolean): JQuery; + + /** + * Remove the set of matched elements from the DOM. + * + * param selector A selector expression that filters the set of matched elements to be removed. + */ + detach(selector?: string): JQuery; + + /** + * Remove all child nodes of the set of matched elements from the DOM. + */ + empty(): JQuery; + + /** + * Insert every element in the set of matched elements after the target. + * + * param target A selector, element, array of elements, HTML string, or jQuery object; the matched set of elements will be inserted after the element(s) specified by this parameter. + */ + insertAfter(target: JQuery|any[]|Element|Text|string): JQuery; + + /** + * Insert every element in the set of matched elements before the target. + * + * param target A selector, element, array of elements, HTML string, or jQuery object; the matched set of elements will be inserted before the element(s) specified by this parameter. + */ + insertBefore(target: JQuery|any[]|Element|Text|string): JQuery; + + /** + * Insert content, specified by the parameter, to the beginning of each element in the set of matched elements. + * + * param content1 DOM element, array of elements, HTML string, or jQuery object to insert at the beginning of each element in the set of matched elements. + * param content2 One or more additional DOM elements, arrays of elements, HTML strings, or jQuery objects to insert at the beginning of each element in the set of matched elements. + */ + prepend(content1: JQuery|any[]|Element|Text|string, ...content2: any[]): JQuery; + /** + * Insert content, specified by the parameter, to the beginning of each element in the set of matched elements. + * + * param func A function that returns an HTML string, DOM element(s), or jQuery object to insert at the beginning of each element in the set of matched elements. Receives the index position of the element in the set and the old HTML value of the element as arguments. Within the function, this refers to the current element in the set. + */ + prepend(func: (index: number, html: string) => string|Element|JQuery): JQuery; + + /** + * Insert every element in the set of matched elements to the beginning of the target. + * + * @param target A selector, element, HTML string, array of elements, or jQuery object; the matched set of elements will be inserted at the beginning of the element(s) specified by this parameter. + */ + prependTo(target: JQuery|any[]|Element|string): JQuery; + + /** + * Remove the set of matched elements from the DOM. + * + * @param selector A selector expression that filters the set of matched elements to be removed. + */ + remove(selector?: string): JQuery; + + /** + * Replace each target element with the set of matched elements. + * + * @param target A selector string, jQuery object, DOM element, or array of elements indicating which element(s) to replace. + */ + replaceAll(target: JQuery|any[]|Element|string): JQuery; + + /** + * Replace each element in the set of matched elements with the provided new content and return the set of elements that was removed. + * + * param newContent The content to insert. May be an HTML string, DOM element, array of DOM elements, or jQuery object. + */ + replaceWith(newContent: JQuery|any[]|Element|Text|string): JQuery; + /** + * Replace each element in the set of matched elements with the provided new content and return the set of elements that was removed. + * + * param func A function that returns content with which to replace the set of matched elements. + */ + replaceWith(func: () => Element|JQuery): JQuery; + + /** + * Get the combined text contents of each element in the set of matched elements, including their descendants. + */ + text(): string; + /** + * Set the content of each element in the set of matched elements to the specified text. + * + * @param text The text to set as the content of each matched element. When Number or Boolean is supplied, it will be converted to a String representation. + */ + text(text: string|number|boolean): JQuery; + /** + * Set the content of each element in the set of matched elements to the specified text. + * + * @param func A function returning the text content to set. Receives the index position of the element in the set and the old text value as arguments. + */ + text(func: (index: number, text: string) => string): JQuery; + + /** + * Retrieve all the elements contained in the jQuery set, as an array. + */ + toArray(): any[]; + + /** + * Remove the parents of the set of matched elements from the DOM, leaving the matched elements in their place. + */ + unwrap(): JQuery; + + /** + * Wrap an HTML structure around each element in the set of matched elements. + * + * @param wrappingElement A selector, element, HTML string, or jQuery object specifying the structure to wrap around the matched elements. + */ + wrap(wrappingElement: JQuery|Element|string): JQuery; + /** + * Wrap an HTML structure around each element in the set of matched elements. + * + * @param func A callback function returning the HTML content or jQuery object to wrap around the matched elements. Receives the index position of the element in the set as an argument. Within the function, this refers to the current element in the set. + */ + wrap(func: (index: number) => string|JQuery): JQuery; + + /** + * Wrap an HTML structure around all elements in the set of matched elements. + * + * @param wrappingElement A selector, element, HTML string, or jQuery object specifying the structure to wrap around the matched elements. + */ + wrapAll(wrappingElement: JQuery|Element|string): JQuery; + wrapAll(func: (index: number) => string): JQuery; + + /** + * Wrap an HTML structure around the content of each element in the set of matched elements. + * + * @param wrappingElement An HTML snippet, selector expression, jQuery object, or DOM element specifying the structure to wrap around the content of the matched elements. + */ + wrapInner(wrappingElement: JQuery|Element|string): JQuery; + /** + * Wrap an HTML structure around the content of each element in the set of matched elements. + * + * @param func A callback function which generates a structure to wrap around the content of the matched elements. Receives the index position of the element in the set as an argument. Within the function, this refers to the current element in the set. + */ + wrapInner(func: (index: number) => string): JQuery; + + /** + * Iterate over a jQuery object, executing a function for each matched element. + * + * @param func A function to execute for each matched element. + */ + each(func: (index: number, elem: Element) => any): JQuery; + + /** + * Retrieve one of the elements matched by the jQuery object. + * + * @param index A zero-based integer indicating which element to retrieve. + */ + get(index: number): HTMLElement; + /** + * Retrieve the elements matched by the jQuery object. + */ + get(): any[]; + + /** + * Search for a given element from among the matched elements. + */ + index(): number; + /** + * Search for a given element from among the matched elements. + * + * @param selector A selector representing a jQuery collection in which to look for an element. + */ + index(selector: string|JQuery|Element): number; + + /** + * The number of elements in the jQuery object. + */ + length: number; + /** + * A selector representing selector passed to jQuery(), if any, when creating the original set. + * version deprecated: 1.7, removed: 1.9 + */ + selector: string; + [index: string]: any; + [index: number]: HTMLElement; + + /** + * Add elements to the set of matched elements. + * + * @param selector A string representing a selector expression to find additional elements to add to the set of matched elements. + * @param context The point in the document at which the selector should begin matching; similar to the context argument of the $(selector, context) method. + */ + add(selector: string, context?: Element): JQuery; + /** + * Add elements to the set of matched elements. + * + * @param elements One or more elements to add to the set of matched elements. + */ + add(...elements: Element[]): JQuery; + /** + * Add elements to the set of matched elements. + * + * @param html An HTML fragment to add to the set of matched elements. + */ + add(html: string): JQuery; + /** + * Add elements to the set of matched elements. + * + * @param obj An existing jQuery object to add to the set of matched elements. + */ + add(obj: JQuery): JQuery; + + /** + * Get the children of each element in the set of matched elements, optionally filtered by a selector. + * + * @param selector A string containing a selector expression to match elements against. + */ + children(selector?: string): JQuery; + + /** + * For each element in the set, get the first element that matches the selector by testing the element itself and traversing up through its ancestors in the DOM tree. + * + * @param selector A string containing a selector expression to match elements against. + */ + closest(selector: string): JQuery; + /** + * For each element in the set, get the first element that matches the selector by testing the element itself and traversing up through its ancestors in the DOM tree. + * + * @param selector A string containing a selector expression to match elements against. + * @param context A DOM element within which a matching element may be found. If no context is passed in then the context of the jQuery set will be used instead. + */ + closest(selector: string, context?: Element): JQuery; + /** + * For each element in the set, get the first element that matches the selector by testing the element itself and traversing up through its ancestors in the DOM tree. + * + * @param obj A jQuery object to match elements against. + */ + closest(obj: JQuery): JQuery; + /** + * For each element in the set, get the first element that matches the selector by testing the element itself and traversing up through its ancestors in the DOM tree. + * + * @param element An element to match elements against. + */ + closest(element: Element): JQuery; + + /** + * Get an array of all the elements and selectors matched against the current element up through the DOM tree. + * + * @param selectors An array or string containing a selector expression to match elements against (can also be a jQuery object). + * @param context A DOM element within which a matching element may be found. If no context is passed in then the context of the jQuery set will be used instead. + */ + closest(selectors: any, context?: Element): any[]; + + /** + * Get the children of each element in the set of matched elements, including text and comment nodes. + */ + contents(): JQuery; + + /** + * End the most recent filtering operation in the current chain and return the set of matched elements to its previous state. + */ + end(): JQuery; + + /** + * Reduce the set of matched elements to the one at the specified index. + * + * @param index An integer indicating the 0-based position of the element. OR An integer indicating the position of the element, counting backwards from the last element in the set. + * + */ + eq(index: number): JQuery; + + /** + * Reduce the set of matched elements to those that match the selector or pass the function's test. + * + * @param selector A string containing a selector expression to match the current set of elements against. + */ + filter(selector: string): JQuery; + /** + * Reduce the set of matched elements to those that match the selector or pass the function's test. + * + * @param func A function used as a test for each element in the set. this is the current DOM element. + */ + filter(func: (index: number, element: Element) => any): JQuery; + /** + * Reduce the set of matched elements to those that match the selector or pass the function's test. + * + * @param element An element to match the current set of elements against. + */ + filter(element: Element): JQuery; + /** + * Reduce the set of matched elements to those that match the selector or pass the function's test. + * + * @param obj An existing jQuery object to match the current set of elements against. + */ + filter(obj: JQuery): JQuery; + + /** + * Get the descendants of each element in the current set of matched elements, filtered by a selector, jQuery object, or element. + * + * @param selector A string containing a selector expression to match elements against. + */ + find(selector: string): JQuery; + /** + * Get the descendants of each element in the current set of matched elements, filtered by a selector, jQuery object, or element. + * + * @param element An element to match elements against. + */ + find(element: Element): JQuery; + /** + * Get the descendants of each element in the current set of matched elements, filtered by a selector, jQuery object, or element. + * + * @param obj A jQuery object to match elements against. + */ + find(obj: JQuery): JQuery; + + /** + * Reduce the set of matched elements to the first in the set. + */ + first(): JQuery; + + /** + * Reduce the set of matched elements to those that have a descendant that matches the selector or DOM element. + * + * @param selector A string containing a selector expression to match elements against. + */ + has(selector: string): JQuery; + /** + * Reduce the set of matched elements to those that have a descendant that matches the selector or DOM element. + * + * @param contained A DOM element to match elements against. + */ + has(contained: Element): JQuery; + + /** + * Check the current matched set of elements against a selector, element, or jQuery object and return true if at least one of these elements matches the given arguments. + * + * @param selector A string containing a selector expression to match elements against. + */ + is(selector: string): boolean; + /** + * Check the current matched set of elements against a selector, element, or jQuery object and return true if at least one of these elements matches the given arguments. + * + * @param func A function used as a test for the set of elements. It accepts one argument, index, which is the element's index in the jQuery collection.Within the function, this refers to the current DOM element. + */ + is(func: (index: number, element: Element) => boolean): boolean; + /** + * Check the current matched set of elements against a selector, element, or jQuery object and return true if at least one of these elements matches the given arguments. + * + * @param obj An existing jQuery object to match the current set of elements against. + */ + is(obj: JQuery): boolean; + /** + * Check the current matched set of elements against a selector, element, or jQuery object and return true if at least one of these elements matches the given arguments. + * + * @param elements One or more elements to match the current set of elements against. + */ + is(elements: any): boolean; + + /** + * Reduce the set of matched elements to the final one in the set. + */ + last(): JQuery; + + /** + * Pass each element in the current matched set through a function, producing a new jQuery object containing the return values. + * + * @param callback A function object that will be invoked for each element in the current set. + */ + map(callback: (index: number, domElement: Element) => any): JQuery; + + /** + * Get the immediately following sibling of each element in the set of matched elements. If a selector is provided, it retrieves the next sibling only if it matches that selector. + * + * @param selector A string containing a selector expression to match elements against. + */ + next(selector?: string): JQuery; + + /** + * Get all following siblings of each element in the set of matched elements, optionally filtered by a selector. + * + * @param selector A string containing a selector expression to match elements against. + */ + nextAll(selector?: string): JQuery; + + /** + * Get all following siblings of each element up to but not including the element matched by the selector, DOM node, or jQuery object passed. + * + * @param selector A string containing a selector expression to indicate where to stop matching following sibling elements. + * @param filter A string containing a selector expression to match elements against. + */ + nextUntil(selector?: string, filter?: string): JQuery; + /** + * Get all following siblings of each element up to but not including the element matched by the selector, DOM node, or jQuery object passed. + * + * @param element A DOM node or jQuery object indicating where to stop matching following sibling elements. + * @param filter A string containing a selector expression to match elements against. + */ + nextUntil(element?: Element, filter?: string): JQuery; + /** + * Get all following siblings of each element up to but not including the element matched by the selector, DOM node, or jQuery object passed. + * + * @param obj A DOM node or jQuery object indicating where to stop matching following sibling elements. + * @param filter A string containing a selector expression to match elements against. + */ + nextUntil(obj?: JQuery, filter?: string): JQuery; + + /** + * Remove elements from the set of matched elements. + * + * @param selector A string containing a selector expression to match elements against. + */ + not(selector: string): JQuery; + /** + * Remove elements from the set of matched elements. + * + * @param func A function used as a test for each element in the set. this is the current DOM element. + */ + not(func: (index: number, element: Element) => boolean): JQuery; + /** + * Remove elements from the set of matched elements. + * + * @param elements One or more DOM elements to remove from the matched set. + */ + not(...elements: Element[]): JQuery; + /** + * Remove elements from the set of matched elements. + * + * @param obj An existing jQuery object to match the current set of elements against. + */ + not(obj: JQuery): JQuery; + + /** + * Get the closest ancestor element that is positioned. + */ + offsetParent(): JQuery; + + /** + * Get the parent of each element in the current set of matched elements, optionally filtered by a selector. + * + * @param selector A string containing a selector expression to match elements against. + */ + parent(selector?: string): JQuery; + + /** + * Get the ancestors of each element in the current set of matched elements, optionally filtered by a selector. + * + * @param selector A string containing a selector expression to match elements against. + */ + parents(selector?: string): JQuery; + + /** + * Get the ancestors of each element in the current set of matched elements, up to but not including the element matched by the selector, DOM node, or jQuery object. + * + * @param selector A string containing a selector expression to indicate where to stop matching ancestor elements. + * @param filter A string containing a selector expression to match elements against. + */ + parentsUntil(selector?: string, filter?: string): JQuery; + /** + * Get the ancestors of each element in the current set of matched elements, up to but not including the element matched by the selector, DOM node, or jQuery object. + * + * @param element A DOM node or jQuery object indicating where to stop matching ancestor elements. + * @param filter A string containing a selector expression to match elements against. + */ + parentsUntil(element?: Element, filter?: string): JQuery; + /** + * Get the ancestors of each element in the current set of matched elements, up to but not including the element matched by the selector, DOM node, or jQuery object. + * + * @param obj A DOM node or jQuery object indicating where to stop matching ancestor elements. + * @param filter A string containing a selector expression to match elements against. + */ + parentsUntil(obj?: JQuery, filter?: string): JQuery; + + /** + * Get the immediately preceding sibling of each element in the set of matched elements, optionally filtered by a selector. + * + * @param selector A string containing a selector expression to match elements against. + */ + prev(selector?: string): JQuery; + + /** + * Get all preceding siblings of each element in the set of matched elements, optionally filtered by a selector. + * + * @param selector A string containing a selector expression to match elements against. + */ + prevAll(selector?: string): JQuery; + + /** + * Get all preceding siblings of each element up to but not including the element matched by the selector, DOM node, or jQuery object. + * + * @param selector A string containing a selector expression to indicate where to stop matching preceding sibling elements. + * @param filter A string containing a selector expression to match elements against. + */ + prevUntil(selector?: string, filter?: string): JQuery; + /** + * Get all preceding siblings of each element up to but not including the element matched by the selector, DOM node, or jQuery object. + * + * @param element A DOM node or jQuery object indicating where to stop matching preceding sibling elements. + * @param filter A string containing a selector expression to match elements against. + */ + prevUntil(element?: Element, filter?: string): JQuery; + /** + * Get all preceding siblings of each element up to but not including the element matched by the selector, DOM node, or jQuery object. + * + * @param obj A DOM node or jQuery object indicating where to stop matching preceding sibling elements. + * @param filter A string containing a selector expression to match elements against. + */ + prevUntil(obj?: JQuery, filter?: string): JQuery; + + /** + * Get the siblings of each element in the set of matched elements, optionally filtered by a selector. + * + * @param selector A string containing a selector expression to match elements against. + */ + siblings(selector?: string): JQuery; + + /** + * Reduce the set of matched elements to a subset specified by a range of indices. + * + * @param start An integer indicating the 0-based position at which the elements begin to be selected. If negative, it indicates an offset from the end of the set. + * @param end An integer indicating the 0-based position at which the elements stop being selected. If negative, it indicates an offset from the end of the set. If omitted, the range continues until the end of the set. + */ + slice(start: number, end?: number): JQuery; + + /** + * Show the queue of functions to be executed on the matched elements. + * + * @param queueName A string containing the name of the queue. Defaults to fx, the standard effects queue. + */ + queue(queueName?: string): any[]; + /** + * Manipulate the queue of functions to be executed, once for each matched element. + * + * @param newQueue An array of functions to replace the current queue contents. + */ + queue(newQueue: Function[]): JQuery; + /** + * Manipulate the queue of functions to be executed, once for each matched element. + * + * @param callback The new function to add to the queue, with a function to call that will dequeue the next item. + */ + queue(callback: Function): JQuery; + /** + * Manipulate the queue of functions to be executed, once for each matched element. + * + * @param queueName A string containing the name of the queue. Defaults to fx, the standard effects queue. + * @param newQueue An array of functions to replace the current queue contents. + */ + queue(queueName: string, newQueue: Function[]): JQuery; + /** + * Manipulate the queue of functions to be executed, once for each matched element. + * + * @param queueName A string containing the name of the queue. Defaults to fx, the standard effects queue. + * @param callback The new function to add to the queue, with a function to call that will dequeue the next item. + */ + queue(queueName: string, callback: Function): JQuery; +} +declare module "jquery" { + export = $; +} +declare var jQuery: JQueryStatic; +declare var $: JQueryStatic; diff --git a/catalog-ui/typings/jsMd5/md5.d.ts b/catalog-ui/typings/jsMd5/md5.d.ts new file mode 100644 index 0000000000..3f06a6f509 --- /dev/null +++ b/catalog-ui/typings/jsMd5/md5.d.ts @@ -0,0 +1,55 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ +// Type definitions for js-md5 v0.3.0 +// Project: https://github.com/emn178/js-md5 +// Definitions by: Roland Greim <https://github.com/tigerxy> +// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped/ + +/// <reference path="../jquery/jquery.d.ts"/> + +interface JQuery { + md5(value: string): string; + md5(value: Array<any>): string; + md5(value: Uint8Array): string; +} + +interface JQueryStatic { + md5(value: string): string; + md5(value: Array<any>): string; + md5(value: Uint8Array): string; +} + +interface md5 { + (value: string): string; + (value: Array<any>): string; + (value: Uint8Array): string; +} + +interface String { + md5(value: string): string; + md5(value: Array<any>): string; + md5(value: Uint8Array): string; +} + +declare module "js-md5" { + export = md5; +} + +declare var md5: md5; diff --git a/catalog-ui/typings/lodash/lodash.d.ts b/catalog-ui/typings/lodash/lodash.d.ts new file mode 100644 index 0000000000..9d23982103 --- /dev/null +++ b/catalog-ui/typings/lodash/lodash.d.ts @@ -0,0 +1,22949 @@ +// Type definitions for Lo-Dash 4.14 +// Project: http://lodash.com/ +// Definitions by: Brian Zengel <https://github.com/bczengel>, Ilya Mochalov <https://github.com/chrootsu>, Stepan Mikhaylyuk <https://github.com/stepancar> +// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped + + +/** + ### 4.0.0 Changelog (https://github.com/lodash/lodash/wiki/Changelog) + + #### TODO: + removed: + - [x] Removed _.support + - [x] Removed _.findWhere in favor of _.find with iteratee shorthand + - [x] Removed _.where in favor of _.filter with iteratee shorthand + - [x] Removed _.pluck in favor of _.map with iteratee shorthand + + renamed: + - [x] Renamed _.first to _.head + - [x] Renamed _.indexBy to _.keyBy + - [x] Renamed _.invoke to _.invokeMap + - [x] Renamed _.overArgs to _.overArgs + - [x] Renamed _.padLeft & _.padRight to _.padStart & _.padEnd + - [x] Renamed _.pairs to _.toPairs + - [x] Renamed _.rest to _.tail + - [x] Renamed _.restParam to _.rest + - [x] Renamed _.sortByOrder to _.orderBy + - [x] Renamed _.trimLeft & _.trimRight to _.trimStart & _.trimEnd + - [x] Renamed _.trunc to _.truncate + + split: + - [x] Split _.indexOf & _.lastIndexOf into _.sortedIndexOf & _.sortedLastIndexOf + - [x] Split _.max & _.min into _.maxBy & _.minBy + - [x] Split _.omit & _.pick into _.omitBy & _.pickBy + - [x] Split _.sample into _.sampleSize + - [x] Split _.sortedIndex into _.sortedIndexBy + - [x] Split _.sortedLastIndex into _.sortedLastIndexBy + - [x] Split _.uniq into _.sortedUniq, _.sortedUniqBy, & _.uniqBy + + changes: + - [x] Absorbed _.sortByAll into _.sortBy + - [x] Changed the category of _.at to “Object” + - [x] Changed the category of _.bindAll to “Utility” + - [x] Made _.capitalize uppercase the first character & lowercase the rest + - [x] Made _.functions return only own method names + + + added 23 array methods: + - [x] _.concat + - [x] _.differenceBy + - [x] _.differenceWith + - [x] _.flatMap + - [x] _.fromPairs + - [x] _.intersectionBy + - [x] _.intersectionWith + - [x] _.join + - [x] _.pullAll + - [x] _.pullAllBy + - [x] _.reverse + - [x] _.sortedIndexBy + - [x] _.sortedIndexOf + - [x] _.sortedLastIndexBy + - [x] _.sortedLastIndexOf + - [x] _.sortedUniq + - [x] _.sortedUniqBy + - [x] _.unionBy + - [x] _.unionWith + - [x] _.uniqBy + - [x] _.uniqWith + - [x] _.xorBy + - [x] _.xorWith + + added 18 lang methods: + - [x] _.cloneDeepWith + - [x] _.cloneWith + - [x] _.eq + - [x] _.isArrayLike + - [x] _.isArrayLikeObject + - [x] _.isEqualWith + - [x] _.isInteger + - [x] _.isLength + - [x] _.isMatchWith + - [x] _.isNil + - [x] _.isObjectLike + - [x] _.isSafeInteger + - [x] _.isSymbol + - [x] _.toInteger + - [x] _.toLength + - [x] _.toNumber + - [x] _.toSafeInteger + - [x] _.toString + + added 13 object methods: + - [x] _.assignIn + - [x] _.assignInWith + - [x] _.assignWith + - [x] _.functionsIn + - [x] _.hasIn + - [x] _.mergeWith + - [x] _.omitBy + - [x] _.pickBy + + + added 8 string methods: + - [x] _.lowerCase + - [x] _.lowerFirst + - [x] _.upperCase + - [x] _.upperFirst + - [x] _.toLower + - [x] _.toUpper + + added 8 utility methods: + - [x] _.toPath + + added 4 math methods: + - [x] _.maxBy + - [x] _.mean + - [x] _.minBy + - [x] _.sumBy + + added 2 function methods: + - [x] _.flip + - [x] _.unary + + added 2 number methods: + - [x] _.clamp + - [x] _.subtract + + added collection method: + - [x] _.sampleSize + + Added 3 aliases + + - [x] _.first as an alias of _.head + + Removed 17 aliases + - [x] Removed aliase _.all + - [x] Removed aliase _.any + - [x] Removed aliase _.backflow + - [x] Removed aliase _.callback + - [x] Removed aliase _.collect + - [x] Removed aliase _.compose + - [x] Removed aliase _.contains + - [x] Removed aliase _.detect + - [x] Removed aliase _.foldl + - [x] Removed aliase _.foldr + - [x] Removed aliase _.include + - [x] Removed aliase _.inject + - [x] Removed aliase _.methods + - [x] Removed aliase _.object + - [x] Removed aliase _.run + - [x] Removed aliase _.select + - [x] Removed aliase _.unique + + Other changes + - [x] Added support for array buffers to _.isEqual + - [x] Added support for converting iterators to _.toArray + - [x] Added support for deep paths to _.zipObject + - [x] Changed UMD to export to window or self when available regardless of other exports + - [x] Ensured debounce cancel clears args & thisArg references + - [x] Ensured _.add, _.subtract, & _.sum don’t skip NaN values + - [x] Ensured _.clone treats generators like functions + - [x] Ensured _.clone produces clones with the source’s [[Prototype]] + - [x] Ensured _.defaults assigns properties that shadow Object.prototype + - [x] Ensured _.defaultsDeep doesn’t merge a string into an array + - [x] Ensured _.defaultsDeep & _.merge don’t modify sources + - [x] Ensured _.defaultsDeep works with circular references + - [x] Ensured _.keys skips “length” on strict mode arguments objects in Safari 9 + - [x] Ensured _.merge doesn’t convert strings to arrays + - [x] Ensured _.merge merges plain-objects onto non plain-objects + - [x] Ensured _#plant resets iterator data of cloned sequences + - [x] Ensured _.random swaps min & max if min is greater than max + - [x] Ensured _.range preserves the sign of start of -0 + - [x] Ensured _.reduce & _.reduceRight use getIteratee in their array branch + - [x] Fixed rounding issue with the precision param of _.floor + - [x] Added flush method to debounced & throttled functions + + ** LATER ** + Misc: + - [ ] Made _.forEach, _.forIn, _.forOwn, & _.times implicitly end a chain sequence + - [ ] Removed thisArg params from most methods + - [ ] Made “By” methods provide a single param to iteratees + - [ ] Made _.words chainable by default + - [ ] Removed isDeep params from _.clone & _.flatten + - [ ] Removed _.bindAll support for binding all methods when no names are provided + - [ ] Removed func-first param signature from _.before & _.after + - [ ] _.extend as an alias of _.assignIn + - [ ] _.extendWith as an alias of _.assignInWith + - [ ] Added clear method to _.memoize.Cache + - [ ] Added support for ES6 maps, sets, & symbols to _.clone, _.isEqual, & _.toArray + - [ ] Enabled _.flow & _.flowRight to accept an array of functions + - [ ] Ensured “Collection” methods treat functions as objects + - [ ] Ensured _.assign, _.defaults, & _.merge coerce object values to objects + - [ ] Ensured _.bindKey bound functions call object[key] when called with the new operator + - [ ] Ensured _.isFunction returns true for generator functions + - [ ] Ensured _.merge assigns typed arrays directly + - [ ] Made _(...) an iterator & iterable + - [ ] Made _.drop, _.take, & right forms coerce n of undefined to 0 + + Methods: + - [ ] _.concat + - [ ] _.differenceBy + - [ ] _.differenceWith + - [ ] _.flatMap + - [ ] _.fromPairs + - [ ] _.intersectionBy + - [ ] _.intersectionWith + - [ ] _.join + - [ ] _.pullAll + - [ ] _.pullAllBy + - [ ] _.reverse + - [ ] _.sortedLastIndexOf + - [ ] _.unionBy + - [ ] _.unionWith + - [ ] _.uniqWith + - [ ] _.xorBy + - [ ] _.xorWith + - [ ] _.toString + + - [ ] _.invoke + - [ ] _.setWith + - [ ] _.toPairs + - [ ] _.toPairsIn + - [ ] _.unset + + - [ ] _.replace + - [ ] _.split + + - [ ] _.cond + - [ ] _.conforms + - [ ] _.nthArg + - [ ] _.over + - [ ] _.overEvery + - [ ] _.overSome + - [ ] _.rangeRight + + - [ ] _.next + */ + +declare var _: _.LoDashStatic; + +declare module _ { + interface LoDashStatic { + /** + * Creates a lodash object which wraps the given value to enable intuitive method chaining. + * + * In addition to Lo-Dash methods, wrappers also have the following Array methods: + * concat, join, pop, push, reverse, shift, slice, sort, splice, and unshift + * + * Chaining is supported in custom builds as long as the value method is implicitly or + * explicitly included in the build. + * + * The chainable wrapper functions are: + * after, assign, bind, bindAll, bindKey, chain, chunk, compact, compose, concat, countBy, + * createCallback, curry, debounce, defaults, defer, delay, difference, filter, flatten, + * forEach, forEachRight, forIn, forInRight, forOwn, forOwnRight, functions, groupBy, + * keyBy, initial, intersection, invert, invoke, keys, map, max, memoize, merge, min, + * object, omit, once, pairs, partial, partialRight, pick, pluck, pull, push, range, reject, + * remove, rest, reverse, sample, shuffle, slice, sort, sortBy, splice, tap, throttle, times, + * toArray, transform, union, uniq, unset, unshift, unzip, values, where, without, wrap, and zip + * + * The non-chainable wrapper functions are: + * clone, cloneDeep, contains, escape, every, find, findIndex, findKey, findLast, + * findLastIndex, findLastKey, has, identity, indexOf, isArguments, isArray, isBoolean, + * isDate, isElement, isEmpty, isEqual, isFinite, isFunction, isNaN, isNull, isNumber, + * isObject, isPlainObject, isRegExp, isString, isUndefined, join, lastIndexOf, mixin, + * noConflict, parseInt, pop, random, reduce, reduceRight, result, shift, size, some, + * sortedIndex, runInContext, template, unescape, uniqueId, and value + * + * The wrapper functions first and last return wrapped values when n is provided, otherwise + * they return unwrapped values. + * + * Explicit chaining can be enabled by using the _.chain method. + **/ + (value: number): LoDashImplicitWrapper<number>; + (value: string): LoDashImplicitStringWrapper; + (value: boolean): LoDashImplicitWrapper<boolean>; + (value: Array<number>): LoDashImplicitNumberArrayWrapper; + <T>(value: Array<T>): LoDashImplicitArrayWrapper<T>; + <T extends {}>(value: T): LoDashImplicitObjectWrapper<T>; + (value: any): LoDashImplicitWrapper<any>; + + /** + * The semantic version number. + **/ + VERSION: string; + + /** + * By default, the template delimiters used by Lo-Dash are similar to those in embedded Ruby + * (ERB). Change the following template settings to use alternative delimiters. + **/ + templateSettings: TemplateSettings; + } + + /** + * By default, the template delimiters used by Lo-Dash are similar to those in embedded Ruby + * (ERB). Change the following template settings to use alternative delimiters. + **/ + interface TemplateSettings { + /** + * The "escape" delimiter. + **/ + escape?: RegExp; + + /** + * The "evaluate" delimiter. + **/ + evaluate?: RegExp; + + /** + * An object to import into the template as local variables. + **/ + imports?: Dictionary<any>; + + /** + * The "interpolate" delimiter. + **/ + interpolate?: RegExp; + + /** + * Used to reference the data object in the template text. + **/ + variable?: string; + } + + /** + * Creates a cache object to store key/value pairs. + */ + interface MapCache { + /** + * Removes `key` and its value from the cache. + * @param key The key of the value to remove. + * @return Returns `true` if the entry was removed successfully, else `false`. + */ + delete(key: string): boolean; + + /** + * Gets the cached value for `key`. + * @param key The key of the value to get. + * @return Returns the cached value. + */ + get(key: string): any; + + /** + * Checks if a cached value for `key` exists. + * @param key The key of the entry to check. + * @return Returns `true` if an entry for `key` exists, else `false`. + */ + has(key: string): boolean; + + /** + * Sets `value` to `key` of the cache. + * @param key The key of the value to cache. + * @param value The value to cache. + * @return Returns the cache object. + */ + set(key: string, value: any): _.Dictionary<any>; + } + interface MapCacheConstructor { + new (): MapCache; + } + + interface LoDashWrapperBase<T, TWrapper> { } + + interface LoDashImplicitWrapperBase<T, TWrapper> extends LoDashWrapperBase<T, TWrapper> { } + + interface LoDashExplicitWrapperBase<T, TWrapper> extends LoDashWrapperBase<T, TWrapper> { } + + interface LoDashImplicitWrapper<T> extends LoDashImplicitWrapperBase<T, LoDashImplicitWrapper<T>> { } + + interface LoDashExplicitWrapper<T> extends LoDashExplicitWrapperBase<T, LoDashExplicitWrapper<T>> { } + + interface LoDashImplicitStringWrapper extends LoDashImplicitWrapper<string> { } + + interface LoDashExplicitStringWrapper extends LoDashExplicitWrapper<string> { } + + interface LoDashImplicitObjectWrapper<T> extends LoDashImplicitWrapperBase<T, LoDashImplicitObjectWrapper<T>> { } + + interface LoDashExplicitObjectWrapper<T> extends LoDashExplicitWrapperBase<T, LoDashExplicitObjectWrapper<T>> { } + + interface LoDashImplicitArrayWrapper<T> extends LoDashImplicitWrapperBase<T[], LoDashImplicitArrayWrapper<T>> { + pop(): T; + push(...items: T[]): LoDashImplicitArrayWrapper<T>; + shift(): T; + sort(compareFn?: (a: T, b: T) => number): LoDashImplicitArrayWrapper<T>; + splice(start: number): LoDashImplicitArrayWrapper<T>; + splice(start: number, deleteCount: number, ...items: any[]): LoDashImplicitArrayWrapper<T>; + unshift(...items: T[]): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashExplicitArrayWrapper<T> extends LoDashExplicitWrapperBase<T[], LoDashExplicitArrayWrapper<T>> { + pop(): LoDashExplicitObjectWrapper<T>; + push(...items: T[]): LoDashExplicitArrayWrapper<T>; + shift(): LoDashExplicitObjectWrapper<T>; + sort(compareFn?: (a: T, b: T) => number): LoDashExplicitArrayWrapper<T>; + splice(start: number): LoDashExplicitArrayWrapper<T>; + splice(start: number, deleteCount: number, ...items: any[]): LoDashExplicitArrayWrapper<T>; + unshift(...items: T[]): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashImplicitNumberArrayWrapper extends LoDashImplicitArrayWrapper<number> { } + + interface LoDashExplicitNumberArrayWrapper extends LoDashExplicitArrayWrapper<number> { } + + /********* + * Array * + *********/ + + //_.chunk + interface LoDashStatic { + /** + * Creates an array of elements split into groups the length of size. If collection can’t be split evenly, the + * final chunk will be the remaining elements. + * + * @param array The array to process. + * @param size The length of each chunk. + * @return Returns the new array containing chunks. + */ + chunk<T>( + array: List<T>, + size?: number + ): T[][]; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.chunk + */ + chunk(size?: number): LoDashImplicitArrayWrapper<T[]>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.chunk + */ + chunk<TResult>(size?: number): LoDashImplicitArrayWrapper<TResult[]>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.chunk + */ + chunk(size?: number): LoDashExplicitArrayWrapper<T[]>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.chunk + */ + chunk<TResult>(size?: number): LoDashExplicitArrayWrapper<TResult[]>; + } + + //_.compact + interface LoDashStatic { + /** + * Creates an array with all falsey values removed. The values false, null, 0, "", undefined, and NaN are + * falsey. + * + * @param array The array to compact. + * @return (Array) Returns the new array of filtered values. + */ + compact<T>(array?: List<T>): T[]; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.compact + */ + compact(): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.compact + */ + compact<TResult>(): LoDashImplicitArrayWrapper<TResult>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.compact + */ + compact(): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.compact + */ + compact<TResult>(): LoDashExplicitArrayWrapper<TResult>; + } + + //_.concat DUMMY + interface LoDashStatic { + /** + * Creates a new array concatenating `array` with any additional arrays + * and/or values. + * + * @static + * @memberOf _ + * @category Array + * @param {Array} array The array to concatenate. + * @param {...*} [values] The values to concatenate. + * @returns {Array} Returns the new concatenated array. + * @example + * + * var array = [1]; + * var other = _.concat(array, 2, [3], [[4]]); + * + * console.log(other); + * // => [1, 2, 3, [4]] + * + * console.log(array); + * // => [1] + */ + concat<T>(array: T[]|List<T>, ...values: (T|T[]|List<T>)[]) : T[]; + } + + //_.difference + interface LoDashStatic { + /** + * Creates an array of unique array values not included in the other provided arrays using SameValueZero for + * equality comparisons. + * + * @param array The array to inspect. + * @param values The arrays of values to exclude. + * @return Returns the new array of filtered values. + */ + difference<T>( + array: T[]|List<T>, + ...values: Array<T[]|List<T>> + ): T[]; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.difference + */ + difference(...values: (T[]|List<T>)[]): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.difference + */ + difference<TValue>(...values: (TValue[]|List<TValue>)[]): LoDashImplicitArrayWrapper<TValue>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.difference + */ + difference(...values: (T[]|List<T>)[]): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.difference + */ + difference<TValue>(...values: (TValue[]|List<TValue>)[]): LoDashExplicitArrayWrapper<TValue>; + } + + //_.differenceBy + interface LoDashStatic { + /** + * This method is like _.difference except that it accepts iteratee which is invoked for each element of array + * and values to generate the criterion by which uniqueness is computed. The iteratee is invoked with one + * argument: (value). + * + * @param array The array to inspect. + * @param values The values to exclude. + * @param iteratee The iteratee invoked per element. + * @returns Returns the new array of filtered values. + */ + differenceBy<T>( + array: T[]|List<T>, + values?: T[]|List<T>, + iteratee?: ((value: T) => any)|string + ): T[]; + + /** + * @see _.differenceBy + */ + differenceBy<T, W extends Object>( + array: T[]|List<T>, + values?: T[]|List<T>, + iteratee?: W + ): T[]; + + /** + * @see _.differenceBy + */ + differenceBy<T>( + array: T[]|List<T>, + values1?: T[]|List<T>, + values2?: T[]|List<T>, + iteratee?: ((value: T) => any)|string + ): T[]; + + /** + * @see _.differenceBy + */ + differenceBy<T, W extends Object>( + array: T[]|List<T>, + values1?: T[]|List<T>, + values2?: T[]|List<T>, + iteratee?: W + ): T[]; + + /** + * @see _.differenceBy + */ + differenceBy<T>( + array: T[]|List<T>, + values1?: T[]|List<T>, + values2?: T[]|List<T>, + values3?: T[]|List<T>, + iteratee?: ((value: T) => any)|string + ): T[]; + + /** + * @see _.differenceBy + */ + differenceBy<T, W extends Object>( + array: T[]|List<T>, + values1?: T[]|List<T>, + values2?: T[]|List<T>, + values3?: T[]|List<T>, + iteratee?: W + ): T[]; + + /** + * @see _.differenceBy + */ + differenceBy<T, W extends Object>( + array: T[]|List<T>, + values1?: T[]|List<T>, + values2?: T[]|List<T>, + values3?: T[]|List<T>, + values4?: T[]|List<T>, + iteratee?: W + ): T[]; + + /** + * @see _.differenceBy + */ + differenceBy<T>( + array: T[]|List<T>, + values1?: T[]|List<T>, + values2?: T[]|List<T>, + values3?: T[]|List<T>, + values4?: T[]|List<T>, + iteratee?: ((value: T) => any)|string + ): T[]; + + /** + * @see _.differenceBy + */ + differenceBy<T>( + array: T[]|List<T>, + values1?: T[]|List<T>, + values2?: T[]|List<T>, + values3?: T[]|List<T>, + values4?: T[]|List<T>, + values5?: T[]|List<T>, + iteratee?: ((value: T) => any)|string + ): T[]; + + /** + * @see _.differenceBy + */ + differenceBy<T, W extends Object>( + array: T[]|List<T>, + values1?: T[]|List<T>, + values2?: T[]|List<T>, + values3?: T[]|List<T>, + values4?: T[]|List<T>, + values5?: T[]|List<T>, + iteratee?: W + ): T[]; + + /** + * @see _.differenceBy + */ + differenceBy<T>( + array: T[]|List<T>, + ...values: any[] + ): T[]; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.differenceBy + */ + differenceBy<T>( + values?: T[]|List<T>, + iteratee?: ((value: T) => any)|string + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T, W extends Object>( + values?: T[]|List<T>, + iteratee?: W + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T>( + values1?: T[]|List<T>, + values2?: T[]|List<T>, + iteratee?: ((value: T) => any)|string + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T, W extends Object>( + values1?: T[]|List<T>, + values2?: T[]|List<T>, + iteratee?: W + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T>( + values1?: T[]|List<T>, + values2?: T[]|List<T>, + values3?: T[]|List<T>, + iteratee?: ((value: T) => any)|string + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T, W extends Object>( + values1?: T[]|List<T>, + values2?: T[]|List<T>, + values3?: T[]|List<T>, + iteratee?: W + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T>( + values1?: T[]|List<T>, + values2?: T[]|List<T>, + values3?: T[]|List<T>, + values4?: T[]|List<T>, + iteratee?: ((value: T) => any)|string + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T, W extends Object>( + values1?: T[]|List<T>, + values2?: T[]|List<T>, + values3?: T[]|List<T>, + values4?: T[]|List<T>, + iteratee?: W + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T>( + values1?: T[]|List<T>, + values2?: T[]|List<T>, + values3?: T[]|List<T>, + values4?: T[]|List<T>, + values5?: T[]|List<T>, + iteratee?: ((value: T) => any)|string + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T, W extends Object>( + values1?: T[]|List<T>, + values2?: T[]|List<T>, + values3?: T[]|List<T>, + values4?: T[]|List<T>, + values5?: T[]|List<T>, + iteratee?: W + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T>( + ...values: any[] + ): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.differenceBy + */ + differenceBy<T>( + values?: T[]|List<T>, + iteratee?: ((value: T) => any)|string + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T, W extends Object>( + values?: T[]|List<T>, + iteratee?: W + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T>( + values1?: T[]|List<T>, + values2?: T[]|List<T>, + iteratee?: ((value: T) => any)|string + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T, W extends Object>( + values1?: T[]|List<T>, + values2?: T[]|List<T>, + iteratee?: W + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T>( + values1?: T[]|List<T>, + values2?: T[]|List<T>, + values3?: T[]|List<T>, + iteratee?: ((value: T) => any)|string + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T, W extends Object>( + values1?: T[]|List<T>, + values2?: T[]|List<T>, + values3?: T[]|List<T>, + iteratee?: W + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T>( + values1?: T[]|List<T>, + values2?: T[]|List<T>, + values3?: T[]|List<T>, + values4?: T[]|List<T>, + iteratee?: ((value: T) => any)|string + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T, W extends Object>( + values1?: T[]|List<T>, + values2?: T[]|List<T>, + values3?: T[]|List<T>, + values4?: T[]|List<T>, + iteratee?: W + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T>( + values1?: T[]|List<T>, + values2?: T[]|List<T>, + values3?: T[]|List<T>, + values4?: T[]|List<T>, + values5?: T[]|List<T>, + iteratee?: ((value: T) => any)|string + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T, W extends Object>( + values1?: T[]|List<T>, + values2?: T[]|List<T>, + values3?: T[]|List<T>, + values4?: T[]|List<T>, + values5?: T[]|List<T>, + iteratee?: W + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T>( + ...values: any[] + ): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.differenceBy + */ + differenceBy<T>( + values?: T[]|List<T>, + iteratee?: ((value: T) => any)|string + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T, W extends Object>( + values?: T[]|List<T>, + iteratee?: W + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T>( + values1?: T[]|List<T>, + values2?: T[]|List<T>, + iteratee?: ((value: T) => any)|string + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T, W extends Object>( + values1?: T[]|List<T>, + values2?: T[]|List<T>, + iteratee?: W + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T>( + values1?: T[]|List<T>, + values2?: T[]|List<T>, + values3?: T[]|List<T>, + iteratee?: ((value: T) => any)|string + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T, W extends Object>( + values1?: T[]|List<T>, + values2?: T[]|List<T>, + values3?: T[]|List<T>, + iteratee?: W + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T>( + values1?: T[]|List<T>, + values2?: T[]|List<T>, + values3?: T[]|List<T>, + values4?: T[]|List<T>, + iteratee?: ((value: T) => any)|string + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T, W extends Object>( + values1?: T[]|List<T>, + values2?: T[]|List<T>, + values3?: T[]|List<T>, + values4?: T[]|List<T>, + iteratee?: W + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T>( + values1?: T[]|List<T>, + values2?: T[]|List<T>, + values3?: T[]|List<T>, + values4?: T[]|List<T>, + values5?: T[]|List<T>, + iteratee?: ((value: T) => any)|string + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T, W extends Object>( + values1?: T[]|List<T>, + values2?: T[]|List<T>, + values3?: T[]|List<T>, + values4?: T[]|List<T>, + values5?: T[]|List<T>, + iteratee?: W + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T>( + ...values: any[] + ): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.differenceBy + */ + differenceBy<T>( + values?: T[]|List<T>, + iteratee?: ((value: T) => any)|string + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T, W extends Object>( + values?: T[]|List<T>, + iteratee?: W + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T>( + values1?: T[]|List<T>, + values2?: T[]|List<T>, + iteratee?: ((value: T) => any)|string + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T, W extends Object>( + values1?: T[]|List<T>, + values2?: T[]|List<T>, + iteratee?: W + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T>( + values1?: T[]|List<T>, + values2?: T[]|List<T>, + values3?: T[]|List<T>, + iteratee?: ((value: T) => any)|string + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T, W extends Object>( + values1?: T[]|List<T>, + values2?: T[]|List<T>, + values3?: T[]|List<T>, + iteratee?: W + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T>( + values1?: T[]|List<T>, + values2?: T[]|List<T>, + values3?: T[]|List<T>, + values4?: T[]|List<T>, + iteratee?: ((value: T) => any)|string + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T, W extends Object>( + values1?: T[]|List<T>, + values2?: T[]|List<T>, + values3?: T[]|List<T>, + values4?: T[]|List<T>, + iteratee?: W + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T>( + values1?: T[]|List<T>, + values2?: T[]|List<T>, + values3?: T[]|List<T>, + values4?: T[]|List<T>, + values5?: T[]|List<T>, + iteratee?: ((value: T) => any)|string + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T, W extends Object>( + values1?: T[]|List<T>, + values2?: T[]|List<T>, + values3?: T[]|List<T>, + values4?: T[]|List<T>, + values5?: T[]|List<T>, + iteratee?: W + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.differenceBy + */ + differenceBy<T>( + ...values: any[] + ): LoDashExplicitArrayWrapper<T>; + } + + //_.differenceWith DUMMY + interface LoDashStatic { + /** + * Creates an array of unique `array` values not included in the other + * provided arrays using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero) + * for equality comparisons. + * + * @static + * @memberOf _ + * @category Array + * @param {Array} array The array to inspect. + * @param {...Array} [values] The values to exclude. + * @returns {Array} Returns the new array of filtered values. + * @example + * + * _.difference([3, 2, 1], [4, 2]); + * // => [3, 1] + */ + differenceWith( + array: any[]|List<any>, + ...values: any[] + ): any[]; + } + + //_.drop + interface LoDashStatic { + /** + * Creates a slice of array with n elements dropped from the beginning. + * + * @param array The array to query. + * @param n The number of elements to drop. + * @return Returns the slice of array. + */ + drop<T>(array: T[]|List<T>, n?: number): T[]; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.drop + */ + drop(n?: number): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.drop + */ + drop<T>(n?: number): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.drop + */ + drop(n?: number): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.drop + */ + drop<T>(n?: number): LoDashExplicitArrayWrapper<T>; + } + + //_.dropRight + interface LoDashStatic { + /** + * Creates a slice of array with n elements dropped from the end. + * + * @param array The array to query. + * @param n The number of elements to drop. + * @return Returns the slice of array. + */ + dropRight<T>( + array: List<T>, + n?: number + ): T[]; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.dropRight + */ + dropRight(n?: number): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.dropRight + */ + dropRight<TResult>(n?: number): LoDashImplicitArrayWrapper<TResult>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.dropRight + */ + dropRight(n?: number): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.dropRight + */ + dropRight<TResult>(n?: number): LoDashExplicitArrayWrapper<TResult>; + } + + //_.dropRightWhile + interface LoDashStatic { + /** + * Creates a slice of array excluding elements dropped from the end. Elements are dropped until predicate + * returns falsey. The predicate is bound to thisArg and invoked with three arguments: (value, index, array). + * + * If a property name is provided for predicate the created _.property style callback returns the property + * value of the given element. + * + * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for + * elements that have a matching property value, else false. + * + * If an object is provided for predicate the created _.matches style callback returns true for elements that + * match the properties of the given object, else false. + * + * @param array The array to query. + * @param predicate The function invoked per iteration. + * @param thisArg The this binding of predicate. + * @return Returns the slice of array. + */ + dropRightWhile<TValue>( + array: List<TValue>, + predicate?: ListIterator<TValue, boolean> + ): TValue[]; + + /** + * @see _.dropRightWhile + */ + dropRightWhile<TValue>( + array: List<TValue>, + predicate?: string + ): TValue[]; + + /** + * @see _.dropRightWhile + */ + dropRightWhile<TWhere, TValue>( + array: List<TValue>, + predicate?: TWhere + ): TValue[]; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.dropRightWhile + */ + dropRightWhile( + predicate?: ListIterator<T, boolean> + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.dropRightWhile + */ + dropRightWhile( + predicate?: string + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.dropRightWhile + */ + dropRightWhile<TWhere>( + predicate?: TWhere + ): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.dropRightWhile + */ + dropRightWhile<TValue>( + predicate?: ListIterator<TValue, boolean> + ): LoDashImplicitArrayWrapper<TValue>; + + /** + * @see _.dropRightWhile + */ + dropRightWhile<TValue>( + predicate?: string + ): LoDashImplicitArrayWrapper<TValue>; + + /** + * @see _.dropRightWhile + */ + dropRightWhile<TWhere, TValue>( + predicate?: TWhere + ): LoDashImplicitArrayWrapper<TValue>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.dropRightWhile + */ + dropRightWhile( + predicate?: ListIterator<T, boolean> + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.dropRightWhile + */ + dropRightWhile( + predicate?: string + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.dropRightWhile + */ + dropRightWhile<TWhere>( + predicate?: TWhere + ): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.dropRightWhile + */ + dropRightWhile<TValue>( + predicate?: ListIterator<TValue, boolean> + ): LoDashExplicitArrayWrapper<TValue>; + + /** + * @see _.dropRightWhile + */ + dropRightWhile<TValue>( + predicate?: string + ): LoDashExplicitArrayWrapper<TValue>; + + /** + * @see _.dropRightWhile + */ + dropRightWhile<TWhere, TValue>( + predicate?: TWhere + ): LoDashExplicitArrayWrapper<TValue>; + } + + //_.dropWhile + interface LoDashStatic { + /** + * Creates a slice of array excluding elements dropped from the beginning. Elements are dropped until predicate + * returns falsey. The predicate is bound to thisArg and invoked with three arguments: (value, index, array). + * + * If a property name is provided for predicate the created _.property style callback returns the property + * value of the given element. + * + * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for + * elements that have a matching property value, else false. + * + * If an object is provided for predicate the created _.matches style callback returns true for elements that + * have the properties of the given object, else false. + * + * @param array The array to query. + * @param predicate The function invoked per iteration. + * @param thisArg The this binding of predicate. + * @return Returns the slice of array. + */ + dropWhile<TValue>( + array: List<TValue>, + predicate?: ListIterator<TValue, boolean> + ): TValue[]; + + /** + * @see _.dropWhile + */ + dropWhile<TValue>( + array: List<TValue>, + predicate?: string + ): TValue[]; + + /** + * @see _.dropWhile + */ + dropWhile<TWhere, TValue>( + array: List<TValue>, + predicate?: TWhere + ): TValue[]; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.dropWhile + */ + dropWhile( + predicate?: ListIterator<T, boolean> + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.dropWhile + */ + dropWhile( + predicate?: string + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.dropWhile + */ + dropWhile<TWhere>( + predicate?: TWhere + ): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.dropWhile + */ + dropWhile<TValue>( + predicate?: ListIterator<TValue, boolean> + ): LoDashImplicitArrayWrapper<TValue>; + + /** + * @see _.dropWhile + */ + dropWhile<TValue>( + predicate?: string + ): LoDashImplicitArrayWrapper<TValue>; + + /** + * @see _.dropWhile + */ + dropWhile<TWhere, TValue>( + predicate?: TWhere + ): LoDashImplicitArrayWrapper<TValue>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.dropWhile + */ + dropWhile( + predicate?: ListIterator<T, boolean> + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.dropWhile + */ + dropWhile( + predicate?: string + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.dropWhile + */ + dropWhile<TWhere>( + predicate?: TWhere + ): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.dropWhile + */ + dropWhile<TValue>( + predicate?: ListIterator<TValue, boolean> + ): LoDashExplicitArrayWrapper<TValue>; + + /** + * @see _.dropWhile + */ + dropWhile<TValue>( + predicate?: string + ): LoDashExplicitArrayWrapper<TValue>; + + /** + * @see _.dropWhile + */ + dropWhile<TWhere, TValue>( + predicate?: TWhere + ): LoDashExplicitArrayWrapper<TValue>; + } + + //_.fill + interface LoDashStatic { + /** + * Fills elements of array with value from start up to, but not including, end. + * + * Note: This method mutates array. + * + * @param array The array to fill. + * @param value The value to fill array with. + * @param start The start position. + * @param end The end position. + * @return Returns array. + */ + fill<T>( + array: any[], + value: T, + start?: number, + end?: number + ): T[]; + + /** + * @see _.fill + */ + fill<T>( + array: List<any>, + value: T, + start?: number, + end?: number + ): List<T>; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.fill + */ + fill<T>( + value: T, + start?: number, + end?: number + ): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.fill + */ + fill<T>( + value: T, + start?: number, + end?: number + ): LoDashImplicitObjectWrapper<List<T>>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.fill + */ + fill<T>( + value: T, + start?: number, + end?: number + ): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.fill + */ + fill<T>( + value: T, + start?: number, + end?: number + ): LoDashExplicitObjectWrapper<List<T>>; + } + + //_.findIndex + interface LoDashStatic { + /** + * This method is like _.find except that it returns the index of the first element predicate returns truthy + * for instead of the element itself. + * + * If a property name is provided for predicate the created _.property style callback returns the property + * value of the given element. + * + * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for + * elements that have a matching property value, else false. + * + * If an object is provided for predicate the created _.matches style callback returns true for elements that + * have the properties of the given object, else false. + * + * @param array The array to search. + * @param predicate The function invoked per iteration. + * @param fromIndex The index to search from. + * @return Returns the index of the found element, else -1. + */ + findIndex<T>( + array: List<T>, + predicate?: ListIterator<T, boolean>, + fromIndex?: number + ): number; + + /** + * @see _.findIndex + */ + findIndex<T>( + array: List<T>, + predicate?: string, + fromIndex?: number + ): number; + + /** + * @see _.findIndex + */ + findIndex<W, T>( + array: List<T>, + predicate?: W, + fromIndex?: number + ): number; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.findIndex + */ + findIndex( + predicate?: ListIterator<T, boolean>, + fromIndex?: number + ): number; + + /** + * @see _.findIndex + */ + findIndex( + predicate?: string, + fromIndex?: number + ): number; + + /** + * @see _.findIndex + */ + findIndex<W>( + predicate?: W, + fromIndex?: number + ): number; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.findIndex + */ + findIndex<TResult>( + predicate?: ListIterator<TResult, boolean>, + fromIndex?: number + ): number; + + /** + * @see _.findIndex + */ + findIndex( + predicate?: string, + fromIndex?: number + ): number; + + /** + * @see _.findIndex + */ + findIndex<W>( + predicate?: W, + fromIndex?: number + ): number; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.findIndex + */ + findIndex( + predicate?: ListIterator<T, boolean>, + fromIndex?: number + ): LoDashExplicitWrapper<number>; + + /** + * @see _.findIndex + */ + findIndex( + predicate?: string, + fromIndex?: number + ): LoDashExplicitWrapper<number>; + + /** + * @see _.findIndex + */ + findIndex<W>( + predicate?: W, + fromIndex?: number + ): LoDashExplicitWrapper<number>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.findIndex + */ + findIndex<TResult>( + predicate?: ListIterator<TResult, boolean>, + fromIndex?: number + ): LoDashExplicitWrapper<number>; + + /** + * @see _.findIndex + */ + findIndex( + predicate?: string, + fromIndex?: number + ): LoDashExplicitWrapper<number>; + + /** + * @see _.findIndex + */ + findIndex<W>( + predicate?: W, + fromIndex?: number + ): LoDashExplicitWrapper<number>; + } + + //_.findLastIndex + interface LoDashStatic { + /** + * This method is like _.findIndex except that it iterates over elements of collection from right to left. + * + * If a property name is provided for predicate the created _.property style callback returns the property + * value of the given element. + * + * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for + * elements that have a matching property value, else false. + * + * If an object is provided for predicate the created _.matches style callback returns true for elements that + * have the properties of the given object, else false. + * + * @param array The array to search. + * @param predicate The function invoked per iteration. + * @param fromIndex The index to search from. + * @return Returns the index of the found element, else -1. + */ + findLastIndex<T>( + array: List<T>, + predicate?: ListIterator<T, boolean>, + fromIndex?: number + ): number; + + /** + * @see _.findLastIndex + */ + findLastIndex<T>( + array: List<T>, + predicate?: string, + fromIndex?: number + ): number; + + /** + * @see _.findLastIndex + */ + findLastIndex<W, T>( + array: List<T>, + predicate?: W, + fromIndex?: number + ): number; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.findLastIndex + */ + findLastIndex( + predicate?: ListIterator<T, boolean>, + fromIndex?: number + ): number; + + /** + * @see _.findLastIndex + */ + findLastIndex( + predicate?: string, + fromIndex?: number + ): number; + + /** + * @see _.findLastIndex + */ + findLastIndex<W>( + predicate?: W, + fromIndex?: number + ): number; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.findLastIndex + */ + findLastIndex<TResult>( + predicate?: ListIterator<TResult, boolean>, + fromIndex?: number + ): number; + + /** + * @see _.findLastIndex + */ + findLastIndex( + predicate?: string, + fromIndex?: number + ): number; + + /** + * @see _.findLastIndex + */ + findLastIndex<W>( + predicate?: W, + fromIndex?: number + ): number; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.findLastIndex + */ + findLastIndex( + predicate?: ListIterator<T, boolean>, + fromIndex?: number + ): LoDashExplicitWrapper<number>; + + /** + * @see _.findLastIndex + */ + findLastIndex( + predicate?: string, + fromIndex?: number + ): LoDashExplicitWrapper<number>; + + /** + * @see _.findLastIndex + */ + findLastIndex<W>( + predicate?: W, + fromIndex?: number + ): LoDashExplicitWrapper<number>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.findLastIndex + */ + findLastIndex<TResult>( + predicate?: ListIterator<TResult, boolean>, + fromIndex?: number + ): LoDashExplicitWrapper<number>; + + /** + * @see _.findLastIndex + */ + findLastIndex( + predicate?: string, + fromIndex?: number + ): LoDashExplicitWrapper<number>; + + /** + * @see _.findLastIndex + */ + findLastIndex<W>( + predicate?: W, + fromIndex?: number + ): LoDashExplicitWrapper<number>; + } + + //_.first + interface LoDashStatic { + /** + * @see _.head + */ + first<T>(array: List<T>): T; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.head + */ + first(): string; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.head + */ + first(): T; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.head + */ + first<T>(): T; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.head + */ + first(): LoDashExplicitWrapper<string>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.head + */ + first<T>(): T; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.head + */ + first<T>(): T; + } + + interface RecursiveArray<T> extends Array<T|RecursiveArray<T>> {} + interface ListOfRecursiveArraysOrValues<T> extends List<T|RecursiveArray<T>> {} + + //_.flatten + interface LoDashStatic { + /** + * Flattens a nested array. If isDeep is true the array is recursively flattened, otherwise it’s only + * flattened a single level. + * + * @param array The array to flatten. + * @param isDeep Specify a deep flatten. + * @return Returns the new flattened array. + */ + flatten<T>(array: ListOfRecursiveArraysOrValues<T>, isDeep: boolean): T[]; + + /** + * @see _.flatten + */ + flatten<T>(array: List<T|T[]>): T[]; + + /** + * @see _.flatten + */ + flatten<T>(array: ListOfRecursiveArraysOrValues<T>): RecursiveArray<T>; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.flatten + */ + flatten(): LoDashImplicitArrayWrapper<string>; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.flatten + */ + flatten<TResult>(isDeep?: boolean): LoDashImplicitArrayWrapper<TResult>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.flatten + */ + flatten<TResult>(isDeep?: boolean): LoDashImplicitArrayWrapper<TResult>; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.flatten + */ + flatten(): LoDashExplicitArrayWrapper<string>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.flatten + */ + flatten<TResult>(isDeep?: boolean): LoDashExplicitArrayWrapper<TResult>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.flatten + */ + flatten<TResult>(isDeep?: boolean): LoDashExplicitArrayWrapper<TResult>; + } + + //_.flattenDeep + interface LoDashStatic { + /** + * Recursively flattens a nested array. + * + * @param array The array to recursively flatten. + * @return Returns the new flattened array. + */ + flattenDeep<T>(array: ListOfRecursiveArraysOrValues<T>): T[]; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.flattenDeep + */ + flattenDeep(): LoDashImplicitArrayWrapper<string>; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.flattenDeep + */ + flattenDeep<T>(): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.flattenDeep + */ + flattenDeep<T>(): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.flattenDeep + */ + flattenDeep(): LoDashExplicitArrayWrapper<string>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.flattenDeep + */ + flattenDeep<T>(): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.flattenDeep + */ + flattenDeep<T>(): LoDashExplicitArrayWrapper<T>; + } + + // _.flattenDepth + interface LoDashStatic { + /** + * Recursively flatten array up to depth times. + * + * @param array The array to recursively flatten. + * @param number The maximum recursion depth. + * @return Returns the new flattened array. + */ + flattenDepth<T>(array: ListOfRecursiveArraysOrValues<T>, depth?: number): T[]; + } + + //_.fromPairs + interface LoDashStatic { + /** + * The inverse of `_.toPairs`; this method returns an object composed + * from key-value `pairs`. + * + * @static + * @memberOf _ + * @category Array + * @param {Array} pairs The key-value pairs. + * @returns {Object} Returns the new object. + * @example + * + * _.fromPairs([['fred', 30], ['barney', 40]]); + * // => { 'fred': 30, 'barney': 40 } + */ + fromPairs<T>( + array: List<[_.StringRepresentable, T]> + ): Dictionary<T>; + + /** + @see _.fromPairs + */ + fromPairs( + array: List<any[]> + ): Dictionary<any>; + } + + //_.fromPairs DUMMY + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.fromPairs + */ + fromPairs(): LoDashImplicitObjectWrapper<any>; + } + + //_.fromPairs DUMMY + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.fromPairs + */ + fromPairs(): LoDashExplicitObjectWrapper<any>; + } + + //_.head + interface LoDashStatic { + /** + * Gets the first element of array. + * + * @alias _.first + * + * @param array The array to query. + * @return Returns the first element of array. + */ + head<T>(array: List<T>): T; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.head + */ + head(): string; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.head + */ + head(): T; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.head + */ + head<T>(): T; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.head + */ + head(): LoDashExplicitWrapper<string>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.head + */ + head<T>(): T; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.head + */ + head<T>(): T; + } + + //_.indexOf + interface LoDashStatic { + /** + * Gets the index at which the first occurrence of `value` is found in `array` + * using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero) + * for equality comparisons. If `fromIndex` is negative, it's used as the offset + * from the end of `array`. If `array` is sorted providing `true` for `fromIndex` + * performs a faster binary search. + * + * @static + * @memberOf _ + * @category Array + * @param {Array} array The array to search. + * @param {*} value The value to search for. + * @param {number} [fromIndex=0] The index to search from. + * @returns {number} Returns the index of the matched value, else `-1`. + * @example + * + * _.indexOf([1, 2, 1, 2], 2); + * // => 1 + * + * // using `fromIndex` + * _.indexOf([1, 2, 1, 2], 2, 2); + * // => 3 + */ + indexOf<T>( + array: List<T>, + value: T, + fromIndex?: boolean|number + ): number; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.indexOf + */ + indexOf( + value: T, + fromIndex?: boolean|number + ): number; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.indexOf + */ + indexOf<TValue>( + value: TValue, + fromIndex?: boolean|number + ): number; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.indexOf + */ + indexOf( + value: T, + fromIndex?: boolean|number + ): LoDashExplicitWrapper<number>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.indexOf + */ + indexOf<TValue>( + value: TValue, + fromIndex?: boolean|number + ): LoDashExplicitWrapper<number>; + } + + //_.intersectionBy DUMMY + interface LoDashStatic { + /** + * This method is like `_.intersection` except that it accepts `iteratee` + * which is invoked for each element of each `arrays` to generate the criterion + * by which uniqueness is computed. The iteratee is invoked with one argument: (value). + * + * @static + * @memberOf _ + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @param {Function|Object|string} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Array} Returns the new array of shared values. + * @example + * + * _.intersectionBy([2.1, 1.2], [4.3, 2.4], Math.floor); + * // => [2.1] + * + * // using the `_.property` iteratee shorthand + * _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); + * // => [{ 'x': 1 }] + */ + intersectionBy( + array: any[]|List<any>, + ...values: any[] + ): any[]; + } + + //_.intersectionWith DUMMY + interface LoDashStatic { + /** + * This method is like `_.intersection` except that it accepts `comparator` + * which is invoked to compare elements of `arrays`. The comparator is invoked + * with two arguments: (arrVal, othVal). + * + * @static + * @memberOf _ + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new array of shared values. + * @example + * + * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * + * _.intersectionWith(objects, others, _.isEqual); + * // => [{ 'x': 1, 'y': 2 }] + */ + intersectionWith( + array: any[]|List<any>, + ...values: any[] + ): any[]; + } + + //_.join + interface LoDashStatic { + /** + * Converts all elements in `array` into a string separated by `separator`. + * + * @param array The array to convert. + * @param separator The element separator. + * @returns Returns the joined string. + */ + join( + array: List<any>, + separator?: string + ): string; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.join + */ + join(separator?: string): string; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.join + */ + join(separator?: string): string; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.join + */ + join(separator?: string): string; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.join + */ + join(separator?: string): LoDashExplicitWrapper<string>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.join + */ + join(separator?: string): LoDashExplicitWrapper<string>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.join + */ + join(separator?: string): LoDashExplicitWrapper<string>; + } + + //_.pullAll DUMMY + interface LoDashStatic { + /** + * This method is like `_.pull` except that it accepts an array of values to remove. + * + * **Note:** Unlike `_.difference`, this method mutates `array`. + * + * @static + * @memberOf _ + * @category Array + * @param {Array} array The array to modify. + * @param {Array} values The values to remove. + * @returns {Array} Returns `array`. + * @example + * + * var array = [1, 2, 3, 1, 2, 3]; + * + * _.pull(array, [2, 3]); + * console.log(array); + * // => [1, 1] + */ + pullAll( + array: any[]|List<any>, + ...values: any[] + ): any[]; + } + + //_.pullAllBy DUMMY + interface LoDashStatic { + /** + * This method is like `_.pullAll` except that it accepts `iteratee` which is + * invoked for each element of `array` and `values` to to generate the criterion + * by which uniqueness is computed. The iteratee is invoked with one argument: (value). + * + * **Note:** Unlike `_.differenceBy`, this method mutates `array`. + * + * @static + * @memberOf _ + * @category Array + * @param {Array} array The array to modify. + * @param {Array} values The values to remove. + * @param {Function|Object|string} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Array} Returns `array`. + * @example + * + * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }]; + * + * _.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x'); + * console.log(array); + * // => [{ 'x': 2 }] + */ + pullAllBy( + array: any[]|List<any>, + ...values: any[] + ): any[]; + } + + //_.reverse DUMMY + interface LoDashStatic { + /** + * Reverses `array` so that the first element becomes the last, the second + * element becomes the second to last, and so on. + * + * **Note:** This method mutates `array` and is based on + * [`Array#reverse`](https://mdn.io/Array/reverse). + * + * @memberOf _ + * @category Array + * @returns {Array} Returns `array`. + * @example + * + * var array = [1, 2, 3]; + * + * _.reverse(array); + * // => [3, 2, 1] + * + * console.log(array); + * // => [3, 2, 1] + */ + reverse( + array: any[]|List<any>, + ...values: any[] + ): any[]; + } + + //_.sortedIndexOf + interface LoDashStatic { + /** + * This method is like `_.indexOf` except that it performs a binary + * search on a sorted `array`. + * + * @static + * @memberOf _ + * @category Array + * @param {Array} array The array to search. + * @param {*} value The value to search for. + * @returns {number} Returns the index of the matched value, else `-1`. + * @example + * + * _.sortedIndexOf([1, 1, 2, 2], 2); + * // => 2 + */ + sortedIndexOf<T>( + array: List<T>, + value: T + ): number; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.sortedIndexOf + */ + sortedIndexOf( + value: T + ): number; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.sortedIndexOf + */ + sortedIndexOf<TValue>( + value: TValue + ): number; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.sortedIndexOf + */ + sortedIndexOf( + value: T + ): LoDashExplicitWrapper<number>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.sortedIndexOf + */ + sortedIndexOf<TValue>( + value: TValue + ): LoDashExplicitWrapper<number>; + } + + //_.initial + interface LoDashStatic { + /** + * Gets all but the last element of array. + * + * @param array The array to query. + * @return Returns the slice of array. + */ + initial<T>(array: List<T>): T[]; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.initial + */ + initial(): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.initial + */ + initial<T>(): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.initial + */ + initial(): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.initial + */ + initial<T>(): LoDashExplicitArrayWrapper<T>; + } + + //_.intersection + interface LoDashStatic { + /** + * Creates an array of unique values that are included in all of the provided arrays using SameValueZero for + * equality comparisons. + * + * @param arrays The arrays to inspect. + * @return Returns the new array of shared values. + */ + intersection<T>(...arrays: (T[]|List<T>)[]): T[]; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.intersection + */ + intersection<TResult>(...arrays: (TResult[]|List<TResult>)[]): LoDashImplicitArrayWrapper<TResult>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.intersection + */ + intersection<TResult>(...arrays: (TResult[]|List<TResult>)[]): LoDashImplicitArrayWrapper<TResult>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.intersection + */ + intersection<TResult>(...arrays: (TResult[]|List<TResult>)[]): LoDashExplicitArrayWrapper<TResult>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.intersection + */ + intersection<TResult>(...arrays: (TResult[]|List<TResult>)[]): LoDashExplicitArrayWrapper<TResult>; + } + + //_.last + interface LoDashStatic { + /** + * Gets the last element of array. + * + * @param array The array to query. + * @return Returns the last element of array. + */ + last<T>(array: List<T>): T; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.last + */ + last(): string; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.last + */ + last(): T; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.last + */ + last<T>(): T; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.last + */ + last(): LoDashExplicitWrapper<string>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.last + */ + last<T>(): T; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.last + */ + last<T>(): T; + } + + //_.lastIndexOf + interface LoDashStatic { + /** + * This method is like _.indexOf except that it iterates over elements of array from right to left. + * + * @param array The array to search. + * @param value The value to search for. + * @param fromIndex The index to search from or true to perform a binary search on a sorted array. + * @return Returns the index of the matched value, else -1. + */ + lastIndexOf<T>( + array: List<T>, + value: T, + fromIndex?: boolean|number + ): number; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.lastIndexOf + */ + lastIndexOf( + value: T, + fromIndex?: boolean|number + ): number; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.lastIndexOf + */ + lastIndexOf<TResult>( + value: TResult, + fromIndex?: boolean|number + ): number; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.lastIndexOf + */ + lastIndexOf( + value: T, + fromIndex?: boolean|number + ): LoDashExplicitWrapper<number>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.lastIndexOf + */ + lastIndexOf<TResult>( + value: TResult, + fromIndex?: boolean|number + ): LoDashExplicitWrapper<number>; + } + + //_.pull + interface LoDashStatic { + /** + * Removes all provided values from array using SameValueZero for equality comparisons. + * + * Note: Unlike _.without, this method mutates array. + * + * @param array The array to modify. + * @param values The values to remove. + * @return Returns array. + */ + pull<T>( + array: T[], + ...values: T[] + ): T[]; + + /** + * @see _.pull + */ + pull<T>( + array: List<T>, + ...values: T[] + ): List<T>; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.pull + */ + pull(...values: T[]): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.pull + */ + pull<TValue>(...values: TValue[]): LoDashImplicitObjectWrapper<List<TValue>>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.pull + */ + pull(...values: T[]): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.pull + */ + pull<TValue>(...values: TValue[]): LoDashExplicitObjectWrapper<List<TValue>>; + } + + //_.pullAt + interface LoDashStatic { + /** + * Removes elements from array corresponding to the given indexes and returns an array of the removed elements. + * Indexes may be specified as an array of indexes or as individual arguments. + * + * Note: Unlike _.at, this method mutates array. + * + * @param array The array to modify. + * @param indexes The indexes of elements to remove, specified as individual indexes or arrays of indexes. + * @return Returns the new array of removed elements. + */ + pullAt<T>( + array: List<T>, + ...indexes: (number|number[])[] + ): T[]; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.pullAt + */ + pullAt(...indexes: (number|number[])[]): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.pullAt + */ + pullAt<T>(...indexes: (number|number[])[]): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.pullAt + */ + pullAt(...indexes: (number|number[])[]): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.pullAt + */ + pullAt<T>(...indexes: (number|number[])[]): LoDashExplicitArrayWrapper<T>; + } + + //_.remove + interface LoDashStatic { + /** + * Removes all elements from array that predicate returns truthy for and returns an array of the removed + * elements. The predicate is bound to thisArg and invoked with three arguments: (value, index, array). + * + * If a property name is provided for predicate the created _.property style callback returns the property + * value of the given element. + * + * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for + * elements that have a matching property value, else false. + * + * If an object is provided for predicate the created _.matches style callback returns true for elements that + * have the properties of the given object, else false. + * + * Note: Unlike _.filter, this method mutates array. + * + * @param array The array to modify. + * @param predicate The function invoked per iteration. + * @param thisArg The this binding of predicate. + * @return Returns the new array of removed elements. + */ + remove<T>( + array: List<T>, + predicate?: ListIterator<T, boolean> + ): T[]; + + /** + * @see _.remove + */ + remove<T>( + array: List<T>, + predicate?: string + ): T[]; + + /** + * @see _.remove + */ + remove<W, T>( + array: List<T>, + predicate?: W + ): T[]; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.remove + */ + remove( + predicate?: ListIterator<T, boolean> + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.remove + */ + remove( + predicate?: string + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.remove + */ + remove<W>( + predicate?: W + ): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.remove + */ + remove<TResult>( + predicate?: ListIterator<TResult, boolean> + ): LoDashImplicitArrayWrapper<TResult>; + + /** + * @see _.remove + */ + remove<TResult>( + predicate?: string + ): LoDashImplicitArrayWrapper<TResult>; + + /** + * @see _.remove + */ + remove<W, TResult>( + predicate?: W + ): LoDashImplicitArrayWrapper<TResult>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.remove + */ + remove( + predicate?: ListIterator<T, boolean> + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.remove + */ + remove( + predicate?: string + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.remove + */ + remove<W>( + predicate?: W + ): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.remove + */ + remove<TResult>( + predicate?: ListIterator<TResult, boolean> + ): LoDashExplicitArrayWrapper<TResult>; + + /** + * @see _.remove + */ + remove<TResult>( + predicate?: string + ): LoDashExplicitArrayWrapper<TResult>; + + /** + * @see _.remove + */ + remove<W, TResult>( + predicate?: W + ): LoDashExplicitArrayWrapper<TResult>; + } + + //_.tail + interface LoDashStatic { + /** + * Gets all but the first element of array. + * + * @alias _.tail + * + * @param array The array to query. + * @return Returns the slice of array. + */ + tail<T>(array: List<T>): T[]; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.tail + */ + tail(): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.tail + */ + tail<T>(): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.tail + */ + tail(): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.tail + */ + tail<T>(): LoDashExplicitArrayWrapper<T>; + } + + //_.slice + interface LoDashStatic { + /** + * Creates a slice of array from start up to, but not including, end. + * + * @param array The array to slice. + * @param start The start position. + * @param end The end position. + * @return Returns the slice of array. + */ + slice<T>( + array: T[], + start?: number, + end?: number + ): T[]; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.slice + */ + slice( + start?: number, + end?: number + ): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.slice + */ + slice( + start?: number, + end?: number + ): LoDashExplicitArrayWrapper<T>; + } + + //_.sortedIndex + interface LoDashStatic { + /** + * Uses a binary search to determine the lowest index at which `value` should + * be inserted into `array` in order to maintain its sort order. + * + * @static + * @memberOf _ + * @category Array + * @param {Array} array The sorted array to inspect. + * @param {*} value The value to evaluate. + * @returns {number} Returns the index at which `value` should be inserted into `array`. + * @example + * + * _.sortedIndex([30, 50], 40); + * // => 1 + * + * _.sortedIndex([4, 5], 4); + * // => 0 + */ + sortedIndex<T, TSort>( + array: List<T>, + value: T + ): number; + + /** + * @see _.sortedIndex + */ + sortedIndex<T>( + array: List<T>, + value: T + ): number; + + /** + * @see _.sortedIndex + */ + sortedIndex<T>( + array: List<T>, + value: T + ): number; + + /** + * @see _.sortedIndex + */ + sortedIndex<W, T>( + array: List<T>, + value: T + ): number; + + /** + * @see _.sortedIndex + */ + sortedIndex<T>( + array: List<T>, + value: T + ): number; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.sortedIndex + */ + sortedIndex<TSort>( + value: string + ): number; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.sortedIndex + */ + sortedIndex<TSort>( + value: T + ): number; + + /** + * @see _.sortedIndex + */ + sortedIndex( + value: T + ): number; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.sortedIndex + */ + sortedIndex<T, TSort>( + value: T + ): number; + + /** + * @see _.sortedIndex + */ + sortedIndex<T>( + value: T + ): number; + + /** + * @see _.sortedIndex + */ + sortedIndex<W, T>( + value: T + ): number; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.sortedIndex + */ + sortedIndex<TSort>( + value: string + ): LoDashExplicitWrapper<number>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.sortedIndex + */ + sortedIndex<TSort>( + value: T + ): LoDashExplicitWrapper<number>; + + /** + * @see _.sortedIndex + */ + sortedIndex( + value: T + ): LoDashExplicitWrapper<number>; + + /** + * @see _.sortedIndex + */ + sortedIndex<W>( + value: T + ): LoDashExplicitWrapper<number>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.sortedIndex + */ + sortedIndex<T, TSort>( + value: T + ): LoDashExplicitWrapper<number>; + + /** + * @see _.sortedIndex + */ + sortedIndex<T>( + value: T + ): LoDashExplicitWrapper<number>; + + /** + * @see _.sortedIndex + */ + sortedIndex<W, T>( + value: T + ): LoDashExplicitWrapper<number>; + + + } + + //_.sortedIndexBy + interface LoDashStatic { + /** + * This method is like `_.sortedIndex` except that it accepts `iteratee` + * which is invoked for `value` and each element of `array` to compute their + * sort ranking. The iteratee is invoked with one argument: (value). + * + * @static + * @memberOf _ + * @category Array + * @param {Array} array The sorted array to inspect. + * @param {*} value The value to evaluate. + * @param {Function|Object|string} [iteratee=_.identity] The iteratee invoked per element. + * @returns {number} Returns the index at which `value` should be inserted into `array`. + * @example + * + * var dict = { 'thirty': 30, 'forty': 40, 'fifty': 50 }; + * + * _.sortedIndexBy(['thirty', 'fifty'], 'forty', _.propertyOf(dict)); + * // => 1 + * + * // using the `_.property` iteratee shorthand + * _.sortedIndexBy([{ 'x': 4 }, { 'x': 5 }], { 'x': 4 }, 'x'); + * // => 0 + */ + sortedIndexBy<T, TSort>( + array: List<T>, + value: T, + iteratee: (x: T) => TSort + ): number; + + /** + * @see _.sortedIndexBy + */ + sortedIndexBy<T>( + array: List<T>, + value: T, + iteratee: (x: T) => any + ): number; + + /** + * @see _.sortedIndexBy + */ + sortedIndexBy<T>( + array: List<T>, + value: T, + iteratee: string + ): number; + + /** + * @see _.sortedIndexBy + */ + sortedIndexBy<W, T>( + array: List<T>, + value: T, + iteratee: W + ): number; + + /** + * @see _.sortedIndexBy + */ + sortedIndexBy<T>( + array: List<T>, + value: T, + iteratee: Object + ): number; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.sortedIndexBy + */ + sortedIndexBy<TSort>( + value: string, + iteratee: (x: string) => TSort + ): number; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.sortedIndexBy + */ + sortedIndexBy<TSort>( + value: T, + iteratee: (x: T) => TSort + ): number; + + /** + * @see _.sortedIndexBy + */ + sortedIndexBy( + value: T, + iteratee: string + ): number; + + /** + * @see _.sortedIndexBy + */ + sortedIndexBy<W>( + value: T, + iteratee: W + ): number; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.sortedIndexBy + */ + sortedIndexBy<T, TSort>( + value: T, + iteratee: (x: T) => TSort + ): number; + + /** + * @see _.sortedIndexBy + */ + sortedIndexBy<T>( + value: T, + iteratee: (x: T) => any + ): number; + + /** + * @see _.sortedIndexBy + */ + sortedIndexBy<T>( + value: T, + iteratee: string + ): number; + + /** + * @see _.sortedIndexBy + */ + sortedIndexBy<W, T>( + value: T, + iteratee: W + ): number; + + /** + * @see _.sortedIndexBy + */ + sortedIndexBy<T>( + value: T, + iteratee: Object + ): number; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.sortedIndexBy + */ + sortedIndexBy<TSort>( + value: string, + iteratee: (x: string) => TSort + ): LoDashExplicitWrapper<number>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.sortedIndexBy + */ + sortedIndexBy<TSort>( + value: T, + iteratee: (x: T) => TSort + ): LoDashExplicitWrapper<number>; + + /** + * @see _.sortedIndexBy + */ + sortedIndexBy( + value: T, + iteratee: string + ): LoDashExplicitWrapper<number>; + + /** + * @see _.sortedIndexBy + */ + sortedIndexBy<W>( + value: T, + iteratee: W + ): LoDashExplicitWrapper<number>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.sortedIndexBy + */ + sortedIndexBy<T, TSort>( + value: T, + iteratee: (x: T) => TSort + ): LoDashExplicitWrapper<number>; + + /** + * @see _.sortedIndexBy + */ + sortedIndexBy<T>( + value: T, + iteratee: (x: T) => any + ): LoDashExplicitWrapper<number>; + + /** + * @see _.sortedIndexBy + */ + sortedIndexBy<T>( + value: T, + iteratee: string + ): LoDashExplicitWrapper<number>; + + /** + * @see _.sortedIndexBy + */ + sortedIndexBy<W, T>( + value: T, + iteratee: W + ): LoDashExplicitWrapper<number>; + + /** + * @see _.sortedIndexBy + */ + sortedIndexBy<T>( + value: T, + iteratee: Object + ): LoDashExplicitWrapper<number>; + } + + //_.sortedLastIndex + interface LoDashStatic { + /** + * This method is like `_.sortedIndex` except that it returns the highest + * index at which `value` should be inserted into `array` in order to + * maintain its sort order. + * + * @static + * @memberOf _ + * @category Array + * @param {Array} array The sorted array to inspect. + * @param {*} value The value to evaluate. + * @returns {number} Returns the index at which `value` should be inserted into `array`. + * @example + * + * _.sortedLastIndex([4, 5], 4); + * // => 1 + */ + sortedLastIndex<T, TSort>( + array: List<T>, + value: T + ): number; + + /** + * @see _.sortedLastIndex + */ + sortedLastIndex<T>( + array: List<T>, + value: T + ): number; + + /** + * @see _.sortedLastIndex + */ + sortedLastIndex<T>( + array: List<T>, + value: T + ): number; + + /** + * @see _.sortedLastIndex + */ + sortedLastIndex<W, T>( + array: List<T>, + value: T + ): number; + + /** + * @see _.sortedLastIndex + */ + sortedLastIndex<T>( + array: List<T>, + value: T + ): number; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.sortedLastIndex + */ + sortedLastIndex<TSort>( + value: string + ): number; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.sortedLastIndex + */ + sortedLastIndex<TSort>( + value: T + ): number; + + /** + * @see _.sortedLastIndex + */ + sortedLastIndex( + value: T + ): number; + + /** + * @see _.sortedLastIndex + */ + sortedLastIndex<W>( + value: T + ): number; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.sortedLastIndex + */ + sortedLastIndex<T, TSort>( + value: T + ): number; + + /** + * @see _.sortedLastIndex + */ + sortedLastIndex<T>( + value: T + ): number; + + /** + * @see _.sortedLastIndex + */ + sortedLastIndex<W, T>( + value: T + ): number; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.sortedLastIndex + */ + sortedLastIndex<TSort>( + value: string + ): LoDashExplicitWrapper<number>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.sortedLastIndex + */ + sortedLastIndex<TSort>( + value: T + ): LoDashExplicitWrapper<number>; + + /** + * @see _.sortedLastIndex + */ + sortedLastIndex( + value: T + ): LoDashExplicitWrapper<number>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.sortedLastIndex + */ + sortedLastIndex<T, TSort>( + value: T + ): LoDashExplicitWrapper<number>; + + /** + * @see _.sortedLastIndex + */ + sortedLastIndex<T>( + value: T + ): LoDashExplicitWrapper<number>; + + /** + * @see _.sortedLastIndex + */ + sortedLastIndex<W, T>( + value: T + ): LoDashExplicitWrapper<number>; + } + + //_.sortedLastIndexBy + interface LoDashStatic { + /** + * This method is like `_.sortedLastIndex` except that it accepts `iteratee` + * which is invoked for `value` and each element of `array` to compute their + * sort ranking. The iteratee is invoked with one argument: (value). + * + * @static + * @memberOf _ + * @category Array + * @param {Array} array The sorted array to inspect. + * @param {*} value The value to evaluate. + * @param {Function|Object|string} [iteratee=_.identity] The iteratee invoked per element. + * @returns {number} Returns the index at which `value` should be inserted into `array`. + * @example + * + * // using the `_.property` iteratee shorthand + * _.sortedLastIndexBy([{ 'x': 4 }, { 'x': 5 }], { 'x': 4 }, 'x'); + * // => 1 + */ + sortedLastIndexBy<T, TSort>( + array: List<T>, + value: T, + iteratee: (x: T) => TSort + ): number; + + /** + * @see _.sortedLastIndexBy + */ + sortedLastIndexBy<T>( + array: List<T>, + value: T, + iteratee: (x: T) => any + ): number; + + /** + * @see _.sortedLastIndexBy + */ + sortedLastIndexBy<T>( + array: List<T>, + value: T, + iteratee: string + ): number; + + /** + * @see _.sortedLastIndexBy + */ + sortedLastIndexBy<W, T>( + array: List<T>, + value: T, + iteratee: W + ): number; + + /** + * @see _.sortedLastIndexBy + */ + sortedLastIndexBy<T>( + array: List<T>, + value: T, + iteratee: Object + ): number; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.sortedLastIndexBy + */ + sortedLastIndexBy<TSort>( + value: string, + iteratee: (x: string) => TSort + ): number; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.sortedLastIndexBy + */ + sortedLastIndexBy<TSort>( + value: T, + iteratee: (x: T) => TSort + ): number; + + /** + * @see _.sortedLastIndexBy + */ + sortedLastIndexBy( + value: T, + iteratee: string + ): number; + + /** + * @see _.sortedLastIndexBy + */ + sortedLastIndexBy<W>( + value: T, + iteratee: W + ): number; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.sortedLastIndexBy + */ + sortedLastIndexBy<T, TSort>( + value: T, + iteratee: (x: T) => TSort + ): number; + + /** + * @see _.sortedLastIndexBy + */ + sortedLastIndexBy<T>( + value: T, + iteratee: (x: T) => any + ): number; + + /** + * @see _.sortedLastIndexBy + */ + sortedLastIndexBy<T>( + value: T, + iteratee: string + ): number; + + /** + * @see _.sortedLastIndexBy + */ + sortedLastIndexBy<W, T>( + value: T, + iteratee: W + ): number; + + /** + * @see _.sortedLastIndexBy + */ + sortedLastIndexBy<T>( + value: T, + iteratee: Object + ): number; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.sortedLastIndexBy + */ + sortedLastIndexBy<TSort>( + value: string, + iteratee: (x: string) => TSort + ): LoDashExplicitWrapper<number>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.sortedLastIndexBy + */ + sortedLastIndexBy<TSort>( + value: T, + iteratee: (x: T) => TSort + ): LoDashExplicitWrapper<number>; + + /** + * @see _.sortedLastIndexBy + */ + sortedLastIndexBy( + value: T, + iteratee: string + ): LoDashExplicitWrapper<number>; + + /** + * @see _.sortedLastIndexBy + */ + sortedLastIndexBy<W>( + value: T, + iteratee: W + ): LoDashExplicitWrapper<number>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.sortedLastIndexBy + */ + sortedLastIndexBy<T, TSort>( + value: T, + iteratee: (x: T) => TSort + ): LoDashExplicitWrapper<number>; + + /** + * @see _.sortedLastIndexBy + */ + sortedLastIndexBy<T>( + value: T, + iteratee: (x: T) => any + ): LoDashExplicitWrapper<number>; + + /** + * @see _.sortedLastIndexBy + */ + sortedLastIndexBy<T>( + value: T, + iteratee: string + ): LoDashExplicitWrapper<number>; + + /** + * @see _.sortedLastIndexBy + */ + sortedLastIndexBy<W, T>( + value: T, + iteratee: W + ): LoDashExplicitWrapper<number>; + + /** + * @see _.sortedLastIndexBy + */ + sortedLastIndexBy<T>( + value: T, + iteratee: Object + ): LoDashExplicitWrapper<number>; + } + + //_.sortedLastIndexOf DUMMY + interface LoDashStatic { + /** + * This method is like `_.lastIndexOf` except that it performs a binary + * search on a sorted `array`. + * + * @static + * @memberOf _ + * @category Array + * @param {Array} array The array to search. + * @param {*} value The value to search for. + * @returns {number} Returns the index of the matched value, else `-1`. + * @example + * + * _.sortedLastIndexOf([1, 1, 2, 2], 2); + * // => 3 + */ + sortedLastIndexOf( + array: any[]|List<any>, + ...values: any[] + ): any[]; + } + + //_.tail + interface LoDashStatic { + /** + * @see _.rest + */ + tail<T>(array: List<T>): T[]; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.rest + */ + tail(): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.rest + */ + tail<T>(): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.rest + */ + tail(): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.rest + */ + tail<T>(): LoDashExplicitArrayWrapper<T>; + } + + //_.take + interface LoDashStatic { + /** + * Creates a slice of array with n elements taken from the beginning. + * + * @param array The array to query. + * @param n The number of elements to take. + * @return Returns the slice of array. + */ + take<T>( + array: List<T>, + n?: number + ): T[]; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.take + */ + take(n?: number): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.take + */ + take<TResult>(n?: number): LoDashImplicitArrayWrapper<TResult>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.take + */ + take(n?: number): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.take + */ + take<TResult>(n?: number): LoDashExplicitArrayWrapper<TResult>; + } + + //_.takeRight + interface LoDashStatic { + /** + * Creates a slice of array with n elements taken from the end. + * + * @param array The array to query. + * @param n The number of elements to take. + * @return Returns the slice of array. + */ + takeRight<T>( + array: List<T>, + n?: number + ): T[]; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.takeRight + */ + takeRight(n?: number): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.takeRight + */ + takeRight<TResult>(n?: number): LoDashImplicitArrayWrapper<TResult>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.takeRight + */ + takeRight(n?: number): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.takeRight + */ + takeRight<TResult>(n?: number): LoDashExplicitArrayWrapper<TResult>; + } + + //_.takeRightWhile + interface LoDashStatic { + /** + * Creates a slice of array with elements taken from the end. Elements are taken until predicate returns + * falsey. The predicate is bound to thisArg and invoked with three arguments: (value, index, array). + * + * If a property name is provided for predicate the created _.property style callback returns the property + * value of the given element. + * + * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for + * elements that have a matching property value, else false. + * + * If an object is provided for predicate the created _.matches style callback returns true for elements that + * have the properties of the given object, else false. + * + * @param array The array to query. + * @param predicate The function invoked per iteration. + * @param thisArg The this binding of predicate. + * @return Returns the slice of array. + */ + takeRightWhile<TValue>( + array: List<TValue>, + predicate?: ListIterator<TValue, boolean> + ): TValue[]; + + /** + * @see _.takeRightWhile + */ + takeRightWhile<TValue>( + array: List<TValue>, + predicate?: string + ): TValue[]; + + /** + * @see _.takeRightWhile + */ + takeRightWhile<TWhere, TValue>( + array: List<TValue>, + predicate?: TWhere + ): TValue[]; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.takeRightWhile + */ + takeRightWhile( + predicate?: ListIterator<T, boolean> + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.takeRightWhile + */ + takeRightWhile( + predicate?: string + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.takeRightWhile + */ + takeRightWhile<TWhere>( + predicate?: TWhere + ): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.takeRightWhile + */ + takeRightWhile<TValue>( + predicate?: ListIterator<TValue, boolean> + ): LoDashImplicitArrayWrapper<TValue>; + + /** + * @see _.takeRightWhile + */ + takeRightWhile<TValue>( + predicate?: string + ): LoDashImplicitArrayWrapper<TValue>; + + /** + * @see _.takeRightWhile + */ + takeRightWhile<TWhere, TValue>( + predicate?: TWhere + ): LoDashImplicitArrayWrapper<TValue>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.takeRightWhile + */ + takeRightWhile( + predicate?: ListIterator<T, boolean> + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.takeRightWhile + */ + takeRightWhile( + predicate?: string + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.takeRightWhile + */ + takeRightWhile<TWhere>( + predicate?: TWhere + ): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.takeRightWhile + */ + takeRightWhile<TValue>( + predicate?: ListIterator<TValue, boolean> + ): LoDashExplicitArrayWrapper<TValue>; + + /** + * @see _.takeRightWhile + */ + takeRightWhile<TValue>( + predicate?: string + ): LoDashExplicitArrayWrapper<TValue>; + + /** + * @see _.takeRightWhile + */ + takeRightWhile<TWhere, TValue>( + predicate?: TWhere + ): LoDashExplicitArrayWrapper<TValue>; + } + + //_.takeWhile + interface LoDashStatic { + /** + * Creates a slice of array with elements taken from the beginning. Elements are taken until predicate returns + * falsey. The predicate is bound to thisArg and invoked with three arguments: (value, index, array). + * + * If a property name is provided for predicate the created _.property style callback returns the property + * value of the given element. + * + * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for + * elements that have a matching property value, else false. + * + * If an object is provided for predicate the created _.matches style callback returns true for elements that + * have the properties of the given object, else false. + * + * @param array The array to query. + * @param predicate The function invoked per iteration. + * @param thisArg The this binding of predicate. + * @return Returns the slice of array. + */ + takeWhile<TValue>( + array: List<TValue>, + predicate?: ListIterator<TValue, boolean> + ): TValue[]; + + /** + * @see _.takeWhile + */ + takeWhile<TValue>( + array: List<TValue>, + predicate?: string + ): TValue[]; + + /** + * @see _.takeWhile + */ + takeWhile<TWhere, TValue>( + array: List<TValue>, + predicate?: TWhere + ): TValue[]; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.takeWhile + */ + takeWhile( + predicate?: ListIterator<T, boolean> + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.takeWhile + */ + takeWhile( + predicate?: string + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.takeWhile + */ + takeWhile<TWhere>( + predicate?: TWhere + ): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.takeWhile + */ + takeWhile<TValue>( + predicate?: ListIterator<TValue, boolean> + ): LoDashImplicitArrayWrapper<TValue>; + + /** + * @see _.takeWhile + */ + takeWhile<TValue>( + predicate?: string + ): LoDashImplicitArrayWrapper<TValue>; + + /** + * @see _.takeWhile + */ + takeWhile<TWhere, TValue>( + predicate?: TWhere + ): LoDashImplicitArrayWrapper<TValue>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.takeWhile + */ + takeWhile( + predicate?: ListIterator<T, boolean> + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.takeWhile + */ + takeWhile( + predicate?: string + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.takeWhile + */ + takeWhile<TWhere>( + predicate?: TWhere + ): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.takeWhile + */ + takeWhile<TValue>( + predicate?: ListIterator<TValue, boolean> + ): LoDashExplicitArrayWrapper<TValue>; + + /** + * @see _.takeWhile + */ + takeWhile<TValue>( + predicate?: string + ): LoDashExplicitArrayWrapper<TValue>; + + /** + * @see _.takeWhile + */ + takeWhile<TWhere, TValue>( + predicate?: TWhere + ): LoDashExplicitArrayWrapper<TValue>; + } + + //_.union + interface LoDashStatic { + /** + * Creates an array of unique values, in order, from all of the provided arrays using SameValueZero for + * equality comparisons. + * + * @param arrays The arrays to inspect. + * @return Returns the new array of combined values. + */ + union<T>(...arrays: List<T>[]): T[]; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.union + */ + union(...arrays: List<T>[]): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.union + */ + union<T>(...arrays: List<T>[]): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.union + */ + union<T>(...arrays: List<T>[]): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.union + */ + union(...arrays: List<T>[]): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.union + */ + union<T>(...arrays: List<T>[]): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.union + */ + union<T>(...arrays: List<T>[]): LoDashExplicitArrayWrapper<T>; + } + + //_.unionBy + interface LoDashStatic { + /** + * This method is like `_.union` except that it accepts `iteratee` which is + * invoked for each element of each `arrays` to generate the criterion by which + * uniqueness is computed. The iteratee is invoked with one argument: (value). + * + * @param arrays The arrays to inspect. + * @param iteratee The iteratee invoked per element. + * @return Returns the new array of combined values. + */ + unionBy<T>( + arrays: T[]|List<T>, + iteratee?: (value: T) => any + ): T[]; + + /** + * @see _.unionBy + */ + unionBy<T, W extends Object>( + arrays: T[]|List<T>, + iteratee?: W + ): T[]; + + /** + * @see _.unionBy + */ + unionBy<T>( + arrays1: T[]|List<T>, + arrays2: T[]|List<T>, + iteratee?: (value: T) => any + ): T[]; + + /** + * @see _.unionBy + */ + unionBy<T, W extends Object>( + arrays1: T[]|List<T>, + arrays2: T[]|List<T>, + iteratee?: W + ): T[]; + + /** + * @see _.unionBy + */ + unionBy<T>( + arrays1: T[]|List<T>, + arrays2: T[]|List<T>, + arrays3: T[]|List<T>, + iteratee?: (value: T) => any + ): T[]; + + /** + * @see _.unionBy + */ + unionBy<T, W extends Object>( + arrays1: T[]|List<T>, + arrays2: T[]|List<T>, + arrays3: T[]|List<T>, + iteratee?: W + ): T[]; + + /** + * @see _.unionBy + */ + unionBy<T>( + arrays1: T[]|List<T>, + arrays2: T[]|List<T>, + arrays3: T[]|List<T>, + arrays4: T[]|List<T>, + iteratee?: (value: T) => any + ): T[]; + + /** + * @see _.unionBy + */ + unionBy<T, W extends Object>( + arrays1: T[]|List<T>, + arrays2: T[]|List<T>, + arrays3: T[]|List<T>, + arrays4: T[]|List<T>, + iteratee?: W + ): T[]; + + /** + * @see _.unionBy + */ + unionBy<T>( + arrays1: T[]|List<T>, + arrays2: T[]|List<T>, + arrays3: T[]|List<T>, + arrays4: T[]|List<T>, + arrays5: T[]|List<T>, + iteratee?: (value: T) => any + ): T[]; + + /** + * @see _.unionBy + */ + unionBy<T, W extends Object>( + arrays1: T[]|List<T>, + arrays2: T[]|List<T>, + arrays3: T[]|List<T>, + arrays4: T[]|List<T>, + arrays5: T[]|List<T>, + iteratee?: W + ): T[]; + + /** + * @see _.unionBy + */ + unionBy<T>( + arrays: T[]|List<T>, + ...iteratee: any[] + ): T[]; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.unionBy + */ + unionBy<T>( + iteratee?: (value: T) => any + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T, W extends Object>( + iteratee?: W + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T>( + arrays2: T[]|List<T>, + iteratee?: (value: T) => any + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T, W extends Object>( + arrays2: T[]|List<T>, + iteratee?: W + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T>( + arrays2: T[]|List<T>, + arrays3: T[]|List<T>, + iteratee?: (value: T) => any + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T, W extends Object>( + arrays2: T[]|List<T>, + arrays3: T[]|List<T>, + iteratee?: W + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T>( + arrays2: T[]|List<T>, + arrays3: T[]|List<T>, + arrays4: T[]|List<T>, + iteratee?: (value: T) => any + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T, W extends Object>( + arrays2: T[]|List<T>, + arrays3: T[]|List<T>, + arrays4: T[]|List<T>, + iteratee?: W + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T>( + arrays2: T[]|List<T>, + arrays3: T[]|List<T>, + arrays4: T[]|List<T>, + arrays5: T[]|List<T>, + iteratee?: (value: T) => any + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T, W extends Object>( + arrays2: T[]|List<T>, + arrays3: T[]|List<T>, + arrays4: T[]|List<T>, + arrays5: T[]|List<T>, + iteratee?: W + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T>( + ...iteratee: any[] + ): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.unionBy + */ + unionBy<T>( + iteratee?: (value: T) => any + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T, W extends Object>( + iteratee?: W + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T>( + arrays2: T[]|List<T>, + iteratee?: (value: T) => any + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T, W extends Object>( + arrays2: T[]|List<T>, + iteratee?: W + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T>( + arrays2: T[]|List<T>, + arrays3: T[]|List<T>, + iteratee?: (value: T) => any + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T, W extends Object>( + arrays2: T[]|List<T>, + arrays3: T[]|List<T>, + iteratee?: W + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T>( + arrays2: T[]|List<T>, + arrays3: T[]|List<T>, + arrays4: T[]|List<T>, + iteratee?: (value: T) => any + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T, W extends Object>( + arrays2: T[]|List<T>, + arrays3: T[]|List<T>, + arrays4: T[]|List<T>, + iteratee?: W + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T>( + arrays2: T[]|List<T>, + arrays3: T[]|List<T>, + arrays4: T[]|List<T>, + arrays5: T[]|List<T>, + iteratee?: (value: T) => any + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T, W extends Object>( + arrays2: T[]|List<T>, + arrays3: T[]|List<T>, + arrays4: T[]|List<T>, + arrays5: T[]|List<T>, + iteratee?: W + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T>( + ...iteratee: any[] + ): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.unionBy + */ + unionBy<T>( + iteratee?: (value: T) => any + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T, W extends Object>( + iteratee?: W + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T>( + arrays2: T[]|List<T>, + iteratee?: (value: T) => any + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T, W extends Object>( + arrays2: T[]|List<T>, + iteratee?: W + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T>( + arrays2: T[]|List<T>, + arrays3: T[]|List<T>, + iteratee?: (value: T) => any + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T, W extends Object>( + arrays2: T[]|List<T>, + arrays3: T[]|List<T>, + iteratee?: W + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T>( + arrays2: T[]|List<T>, + arrays3: T[]|List<T>, + arrays4: T[]|List<T>, + iteratee?: (value: T) => any + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T, W extends Object>( + arrays2: T[]|List<T>, + arrays3: T[]|List<T>, + arrays4: T[]|List<T>, + iteratee?: W + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T>( + arrays2: T[]|List<T>, + arrays3: T[]|List<T>, + arrays4: T[]|List<T>, + arrays5: T[]|List<T>, + iteratee?: (value: T) => any + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T, W extends Object>( + arrays2: T[]|List<T>, + arrays3: T[]|List<T>, + arrays4: T[]|List<T>, + arrays5: T[]|List<T>, + iteratee?: W + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T>( + ...iteratee: any[] + ): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.unionBy + */ + unionBy<T>( + iteratee?: (value: T) => any + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T, W extends Object>( + iteratee?: W + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T>( + arrays2: T[]|List<T>, + iteratee?: (value: T) => any + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T, W extends Object>( + arrays2: T[]|List<T>, + iteratee?: W + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T>( + arrays2: T[]|List<T>, + arrays3: T[]|List<T>, + iteratee?: (value: T) => any + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T, W extends Object>( + arrays2: T[]|List<T>, + arrays3: T[]|List<T>, + iteratee?: W + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T>( + arrays2: T[]|List<T>, + arrays3: T[]|List<T>, + arrays4: T[]|List<T>, + iteratee?: (value: T) => any + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T, W extends Object>( + arrays2: T[]|List<T>, + arrays3: T[]|List<T>, + arrays4: T[]|List<T>, + iteratee?: W + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T>( + arrays2: T[]|List<T>, + arrays3: T[]|List<T>, + arrays4: T[]|List<T>, + arrays5: T[]|List<T>, + iteratee?: (value: T) => any + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T, W extends Object>( + arrays2: T[]|List<T>, + arrays3: T[]|List<T>, + arrays4: T[]|List<T>, + arrays5: T[]|List<T>, + iteratee?: W + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.unionBy + */ + unionBy<T>( + ...iteratee: any[] + ): LoDashExplicitArrayWrapper<T>; + } + + //_.uniq + interface LoDashStatic { + /** + * Creates a duplicate-free version of an array, using + * [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero) + * for equality comparisons, in which only the first occurrence of each element + * is kept. + * + * @static + * @memberOf _ + * @category Array + * @param {Array} array The array to inspect. + * @returns {Array} Returns the new duplicate free array. + * @example + * + * _.uniq([2, 1, 2]); + * // => [2, 1] + */ + uniq<T>( + array: List<T> + ): T[]; + + /** + * @see _.uniq + */ + uniq<T, TSort>( + array: List<T> + ): T[]; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.uniq + */ + uniq<TSort>(): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.uniq + */ + uniq<TSort>(): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.uniq + */ + uniq(): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + uniq<T>(): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.uniq + */ + uniq<T, TSort>(): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.uniq + */ + uniq<TSort>(): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.uniq + */ + uniq<TSort>(): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.uniq + */ + uniq(): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.uniq + */ + uniq<T>(): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.uniq + */ + uniq<T, TSort>(): LoDashExplicitArrayWrapper<T>; + } + + //_.uniqBy + interface LoDashStatic { + /** + * This method is like `_.uniq` except that it accepts `iteratee` which is + * invoked for each element in `array` to generate the criterion by which + * uniqueness is computed. The iteratee is invoked with one argument: (value). + * + * @static + * @memberOf _ + * @category Array + * @param {Array} array The array to inspect. + * @param {Function|Object|string} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Array} Returns the new duplicate free array. + * @example + * + * _.uniqBy([2.1, 1.2, 2.3], Math.floor); + * // => [2.1, 1.2] + * + * // using the `_.property` iteratee shorthand + * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x'); + * // => [{ 'x': 1 }, { 'x': 2 }] + */ + uniqBy<T>( + array: List<T>, + iteratee: ListIterator<T, any> + ): T[]; + + /** + * @see _.uniqBy + */ + uniqBy<T, TSort>( + array: List<T>, + iteratee: ListIterator<T, TSort> + ): T[]; + + /** + * @see _.uniqBy + */ + uniqBy<T>( + array: List<T>, + iteratee: string + ): T[]; + + /** + * @see _.uniqBy + */ + uniqBy<T>( + array: List<T>, + iteratee: Object + ): T[]; + + /** + * @see _.uniqBy + */ + uniqBy<TWhere extends {}, T>( + array: List<T>, + iteratee: TWhere + ): T[]; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.uniqBy + */ + uniqBy<TSort>( + iteratee: ListIterator<T, TSort> + ): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.uniqBy + */ + uniqBy<TSort>( + iteratee: ListIterator<T, TSort> + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.uniqBy + */ + uniqBy( + iteratee: string + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.uniqBy + */ + uniqBy<TWhere extends {}>( + iteratee: TWhere + ): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.uniqBy + */ + uniqBy<T>( + iteratee: ListIterator<T, any> + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.uniqBy + */ + uniqBy<T, TSort>( + iteratee: ListIterator<T, TSort> + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.uniqBy + */ + uniqBy<T>( + iteratee: string + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.uniqBy + */ + uniqBy<T>( + iteratee: Object + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.uniqBy + */ + uniqBy<TWhere extends {}, T>( + iteratee: TWhere + ): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.uniqBy + */ + uniqBy<TSort>( + iteratee: ListIterator<T, TSort> + ): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.uniqBy + */ + uniqBy<TSort>( + iteratee: ListIterator<T, TSort> + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.uniqBy + */ + uniqBy( + iteratee: string + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.uniqBy + */ + uniqBy<TWhere extends {}>( + iteratee: TWhere + ): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.uniqBy + */ + uniqBy<T>( + iteratee: ListIterator<T, any> + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.uniqBy + */ + uniqBy<T, TSort>( + iteratee: ListIterator<T, TSort> + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.uniqBy + */ + uniqBy<T>( + iteratee: string + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.uniqBy + */ + uniqBy<T>( + iteratee: Object + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.uniqBy + */ + uniqBy<TWhere extends {}, T>( + iteratee: TWhere + ): LoDashExplicitArrayWrapper<T>; + } + + //_.sortedUniq + interface LoDashStatic { + /** + * This method is like `_.uniq` except that it's designed and optimized + * for sorted arrays. + * + * @static + * @memberOf _ + * @category Array + * @param {Array} array The array to inspect. + * @returns {Array} Returns the new duplicate free array. + * @example + * + * _.sortedUniq([1, 1, 2]); + * // => [1, 2] + */ + sortedUniq<T>( + array: List<T> + ): T[]; + + /** + * @see _.sortedUniq + */ + sortedUniq<T, TSort>( + array: List<T> + ): T[]; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.sortedUniq + */ + sortedUniq<TSort>(): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.sortedUniq + */ + sortedUniq<TSort>(): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.sortedUniq + */ + sortedUniq(): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + sortedUniq<T>(): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.sortedUniq + */ + sortedUniq<T, TSort>(): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.sortedUniq + */ + sortedUniq<TSort>(): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.sortedUniq + */ + sortedUniq<TSort>(): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.sortedUniq + */ + sortedUniq(): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.sortedUniq + */ + sortedUniq<T>(): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.sortedUniq + */ + sortedUniq<T, TSort>(): LoDashExplicitArrayWrapper<T>; + } + + //_.sortedUniqBy + interface LoDashStatic { + /** + * This method is like `_.uniqBy` except that it's designed and optimized + * for sorted arrays. + * + * @static + * @memberOf _ + * @category Array + * @param {Array} array The array to inspect. + * @param {Function} [iteratee] The iteratee invoked per element. + * @returns {Array} Returns the new duplicate free array. + * @example + * + * _.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor); + * // => [1.1, 2.2] + */ + sortedUniqBy<T>( + array: List<T>, + iteratee: ListIterator<T, any> + ): T[]; + + /** + * @see _.sortedUniqBy + */ + sortedUniqBy<T, TSort>( + array: List<T>, + iteratee: ListIterator<T, TSort> + ): T[]; + + /** + * @see _.sortedUniqBy + */ + sortedUniqBy<T>( + array: List<T>, + iteratee: string + ): T[]; + + /** + * @see _.sortedUniqBy + */ + sortedUniqBy<T>( + array: List<T>, + iteratee: Object + ): T[]; + + /** + * @see _.sortedUniqBy + */ + sortedUniqBy<TWhere extends {}, T>( + array: List<T>, + iteratee: TWhere + ): T[]; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.sortedUniqBy + */ + sortedUniqBy<TSort>( + iteratee: ListIterator<T, TSort> + ): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.sortedUniqBy + */ + sortedUniqBy<TSort>( + iteratee: ListIterator<T, TSort> + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.sortedUniqBy + */ + sortedUniqBy( + iteratee: string + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.sortedUniqBy + */ + sortedUniqBy<TWhere extends {}>( + iteratee: TWhere + ): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.sortedUniqBy + */ + sortedUniqBy<T>( + iteratee: ListIterator<T, any> + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.sortedUniqBy + */ + sortedUniqBy<T, TSort>( + iteratee: ListIterator<T, TSort> + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.sortedUniqBy + */ + sortedUniqBy<T>( + iteratee: string + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.sortedUniqBy + */ + sortedUniqBy<T>( + iteratee: Object + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.sortedUniqBy + */ + sortedUniqBy<TWhere extends {}, T>( + iteratee: TWhere + ): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.sortedUniqBy + */ + sortedUniqBy<TSort>( + iteratee: ListIterator<T, TSort> + ): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.sortedUniqBy + */ + sortedUniqBy<TSort>( + iteratee: ListIterator<T, TSort> + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.sortedUniqBy + */ + sortedUniqBy( + iteratee: string + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.sortedUniqBy + */ + sortedUniqBy<TWhere extends {}>( + iteratee: TWhere + ): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.sortedUniqBy + */ + sortedUniqBy<T>( + iteratee: ListIterator<T, any> + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.sortedUniqBy + */ + sortedUniqBy<T, TSort>( + iteratee: ListIterator<T, TSort> + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.sortedUniqBy + */ + sortedUniqBy<T>( + iteratee: string + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.sortedUniqBy + */ + sortedUniqBy<T>( + iteratee: Object + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.sortedUniqBy + */ + sortedUniqBy<TWhere extends {}, T>( + iteratee: TWhere + ): LoDashExplicitArrayWrapper<T>; + } + + //_.unionWith DUMMY + interface LoDashStatic { + /** + * This method is like `_.union` except that it accepts `comparator` which + * is invoked to compare elements of `arrays`. The comparator is invoked + * with two arguments: (arrVal, othVal). + * + * @static + * @memberOf _ + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new array of combined values. + * @example + * + * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * + * _.unionWith(objects, others, _.isEqual); + * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }] + */ + unionWith( + array: any[]|List<any>, + ...values: any[] + ): any[]; + } + + //_.uniqWith DUMMY + interface LoDashStatic { + /** + * This method is like `_.uniq` except that it accepts `comparator` which + * is invoked to compare elements of `array`. The comparator is invoked with + * two arguments: (arrVal, othVal). + * + * @static + * @memberOf _ + * @category Array + * @param {Array} array The array to inspect. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new duplicate free array. + * @example + * + * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * + * _.uniqWith(objects, _.isEqual); + * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }] + */ + uniqWith( + array: any[]|List<any>, + ...values: any[] + ): any[]; + } + + //_.unzip + interface LoDashStatic { + /** + * This method is like _.zip except that it accepts an array of grouped elements and creates an array + * regrouping the elements to their pre-zip configuration. + * + * @param array The array of grouped elements to process. + * @return Returns the new array of regrouped elements. + */ + unzip<T>(array: List<List<T>>): T[][]; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.unzip + */ + unzip<T>(): LoDashImplicitArrayWrapper<T[]>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.unzip + */ + unzip<T>(): LoDashImplicitArrayWrapper<T[]>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.unzip + */ + unzip<T>(): LoDashExplicitArrayWrapper<T[]>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.unzip + */ + unzip<T>(): LoDashExplicitArrayWrapper<T[]>; + } + + //_.unzipWith + interface LoDashStatic { + /** + * This method is like _.unzip except that it accepts an iteratee to specify how regrouped values should be + * combined. The iteratee is bound to thisArg and invoked with four arguments: (accumulator, value, index, + * group). + * + * @param array The array of grouped elements to process. + * @param iteratee The function to combine regrouped values. + * @param thisArg The this binding of iteratee. + * @return Returns the new array of regrouped elements. + */ + unzipWith<TArray, TResult>( + array: List<List<TArray>>, + iteratee?: MemoIterator<TArray, TResult> + ): TResult[]; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.unzipWith + */ + unzipWith<TArr, TResult>( + iteratee?: MemoIterator<TArr, TResult> + ): LoDashImplicitArrayWrapper<TResult>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.unzipWith + */ + unzipWith<TArr, TResult>( + iteratee?: MemoIterator<TArr, TResult> + ): LoDashImplicitArrayWrapper<TResult>; + } + + //_.without + interface LoDashStatic { + /** + * Creates an array excluding all provided values using SameValueZero for equality comparisons. + * + * @param array The array to filter. + * @param values The values to exclude. + * @return Returns the new array of filtered values. + */ + without<T>( + array: List<T>, + ...values: T[] + ): T[]; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.without + */ + without(...values: T[]): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.without + */ + without<T>(...values: T[]): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.without + */ + without(...values: T[]): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.without + */ + without<T>(...values: T[]): LoDashExplicitArrayWrapper<T>; + } + + //_.xor + interface LoDashStatic { + /** + * Creates an array of unique values that is the symmetric difference of the provided arrays. + * + * @param arrays The arrays to inspect. + * @return Returns the new array of values. + */ + xor<T>(...arrays: List<T>[]): T[]; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.xor + */ + xor(...arrays: List<T>[]): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.xor + */ + xor<T>(...arrays: List<T>[]): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.xor + */ + xor(...arrays: List<T>[]): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.xor + */ + xor<T>(...arrays: List<T>[]): LoDashExplicitArrayWrapper<T>; + } + + //_.xorBy DUMMY + interface LoDashStatic { + /** + * This method is like `_.xor` except that it accepts `iteratee` which is + * invoked for each element of each `arrays` to generate the criterion by which + * uniqueness is computed. The iteratee is invoked with one argument: (value). + * + * @static + * @memberOf _ + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @param {Function|Object|string} [iteratee=_.identity] The iteratee invoked per element. + * @returns {Array} Returns the new array of values. + * @example + * + * _.xorBy([2.1, 1.2], [4.3, 2.4], Math.floor); + * // => [1.2, 4.3] + * + * // using the `_.property` iteratee shorthand + * _.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); + * // => [{ 'x': 2 }] + */ + xorBy( + array: any[]|List<any>, + ...values: any[] + ): any[]; + } + + //_.xorWith DUMMY + interface LoDashStatic { + /** + * This method is like `_.xor` except that it accepts `comparator` which is + * invoked to compare elements of `arrays`. The comparator is invoked with + * two arguments: (arrVal, othVal). + * + * @static + * @memberOf _ + * @category Array + * @param {...Array} [arrays] The arrays to inspect. + * @param {Function} [comparator] The comparator invoked per element. + * @returns {Array} Returns the new array of values. + * @example + * + * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * + * _.xorWith(objects, others, _.isEqual); + * // => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }] + */ + xorWith( + array: any[]|List<any>, + ...values: any[] + ): any[]; + } + + //_.zip + interface LoDashStatic { + /** + * Creates an array of grouped elements, the first of which contains the first elements of the given arrays, + * the second of which contains the second elements of the given arrays, and so on. + * + * @param arrays The arrays to process. + * @return Returns the new array of grouped elements. + */ + zip<T>(...arrays: List<T>[]): T[][]; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.zip + */ + zip<T>(...arrays: List<T>[]): _.LoDashImplicitArrayWrapper<T[]>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.zip + */ + zip<T>(...arrays: List<T>[]): _.LoDashImplicitArrayWrapper<T[]>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.zip + */ + zip<T>(...arrays: List<T>[]): _.LoDashExplicitArrayWrapper<T[]>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.zip + */ + zip<T>(...arrays: List<T>[]): _.LoDashExplicitArrayWrapper<T[]>; + } + + //_.zipObject + interface LoDashStatic { + /** + * The inverse of _.pairs; this method returns an object composed from arrays of property names and values. + * Provide either a single two dimensional array, e.g. [[key1, value1], [key2, value2]] or two arrays, one of + * property names and one of corresponding values. + * + * @param props The property names. + * @param values The property values. + * @return Returns the new object. + */ + zipObject<TValues, TResult extends {}>( + props: List<StringRepresentable>|List<List<any>>, + values?: List<TValues> + ): TResult; + + /** + * @see _.zipObject + */ + zipObject<TResult extends {}>( + props: List<StringRepresentable>|List<List<any>>, + values?: List<any> + ): TResult; + + /** + * @see _.zipObject + */ + zipObject( + props: List<StringRepresentable>|List<List<any>>, + values?: List<any> + ): _.Dictionary<any>; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.zipObject + */ + zipObject<TValues, TResult extends {}>( + values?: List<TValues> + ): _.LoDashImplicitObjectWrapper<TResult>; + + /** + * @see _.zipObject + */ + zipObject<TResult extends {}>( + values?: List<any> + ): _.LoDashImplicitObjectWrapper<TResult>; + + /** + * @see _.zipObject + */ + zipObject( + values?: List<any> + ): _.LoDashImplicitObjectWrapper<_.Dictionary<any>>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.zipObject + */ + zipObject<TValues, TResult extends {}>( + values?: List<TValues> + ): _.LoDashImplicitObjectWrapper<TResult>; + + /** + * @see _.zipObject + */ + zipObject<TResult extends {}>( + values?: List<any> + ): _.LoDashImplicitObjectWrapper<TResult>; + + /** + * @see _.zipObject + */ + zipObject( + values?: List<any> + ): _.LoDashImplicitObjectWrapper<_.Dictionary<any>>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.zipObject + */ + zipObject<TValues, TResult extends {}>( + values?: List<TValues> + ): _.LoDashExplicitObjectWrapper<TResult>; + + /** + * @see _.zipObject + */ + zipObject<TResult extends {}>( + values?: List<any> + ): _.LoDashExplicitObjectWrapper<TResult>; + + /** + * @see _.zipObject + */ + zipObject( + values?: List<any> + ): _.LoDashExplicitObjectWrapper<_.Dictionary<any>>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.zipObject + */ + zipObject<TValues, TResult extends {}>( + values?: List<TValues> + ): _.LoDashExplicitObjectWrapper<TResult>; + + /** + * @see _.zipObject + */ + zipObject<TResult extends {}>( + values?: List<any> + ): _.LoDashExplicitObjectWrapper<TResult>; + + /** + * @see _.zipObject + */ + zipObject( + values?: List<any> + ): _.LoDashExplicitObjectWrapper<_.Dictionary<any>>; + } + + //_.zipWith + interface LoDashStatic { + /** + * This method is like _.zip except that it accepts an iteratee to specify how grouped values should be + * combined. The iteratee is bound to thisArg and invoked with four arguments: (accumulator, value, index, + * group). + * @param {...Array} [arrays] The arrays to process. + * @param {Function} [iteratee] The function to combine grouped values. + * @param {*} [thisArg] The `this` binding of `iteratee`. + * @return Returns the new array of grouped elements. + */ + zipWith<TResult>(...args: any[]): TResult[]; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.zipWith + */ + zipWith<TResult>(...args: any[]): LoDashImplicitArrayWrapper<TResult>; + } + + /********* + * Chain * + *********/ + + //_.chain + interface LoDashStatic { + /** + * Creates a lodash object that wraps value with explicit method chaining enabled. + * + * @param value The value to wrap. + * @return Returns the new lodash wrapper instance. + */ + chain(value: number): LoDashExplicitWrapper<number>; + chain(value: string): LoDashExplicitWrapper<string>; + chain(value: boolean): LoDashExplicitWrapper<boolean>; + chain<T>(value: T[]): LoDashExplicitArrayWrapper<T>; + chain<T extends {}>(value: T): LoDashExplicitObjectWrapper<T>; + chain(value: any): LoDashExplicitWrapper<any>; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.chain + */ + chain(): LoDashExplicitWrapper<T>; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.chain + */ + chain(): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.chain + */ + chain(): LoDashExplicitObjectWrapper<T>; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.chain + */ + chain(): TWrapper; + } + + //_.tap + interface LoDashStatic { + /** + * This method invokes interceptor and returns value. The interceptor is bound to thisArg and invoked with one + * argument; (value). The purpose of this method is to "tap into" a method chain in order to perform operations + * on intermediate results within the chain. + * + * @param value The value to provide to interceptor. + * @param interceptor The function to invoke. + * @parem thisArg The this binding of interceptor. + * @return Returns value. + **/ + tap<T>( + value: T, + interceptor: (value: T) => void + ): T; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.tap + */ + tap( + interceptor: (value: T) => void + ): TWrapper; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.tap + */ + tap( + interceptor: (value: T) => void + ): TWrapper; + } + + //_.thru + interface LoDashStatic { + /** + * This method is like _.tap except that it returns the result of interceptor. + * + * @param value The value to provide to interceptor. + * @param interceptor The function to invoke. + * @param thisArg The this binding of interceptor. + * @return Returns the result of interceptor. + */ + thru<T, TResult>( + value: T, + interceptor: (value: T) => TResult + ): TResult; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.thru + */ + thru<TResult extends number>( + interceptor: (value: T) => TResult): LoDashImplicitWrapper<TResult>; + + /** + * @see _.thru + */ + thru<TResult extends string>( + interceptor: (value: T) => TResult): LoDashImplicitWrapper<TResult>; + + /** + * @see _.thru + */ + thru<TResult extends boolean>( + interceptor: (value: T) => TResult): LoDashImplicitWrapper<TResult>; + + /** + * @see _.thru + */ + thru<TResult extends {}>( + interceptor: (value: T) => TResult): LoDashImplicitObjectWrapper<TResult>; + + /** + * @see _.thru + */ + thru<TResult>( + interceptor: (value: T) => TResult[]): LoDashImplicitArrayWrapper<TResult>; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.thru + */ + thru<TResult extends number>( + interceptor: (value: T) => TResult + ): LoDashExplicitWrapper<TResult>; + + /** + * @see _.thru + */ + thru<TResult extends string>( + interceptor: (value: T) => TResult + ): LoDashExplicitWrapper<TResult>; + + /** + * @see _.thru + */ + thru<TResult extends boolean>( + interceptor: (value: T) => TResult + ): LoDashExplicitWrapper<TResult>; + + /** + * @see _.thru + */ + thru<TResult extends {}>( + interceptor: (value: T) => TResult + ): LoDashExplicitObjectWrapper<TResult>; + + /** + * @see _.thru + */ + thru<TResult>( + interceptor: (value: T) => TResult[] + ): LoDashExplicitArrayWrapper<TResult>; + } + + //_.prototype.commit + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * Executes the chained sequence and returns the wrapped result. + * + * @return Returns the new lodash wrapper instance. + */ + commit(): TWrapper; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.commit + */ + commit(): TWrapper; + } + + //_.prototype.concat + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * Creates a new array joining a wrapped array with any additional arrays and/or values. + * + * @param items + * @return Returns the new concatenated array. + */ + concat<TItem>(...items: Array<TItem|Array<TItem>>): LoDashImplicitArrayWrapper<TItem>; + + /** + * @see _.concat + */ + concat(...items: Array<T|Array<T>>): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.concat + */ + concat<TItem>(...items: Array<TItem|Array<TItem>>): LoDashExplicitArrayWrapper<TItem>; + + /** + * @see _.concat + */ + concat(...items: Array<T|Array<T>>): LoDashExplicitArrayWrapper<T>; + } + + //_.prototype.plant + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * Creates a clone of the chained sequence planting value as the wrapped value. + * @param value The value to plant as the wrapped value. + * @return Returns the new lodash wrapper instance. + */ + plant(value: number): LoDashImplicitWrapper<number>; + + /** + * @see _.plant + */ + plant(value: string): LoDashImplicitStringWrapper; + + /** + * @see _.plant + */ + plant(value: boolean): LoDashImplicitWrapper<boolean>; + + /** + * @see _.plant + */ + plant(value: number[]): LoDashImplicitNumberArrayWrapper; + + /** + * @see _.plant + */ + plant<T>(value: T[]): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.plant + */ + plant<T extends {}>(value: T): LoDashImplicitObjectWrapper<T>; + + /** + * @see _.plant + */ + plant(value: any): LoDashImplicitWrapper<any>; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.plant + */ + plant(value: number): LoDashExplicitWrapper<number>; + + /** + * @see _.plant + */ + plant(value: string): LoDashExplicitStringWrapper; + + /** + * @see _.plant + */ + plant(value: boolean): LoDashExplicitWrapper<boolean>; + + /** + * @see _.plant + */ + plant(value: number[]): LoDashExplicitNumberArrayWrapper; + + /** + * @see _.plant + */ + plant<T>(value: T[]): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.plant + */ + plant<T extends {}>(value: T): LoDashExplicitObjectWrapper<T>; + + /** + * @see _.plant + */ + plant(value: any): LoDashExplicitWrapper<any>; + } + + //_.prototype.reverse + interface LoDashImplicitArrayWrapper<T> { + /** + * Reverses the wrapped array so the first element becomes the last, the second element becomes the second to + * last, and so on. + * + * Note: This method mutates the wrapped array. + * + * @return Returns the new reversed lodash wrapper instance. + */ + reverse(): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.reverse + */ + reverse(): LoDashExplicitArrayWrapper<T>; + } + + //_.prototype.toJSON + interface LoDashWrapperBase<T, TWrapper> { + /** + * @see _.value + */ + toJSON(): T; + } + + //_.prototype.toString + interface LoDashWrapperBase<T, TWrapper> { + /** + * Produces the result of coercing the unwrapped value to a string. + * + * @return Returns the coerced string value. + */ + toString(): string; + } + + //_.prototype.value + interface LoDashWrapperBase<T, TWrapper> { + /** + * Executes the chained sequence to extract the unwrapped value. + * + * @alias _.toJSON, _.valueOf + * + * @return Returns the resolved unwrapped value. + */ + value(): T; + } + + //_.valueOf + interface LoDashWrapperBase<T, TWrapper> { + /** + * @see _.value + */ + valueOf(): T; + } + + /************** + * Collection * + **************/ + + //_.at + interface LoDashStatic { + /** + * Creates an array of elements corresponding to the given keys, or indexes, of collection. Keys may be + * specified as individual arguments or as arrays of keys. + * + * @param collection The collection to iterate over. + * @param props The property names or indexes of elements to pick, specified individually or in arrays. + * @return Returns the new array of picked elements. + */ + at<T>( + collection: List<T>|Dictionary<T>, + ...props: (number|string|(number|string)[])[] + ): T[]; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.at + */ + at(...props: (number|string|(number|string)[])[]): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.at + */ + at<T>(...props: (number|string|(number|string)[])[]): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.at + */ + at(...props: (number|string|(number|string)[])[]): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.at + */ + at<T>(...props: (number|string|(number|string)[])[]): LoDashExplicitArrayWrapper<T>; + } + + //_.countBy + interface LoDashStatic { + /** + * Creates an object composed of keys generated from the results of running each element of collection through + * iteratee. The corresponding value of each key is the number of times the key was returned by iteratee. The + * iteratee is bound to thisArg and invoked with three arguments: + * (value, index|key, collection). + * + * If a property name is provided for iteratee the created _.property style callback returns the property + * value of the given element. + * + * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for + * elements that have a matching property value, else false. + * + * If an object is provided for iteratee the created _.matches style callback returns true for elements that + * have the properties of the given object, else false. + * + * @param collection The collection to iterate over. + * @param iteratee The function invoked per iteration. + * @param thisArg The this binding of iteratee. + * @return Returns the composed aggregate object. + */ + countBy<T>( + collection: List<T>, + iteratee?: ListIterator<T, any> + ): Dictionary<number>; + + /** + * @see _.countBy + */ + countBy<T>( + collection: Dictionary<T>, + iteratee?: DictionaryIterator<T, any> + ): Dictionary<number>; + + /** + * @see _.countBy + */ + countBy<T>( + collection: NumericDictionary<T>, + iteratee?: NumericDictionaryIterator<T, any> + ): Dictionary<number>; + + /** + * @see _.countBy + */ + countBy<T>( + collection: List<T>|Dictionary<T>|NumericDictionary<T>, + iteratee?: string + ): Dictionary<number>; + + /** + * @see _.countBy + */ + countBy<W, T>( + collection: List<T>|Dictionary<T>|NumericDictionary<T>, + iteratee?: W + ): Dictionary<number>; + + /** + * @see _.countBy + */ + countBy<T>( + collection: List<T>|Dictionary<T>|NumericDictionary<T>, + iteratee?: Object + ): Dictionary<number>; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.countBy + */ + countBy( + iteratee?: ListIterator<T, any> + ): LoDashImplicitObjectWrapper<Dictionary<number>>; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.countBy + */ + countBy( + iteratee?: ListIterator<T, any> + ): LoDashImplicitObjectWrapper<Dictionary<number>>; + + /** + * @see _.countBy + */ + countBy( + iteratee?: string + ): LoDashImplicitObjectWrapper<Dictionary<number>>; + + /** + * @see _.countBy + */ + countBy<W>( + iteratee?: W + ): LoDashImplicitObjectWrapper<Dictionary<number>>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.countBy + */ + countBy<T>( + iteratee?: ListIterator<T, any>|DictionaryIterator<T, any>|NumericDictionaryIterator<T, any> + ): LoDashImplicitObjectWrapper<Dictionary<number>>; + + /** + * @see _.countBy + */ + countBy( + iteratee?: string + ): LoDashImplicitObjectWrapper<Dictionary<number>>; + + /** + * @see _.countBy + */ + countBy<W>( + iteratee?: W + ): LoDashImplicitObjectWrapper<Dictionary<number>>; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.countBy + */ + countBy( + iteratee?: ListIterator<T, any> + ): LoDashExplicitObjectWrapper<Dictionary<number>>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.countBy + */ + countBy( + iteratee?: ListIterator<T, any> + ): LoDashExplicitObjectWrapper<Dictionary<number>>; + + /** + * @see _.countBy + */ + countBy( + iteratee?: string + ): LoDashExplicitObjectWrapper<Dictionary<number>>; + + /** + * @see _.countBy + */ + countBy<W>( + iteratee?: W + ): LoDashExplicitObjectWrapper<Dictionary<number>>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.countBy + */ + countBy<T>( + iteratee?: ListIterator<T, any>|DictionaryIterator<T, any>|NumericDictionaryIterator<T, any> + ): LoDashExplicitObjectWrapper<Dictionary<number>>; + + /** + * @see _.countBy + */ + countBy( + iteratee?: string + ): LoDashExplicitObjectWrapper<Dictionary<number>>; + + /** + * @see _.countBy + */ + countBy<W>( + iteratee?: W + ): LoDashExplicitObjectWrapper<Dictionary<number>>; + } + + //_.each + interface LoDashStatic { + /** + * @see _.forEach + */ + each<T>( + collection: T[], + iteratee?: ListIterator<T, any> + ): T[]; + + /** + * @see _.forEach + */ + each<T>( + collection: List<T>, + iteratee?: ListIterator<T, any> + ): List<T>; + + /** + * @see _.forEach + */ + each<T>( + collection: Dictionary<T>, + iteratee?: DictionaryIterator<T, any> + ): Dictionary<T>; + + /** + * @see _.forEach + */ + each<T extends {}>( + collection: T, + iteratee?: ObjectIterator<any, any> + ): T; + + /** + * @see _.forEach + */ + each<T extends {}, TValue>( + collection: T, + iteratee?: ObjectIterator<TValue, any> + ): T; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.forEach + */ + each( + iteratee: ListIterator<string, any> + ): LoDashImplicitWrapper<string>; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.forEach + */ + each( + iteratee: ListIterator<T, any> + ): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.forEach + */ + each<TValue>( + iteratee?: ListIterator<TValue, any>|DictionaryIterator<TValue, any> + ): LoDashImplicitObjectWrapper<T>; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.forEach + */ + each( + iteratee: ListIterator<string, any> + ): LoDashExplicitWrapper<string>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.forEach + */ + each( + iteratee: ListIterator<T, any> + ): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.forEach + */ + each<TValue>( + iteratee?: ListIterator<TValue, any>|DictionaryIterator<TValue, any> + ): LoDashExplicitObjectWrapper<T>; + } + + //_.eachRight + interface LoDashStatic { + /** + * @see _.forEachRight + */ + eachRight<T>( + collection: T[], + iteratee?: ListIterator<T, any> + ): T[]; + + /** + * @see _.forEachRight + */ + eachRight<T>( + collection: List<T>, + iteratee?: ListIterator<T, any> + ): List<T>; + + /** + * @see _.forEachRight + */ + eachRight<T>( + collection: Dictionary<T>, + iteratee?: DictionaryIterator<T, any> + ): Dictionary<T>; + + /** + * @see _.forEachRight + */ + eachRight<T extends {}>( + collection: T, + iteratee?: ObjectIterator<any, any> + ): T; + + /** + * @see _.forEachRight + */ + eachRight<T extends {}, TValue>( + collection: T, + iteratee?: ObjectIterator<TValue, any> + ): T; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.forEachRight + */ + eachRight( + iteratee: ListIterator<string, any> + ): LoDashImplicitWrapper<string>; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.forEachRight + */ + eachRight( + iteratee: ListIterator<T, any> + ): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.forEachRight + */ + eachRight<TValue>( + iteratee?: ListIterator<TValue, any>|DictionaryIterator<TValue, any> + ): LoDashImplicitObjectWrapper<T>; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.forEachRight + */ + eachRight( + iteratee: ListIterator<string, any> + ): LoDashExplicitWrapper<string>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.forEachRight + */ + eachRight( + iteratee: ListIterator<T, any> + ): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.forEachRight + */ + eachRight<TValue>( + iteratee?: ListIterator<TValue, any>|DictionaryIterator<TValue, any> + ): LoDashExplicitObjectWrapper<T>; + } + + //_.every + interface LoDashStatic { + /** + * Checks if predicate returns truthy for all elements of collection. Iteration is stopped once predicate + * returns falsey. The predicate is invoked with three arguments: (value, index|key, collection). + * + * @param collection The collection to iterate over. + * @param predicate The function invoked per iteration. + * @return Returns true if all elements pass the predicate check, else false. + */ + every<T>( + collection: List<T>, + predicate?: ListIterator<T, boolean> + ): boolean; + + /** + * @see _.every + */ + every<T>( + collection: Dictionary<T>, + predicate?: DictionaryIterator<T, boolean> + ): boolean; + + /** + * @see _.every + */ + every<T>( + collection: NumericDictionary<T>, + predicate?: NumericDictionaryIterator<T, boolean> + ): boolean; + + /** + * @see _.every + */ + every<T>( + collection: List<T>|Dictionary<T>|NumericDictionary<T>, + predicate?: string|any[] + ): boolean; + + /** + * @see _.every + */ + every<TObject extends {}, T>( + collection: List<T>|Dictionary<T>|NumericDictionary<T>, + predicate?: TObject + ): boolean; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.every + */ + every( + predicate?: ListIterator<T, boolean>|NumericDictionaryIterator<T, boolean> + ): boolean; + + /** + * @see _.every + */ + every( + predicate?: string|any[] + ): boolean; + + /** + * @see _.every + */ + every<TObject extends {}>( + predicate?: TObject + ): boolean; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.every + */ + every<TResult>( + predicate?: ListIterator<TResult, boolean>|DictionaryIterator<TResult, boolean>|NumericDictionaryIterator<T, boolean> + ): boolean; + + /** + * @see _.every + */ + every( + predicate?: string|any[] + ): boolean; + + /** + * @see _.every + */ + every<TObject extends {}>( + predicate?: TObject + ): boolean; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.every + */ + every( + predicate?: ListIterator<T, boolean>|NumericDictionaryIterator<T, boolean> + ): LoDashExplicitWrapper<boolean>; + + /** + * @see _.every + */ + every( + predicate?: string|any[] + ): LoDashExplicitWrapper<boolean>; + + /** + * @see _.every + */ + every<TObject extends {}>( + predicate?: TObject + ): LoDashExplicitWrapper<boolean>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.every + */ + every<TResult>( + predicate?: ListIterator<TResult, boolean>|DictionaryIterator<TResult, boolean>|NumericDictionaryIterator<T, boolean> + ): LoDashExplicitWrapper<boolean>; + + /** + * @see _.every + */ + every( + predicate?: string|any[] + ): LoDashExplicitWrapper<boolean>; + + /** + * @see _.every + */ + every<TObject extends {}>( + predicate?: TObject + ): LoDashExplicitWrapper<boolean>; + } + + //_.filter + interface LoDashStatic { + /** + * Iterates over elements of collection, returning an array of all elements predicate returns truthy for. The + * predicate is bound to thisArg and invoked with three arguments: (value, index|key, collection). + * + * If a property name is provided for predicate the created _.property style callback returns the property + * value of the given element. + * + * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for + * elements that have a matching property value, else false. + * + * If an object is provided for predicate the created _.matches style callback returns true for elements that + * have the properties of the given object, else false. + * + * @param collection The collection to iterate over. + * @param predicate The function invoked per iteration. + * @param thisArg The this binding of predicate. + * @return Returns the new filtered array. + */ + filter<T>( + collection: List<T>, + predicate?: ListIterator<T, boolean> + ): T[]; + + /** + * @see _.filter + */ + filter<T>( + collection: Dictionary<T>, + predicate?: DictionaryIterator<T, boolean> + ): T[]; + + /** + * @see _.filter + */ + filter( + collection: string, + predicate?: StringIterator<boolean> + ): string[]; + + /** + * @see _.filter + */ + filter<T>( + collection: List<T>|Dictionary<T>, + predicate: string + ): T[]; + + /** + * @see _.filter + */ + filter<W extends {}, T>( + collection: List<T>|Dictionary<T>, + predicate: W + ): T[]; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.filter + */ + filter( + predicate?: StringIterator<boolean> + ): LoDashImplicitArrayWrapper<string>; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.filter + */ + filter( + predicate: ListIterator<T, boolean> + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.filter + */ + filter( + predicate: string + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.filter + */ + filter<W>(predicate: W): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.filter + */ + filter<T>( + predicate: ListIterator<T, boolean>|DictionaryIterator<T, boolean> + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.filter + */ + filter<T>( + predicate: string + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.filter + */ + filter<W, T>(predicate: W): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.filter + */ + filter( + predicate?: StringIterator<boolean> + ): LoDashExplicitArrayWrapper<string>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.filter + */ + filter( + predicate: ListIterator<T, boolean> + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.filter + */ + filter( + predicate: string + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.filter + */ + filter<W>(predicate: W): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.filter + */ + filter<T>( + predicate: ListIterator<T, boolean>|DictionaryIterator<T, boolean> + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.filter + */ + filter<T>( + predicate: string + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.filter + */ + filter<W, T>(predicate: W): LoDashExplicitArrayWrapper<T>; + } + + //_.find + interface LoDashStatic { + /** + * Iterates over elements of collection, returning the first element predicate returns truthy for. + * The predicate is bound to thisArg and invoked with three arguments: (value, index|key, collection). + * + * If a property name is provided for predicate the created _.property style callback returns the property + * value of the given element. + * + * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for + * elements that have a matching property value, else false. + * + * If an object is provided for predicate the created _.matches style callback returns true for elements that + * have the properties of the given object, else false. + * + * @param collection The collection to search. + * @param predicate The function invoked per iteration. + * @param fromIndex The index to search from. + * @return Returns the matched element, else undefined. + */ + find<T>( + collection: List<T>, + predicate?: ListIterator<T, boolean>, + fromIndex?: number + ): T; + + /** + * @see _.find + */ + find<T>( + collection: Dictionary<T>, + predicate?: DictionaryIterator<T, boolean>, + fromIndex?: number + ): T; + + /** + * @see _.find + */ + find<T>( + collection: List<T>|Dictionary<T>, + predicate?: string, + fromIndex?: number + ): T; + + /** + * @see _.find + */ + find<TObject extends {}, T>( + collection: List<T>|Dictionary<T>, + predicate?: TObject, + fromIndex?: number + ): T; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.find + */ + find( + predicate?: ListIterator<T, boolean>, + fromIndex?: number + ): T; + + /** + * @see _.find + */ + find( + predicate?: string, + fromIndex?: number + ): T; + + /** + * @see _.find + */ + find<TObject extends {}>( + predicate?: TObject, + fromIndex?: number + ): T; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.find + */ + find<TResult>( + predicate?: ListIterator<TResult, boolean>|DictionaryIterator<TResult, boolean>, + fromIndex?: number + ): TResult; + + /** + * @see _.find + */ + find<TResult>( + predicate?: string, + fromIndex?: number + ): TResult; + + /** + * @see _.find + */ + find<TObject extends {}, TResult>( + predicate?: TObject, + fromIndex?: number + ): TResult; + } + + //_.findLast + interface LoDashStatic { + /** + * This method is like _.find except that it iterates over elements of a collection from + * right to left. + * @param collection Searches for a value in this list. + * @param callback The function called per iteration. + * @param fromIndex The index to search from. + * @return The found element, else undefined. + **/ + findLast<T>( + collection: Array<T>, + callback: ListIterator<T, boolean>, + fromIndex?: number + ): T; + + /** + * @see _.find + **/ + findLast<T>( + collection: List<T>, + callback: ListIterator<T, boolean>, + fromIndex?: number + ): T; + + /** + * @see _.find + **/ + findLast<T>( + collection: Dictionary<T>, + callback: DictionaryIterator<T, boolean>, + fromIndex?: number + ): T; + + /** + * @see _.find + * @param _.pluck style callback + **/ + findLast<W, T>( + collection: Array<T>, + whereValue: W, + fromIndex?: number + ): T; + + /** + * @see _.find + * @param _.pluck style callback + **/ + findLast<W, T>( + collection: List<T>, + whereValue: W, + fromIndex?: number + ): T; + + /** + * @see _.find + * @param _.pluck style callback + **/ + findLast<W, T>( + collection: Dictionary<T>, + whereValue: W, + fromIndex?: number + ): T; + + /** + * @see _.find + * @param _.where style callback + **/ + findLast<T>( + collection: Array<T>, + pluckValue: string, + fromIndex?: number + ): T; + + /** + * @see _.find + * @param _.where style callback + **/ + findLast<T>( + collection: List<T>, + pluckValue: string, + fromIndex?: number + ): T; + + /** + * @see _.find + * @param _.where style callback + **/ + findLast<T>( + collection: Dictionary<T>, + pluckValue: string, + fromIndex?: number + ): T; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.findLast + */ + findLast( + callback: ListIterator<T, boolean>, + fromIndex?: number + ): T; + /** + * @see _.findLast + * @param _.where style callback + */ + findLast<W>( + whereValue: W, + fromIndex?: number + ): T; + + /** + * @see _.findLast + * @param _.where style callback + */ + findLast( + pluckValue: string, + fromIndex?: number + ): T; + } + + //_.flatMap + interface LoDashStatic { + /** + * Creates an array of flattened values by running each element in collection through iteratee + * and concating its result to the other mapped values. The iteratee is invoked with three arguments: + * (value, index|key, collection). + * + * @param collection The collection to iterate over. + * @param iteratee The function invoked per iteration. + * @return Returns the new flattened array. + */ + flatMap<T, TResult>( + collection: List<T>, + iteratee?: ListIterator<T, TResult|TResult[]> + ): TResult[]; + + /** + * @see _.flatMap + */ + flatMap<TResult>( + collection: List<any>, + iteratee?: ListIterator<any, TResult|TResult[]> + ): TResult[]; + + /** + * @see _.flatMap + */ + flatMap<T, TResult>( + collection: Dictionary<T>, + iteratee?: DictionaryIterator<T, TResult|TResult[]> + ): TResult[]; + + /** + * @see _.flatMap + */ + flatMap<TResult>( + collection: Dictionary<any>, + iteratee?: DictionaryIterator<any, TResult|TResult[]> + ): TResult[]; + + /** + * @see _.flatMap + */ + flatMap<T, TResult>( + collection: NumericDictionary<T>, + iteratee?: NumericDictionaryIterator<T, TResult|TResult[]> + ): TResult[]; + + /** + * @see _.flatMap + */ + flatMap<TResult>( + collection: NumericDictionary<any>, + iteratee?: NumericDictionaryIterator<any, TResult|TResult[]> + ): TResult[]; + + /** + * @see _.flatMap + */ + flatMap<TObject extends Object, TResult>( + collection: TObject, + iteratee?: ObjectIterator<any, TResult|TResult[]> + ): TResult[]; + + /** + * @see _.flatMap + */ + flatMap<TResult>( + collection: Object, + iteratee?: ObjectIterator<any, TResult|TResult[]> + ): TResult[]; + + /** + * @see _.flatMap + */ + flatMap<TWhere extends Object, TObject extends Object>( + collection: TObject, + iteratee: TWhere + ): boolean[]; + + /** + * @see _.flatMap + */ + flatMap<TObject extends Object, TResult>( + collection: TObject, + iteratee: Object|string + ): TResult[]; + + /** + * @see _.flatMap + */ + flatMap<TObject extends Object>( + collection: TObject, + iteratee: [string, any] + ): boolean[]; + + /** + * @see _.flatMap + */ + flatMap<TResult>( + collection: string + ): string[]; + + /** + * @see _.flatMap + */ + flatMap<TResult>( + collection: Object, + iteratee?: Object|string + ): TResult[]; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.flatMap + */ + flatMap<TResult>( + iteratee: ListIterator<string, TResult|TResult[]> + ): LoDashImplicitArrayWrapper<TResult>; + + /** + * @see _.flatMap + */ + flatMap(): LoDashImplicitArrayWrapper<string>; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.flatMap + */ + flatMap<TResult>( + iteratee: ListIterator<T, TResult|TResult[]>|string + ): LoDashImplicitArrayWrapper<TResult>; + + /** + * @see _.flatMap + */ + flatMap<TWhere extends Object>( + iteratee: TWhere + ): LoDashImplicitArrayWrapper<boolean>; + + /** + * @see _.flatMap + */ + flatMap( + iteratee: [string, any] + ): LoDashImplicitArrayWrapper<boolean>; + + /** + * @see _.flatMap + */ + flatMap<TResult>(): LoDashImplicitArrayWrapper<TResult>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.flatMap + */ + flatMap<T, TResult>( + iteratee: ListIterator<T, TResult|TResult[]>|DictionaryIterator<T, TResult|TResult[]>|NumericDictionaryIterator<T, TResult|TResult[]> + ): LoDashImplicitArrayWrapper<TResult>; + + /** + * @see _.flatMap + */ + flatMap<TResult>( + iteratee: ObjectIterator<any, TResult|TResult[]>|string + ): LoDashImplicitArrayWrapper<TResult>; + + /** + * @see _.flatMap + */ + flatMap<TWhere extends Object>( + iteratee: TWhere + ): LoDashImplicitArrayWrapper<boolean>; + + /** + * @see _.flatMap + */ + flatMap( + iteratee: [string, any] + ): LoDashImplicitArrayWrapper<boolean>; + + /** + * @see _.flatMap + */ + flatMap<TResult>(): LoDashImplicitArrayWrapper<TResult>; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.flatMap + */ + flatMap<TResult>( + iteratee: ListIterator<string, TResult|TResult[]> + ): LoDashExplicitArrayWrapper<TResult>; + + /** + * @see _.flatMap + */ + flatMap(): LoDashExplicitArrayWrapper<string>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.flatMap + */ + flatMap<TResult>( + iteratee: ListIterator<T, TResult|TResult[]>|string + ): LoDashExplicitArrayWrapper<TResult>; + + /** + * @see _.flatMap + */ + flatMap<TWhere extends Object>( + iteratee: TWhere + ): LoDashExplicitArrayWrapper<boolean>; + + /** + * @see _.flatMap + */ + flatMap( + iteratee: [string, any] + ): LoDashExplicitArrayWrapper<boolean>; + + /** + * @see _.flatMap + */ + flatMap<TResult>(): LoDashExplicitArrayWrapper<TResult>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.flatMap + */ + flatMap<T, TResult>( + iteratee: ListIterator<T, TResult|TResult[]>|DictionaryIterator<T, TResult|TResult[]>|NumericDictionaryIterator<T, TResult|TResult[]> + ): LoDashExplicitArrayWrapper<TResult>; + + /** + * @see _.flatMap + */ + flatMap<TResult>( + iteratee: ObjectIterator<any, TResult|TResult[]>|string + ): LoDashExplicitArrayWrapper<TResult>; + + /** + * @see _.flatMap + */ + flatMap<TWhere extends Object>( + iteratee: TWhere + ): LoDashExplicitArrayWrapper<boolean>; + + /** + * @see _.flatMap + */ + flatMap( + iteratee: [string, any] + ): LoDashExplicitArrayWrapper<boolean>; + + /** + * @see _.flatMap + */ + flatMap<TResult>(): LoDashExplicitArrayWrapper<TResult>; + } + + //_.forEach + interface LoDashStatic { + /** + * Iterates over elements of collection invoking iteratee for each element. The iteratee is bound to thisArg + * and invoked with three arguments: + * (value, index|key, collection). Iteratee functions may exit iteration early by explicitly returning false. + * + * Note: As with other "Collections" methods, objects with a "length" property are iterated like arrays. To + * avoid this behavior _.forIn or _.forOwn may be used for object iteration. + * + * @alias _.each + * + * @param collection The collection to iterate over. + * @param iteratee The function invoked per iteration. + * @param thisArg The this binding of iteratee. + */ + forEach<T>( + collection: T[], + iteratee?: ListIterator<T, any> + ): T[]; + + /** + * @see _.forEach + */ + forEach<T>( + collection: List<T>, + iteratee?: ListIterator<T, any> + ): List<T>; + + /** + * @see _.forEach + */ + forEach<T>( + collection: Dictionary<T>, + iteratee?: DictionaryIterator<T, any> + ): Dictionary<T>; + + /** + * @see _.forEach + */ + forEach<T extends {}>( + collection: T, + iteratee?: ObjectIterator<any, any> + ): T; + + /** + * @see _.forEach + */ + forEach<T extends {}, TValue>( + collection: T, + iteratee?: ObjectIterator<TValue, any> + ): T; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.forEach + */ + forEach( + iteratee: ListIterator<string, any> + ): LoDashImplicitWrapper<string>; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.forEach + */ + forEach( + iteratee: ListIterator<T, any> + ): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.forEach + */ + forEach<TValue>( + iteratee?: ListIterator<TValue, any>|DictionaryIterator<TValue, any> + ): LoDashImplicitObjectWrapper<T>; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.forEach + */ + forEach( + iteratee: ListIterator<string, any> + ): LoDashExplicitWrapper<string>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.forEach + */ + forEach( + iteratee: ListIterator<T, any> + ): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.forEach + */ + forEach<TValue>( + iteratee?: ListIterator<TValue, any>|DictionaryIterator<TValue, any> + ): LoDashExplicitObjectWrapper<T>; + } + + //_.forEachRight + interface LoDashStatic { + /** + * This method is like _.forEach except that it iterates over elements of collection from right to left. + * + * @alias _.eachRight + * + * @param collection The collection to iterate over. + * @param iteratee The function called per iteration. + * @param thisArg The this binding of callback. + */ + forEachRight<T>( + collection: T[], + iteratee?: ListIterator<T, any> + ): T[]; + + /** + * @see _.forEachRight + */ + forEachRight<T>( + collection: List<T>, + iteratee?: ListIterator<T, any> + ): List<T>; + + /** + * @see _.forEachRight + */ + forEachRight<T>( + collection: Dictionary<T>, + iteratee?: DictionaryIterator<T, any> + ): Dictionary<T>; + + /** + * @see _.forEachRight + */ + forEachRight<T extends {}>( + collection: T, + iteratee?: ObjectIterator<any, any> + ): T; + + /** + * @see _.forEachRight + */ + forEachRight<T extends {}, TValue>( + collection: T, + iteratee?: ObjectIterator<TValue, any> + ): T; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.forEachRight + */ + forEachRight( + iteratee: ListIterator<string, any> + ): LoDashImplicitWrapper<string>; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.forEachRight + */ + forEachRight( + iteratee: ListIterator<T, any> + ): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.forEachRight + */ + forEachRight<TValue>( + iteratee?: ListIterator<TValue, any>|DictionaryIterator<TValue, any> + ): LoDashImplicitObjectWrapper<T>; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.forEachRight + */ + forEachRight( + iteratee: ListIterator<string, any> + ): LoDashExplicitWrapper<string>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.forEachRight + */ + forEachRight( + iteratee: ListIterator<T, any> + ): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.forEachRight + */ + forEachRight<TValue>( + iteratee?: ListIterator<TValue, any>|DictionaryIterator<TValue, any> + ): LoDashExplicitObjectWrapper<T>; + } + + //_.groupBy + interface LoDashStatic { + /** + * Creates an object composed of keys generated from the results of running each element of collection through + * iteratee. The corresponding value of each key is an array of the elements responsible for generating the + * key. The iteratee is bound to thisArg and invoked with three arguments: + * (value, index|key, collection). + * + * If a property name is provided for iteratee the created _.property style callback returns the property + * value of the given element. + * + * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for + * elements that have a matching property value, else false. + * + * If an object is provided for iteratee the created _.matches style callback returns true for elements that + * have the properties of the given object, else false. + * + * @param collection The collection to iterate over. + * @param iteratee The function invoked per iteration. + * @param thisArg The this binding of iteratee. + * @return Returns the composed aggregate object. + */ + groupBy<T, TKey>( + collection: List<T>, + iteratee?: ListIterator<T, TKey> + ): Dictionary<T[]>; + + /** + * @see _.groupBy + */ + groupBy<T>( + collection: List<any>, + iteratee?: ListIterator<T, any> + ): Dictionary<T[]>; + + /** + * @see _.groupBy + */ + groupBy<T, TKey>( + collection: Dictionary<T>, + iteratee?: DictionaryIterator<T, TKey> + ): Dictionary<T[]>; + + /** + * @see _.groupBy + */ + groupBy<T>( + collection: Dictionary<any>, + iteratee?: DictionaryIterator<T, any> + ): Dictionary<T[]>; + + /** + * @see _.groupBy + */ + groupBy<T, TValue>( + collection: List<T>|Dictionary<T>, + iteratee?: string + ): Dictionary<T[]>; + + /** + * @see _.groupBy + */ + groupBy<T>( + collection: List<T>|Dictionary<T>, + iteratee?: string + ): Dictionary<T[]>; + + /** + * @see _.groupBy + */ + groupBy<TWhere, T>( + collection: List<T>|Dictionary<T>, + iteratee?: TWhere + ): Dictionary<T[]>; + + /** + * @see _.groupBy + */ + groupBy<T>( + collection: List<T>|Dictionary<T>, + iteratee?: Object + ): Dictionary<T[]>; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.groupBy + */ + groupBy<TKey>( + iteratee?: ListIterator<T, TKey> + ): LoDashImplicitObjectWrapper<Dictionary<T[]>>; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.groupBy + */ + groupBy<TKey>( + iteratee?: ListIterator<T, TKey> + ): LoDashImplicitObjectWrapper<Dictionary<T[]>>; + + /** + * @see _.groupBy + */ + groupBy<TValue>( + iteratee?: string + ): LoDashImplicitObjectWrapper<Dictionary<T[]>>; + + /** + * @see _.groupBy + */ + groupBy<TWhere>( + iteratee?: TWhere + ): LoDashImplicitObjectWrapper<Dictionary<T[]>>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.groupBy + */ + groupBy<T, TKey>( + iteratee?: ListIterator<T, TKey>|DictionaryIterator<T, TKey> + ): LoDashImplicitObjectWrapper<Dictionary<T[]>>; + + /** + * @see _.groupBy + */ + groupBy<T>( + iteratee?: ListIterator<T, any>|DictionaryIterator<T, any> + ): LoDashImplicitObjectWrapper<Dictionary<T[]>>; + + /** + * @see _.groupBy + */ + groupBy<T, TValue>( + iteratee?: string + ): LoDashImplicitObjectWrapper<Dictionary<T[]>>; + + /** + * @see _.groupBy + */ + groupBy<T>( + iteratee?: string + ): LoDashImplicitObjectWrapper<Dictionary<T[]>>; + + /** + * @see _.groupBy + */ + groupBy<TWhere, T>( + iteratee?: TWhere + ): LoDashImplicitObjectWrapper<Dictionary<T[]>>; + + /** + * @see _.groupBy + */ + groupBy<T>( + iteratee?: Object + ): LoDashImplicitObjectWrapper<Dictionary<T[]>>; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.groupBy + */ + groupBy<TKey>( + iteratee?: ListIterator<T, TKey> + ): LoDashExplicitObjectWrapper<Dictionary<T[]>>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.groupBy + */ + groupBy<TKey>( + iteratee?: ListIterator<T, TKey> + ): LoDashExplicitObjectWrapper<Dictionary<T[]>>; + + /** + * @see _.groupBy + */ + groupBy<TValue>( + iteratee?: string + ): LoDashExplicitObjectWrapper<Dictionary<T[]>>; + + /** + * @see _.groupBy + */ + groupBy<TWhere>( + iteratee?: TWhere + ): LoDashExplicitObjectWrapper<Dictionary<T[]>>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.groupBy + */ + groupBy<T, TKey>( + iteratee?: ListIterator<T, TKey>|DictionaryIterator<T, TKey> + ): LoDashExplicitObjectWrapper<Dictionary<T[]>>; + + /** + * @see _.groupBy + */ + groupBy<T>( + iteratee?: ListIterator<T, any>|DictionaryIterator<T, any> + ): LoDashExplicitObjectWrapper<Dictionary<T[]>>; + + /** + * @see _.groupBy + */ + groupBy<T, TValue>( + iteratee?: string + ): LoDashExplicitObjectWrapper<Dictionary<T[]>>; + + /** + * @see _.groupBy + */ + groupBy<T>( + iteratee?: string + ): LoDashExplicitObjectWrapper<Dictionary<T[]>>; + + /** + * @see _.groupBy + */ + groupBy<TWhere, T>( + iteratee?: TWhere + ): LoDashExplicitObjectWrapper<Dictionary<T[]>>; + + /** + * @see _.groupBy + */ + groupBy<T>( + iteratee?: Object + ): LoDashExplicitObjectWrapper<Dictionary<T[]>>; + } + + //_.includes + interface LoDashStatic { + /** + * Checks if target is in collection using SameValueZero for equality comparisons. If fromIndex is negative, + * it’s used as the offset from the end of collection. + * + * @param collection The collection to search. + * @param target The value to search for. + * @param fromIndex The index to search from. + * @return True if the target element is found, else false. + */ + includes<T>( + collection: List<T>|Dictionary<T>, + target: T, + fromIndex?: number + ): boolean; + + /** + * @see _.includes + */ + includes( + collection: string, + target: string, + fromIndex?: number + ): boolean; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.includes + */ + includes( + target: T, + fromIndex?: number + ): boolean; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.includes + */ + includes<TValue>( + target: TValue, + fromIndex?: number + ): boolean; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.includes + */ + includes( + target: string, + fromIndex?: number + ): boolean; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.includes + */ + includes( + target: T, + fromIndex?: number + ): LoDashExplicitWrapper<boolean>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.includes + */ + includes<TValue>( + target: TValue, + fromIndex?: number + ): LoDashExplicitWrapper<boolean>; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.includes + */ + includes( + target: string, + fromIndex?: number + ): LoDashExplicitWrapper<boolean>; + } + + //_.keyBy + interface LoDashStatic { + /** + * Creates an object composed of keys generated from the results of running each element of collection through + * iteratee. The corresponding value of each key is the last element responsible for generating the key. The + * iteratee function is bound to thisArg and invoked with three arguments: + * (value, index|key, collection). + * + * If a property name is provided for iteratee the created _.property style callback returns the property + * value of the given element. + * + * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for + * elements that have a matching property value, else false. + * + * If an object is provided for iteratee the created _.matches style callback returns true for elements that + * have the properties of the given object, else false. + * + * @param collection The collection to iterate over. + * @param iteratee The function invoked per iteration. + * @param thisArg The this binding of iteratee. + * @return Returns the composed aggregate object. + */ + keyBy<T>( + collection: List<T>, + iteratee?: ListIterator<T, any> + ): Dictionary<T>; + + /** + * @see _.keyBy + */ + keyBy<T>( + collection: NumericDictionary<T>, + iteratee?: NumericDictionaryIterator<T, any> + ): Dictionary<T>; + + /** + * @see _.keyBy + */ + keyBy<T>( + collection: Dictionary<T>, + iteratee?: DictionaryIterator<T, any> + ): Dictionary<T>; + + /** + * @see _.keyBy + */ + keyBy<T>( + collection: List<T>|NumericDictionary<T>|Dictionary<T>, + iteratee?: string + ): Dictionary<T>; + + /** + * @see _.keyBy + */ + keyBy<W extends Object, T>( + collection: List<T>|NumericDictionary<T>|Dictionary<T>, + iteratee?: W + ): Dictionary<T>; + + /** + * @see _.keyBy + */ + keyBy<T>( + collection: List<T>|NumericDictionary<T>|Dictionary<T>, + iteratee?: Object + ): Dictionary<T>; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.keyBy + */ + keyBy( + iteratee?: ListIterator<T, any> + ): LoDashImplicitObjectWrapper<Dictionary<T>>; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.keyBy + */ + keyBy( + iteratee?: ListIterator<T, any> + ): LoDashImplicitObjectWrapper<Dictionary<T>>; + + /** + * @see _.keyBy + */ + keyBy( + iteratee?: string + ): LoDashImplicitObjectWrapper<Dictionary<T>>; + + /** + * @see _.keyBy + */ + keyBy<W extends Object>( + iteratee?: W + ): LoDashImplicitObjectWrapper<Dictionary<T>>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.keyBy + */ + keyBy<T>( + iteratee?: ListIterator<T, any>|NumericDictionaryIterator<T, any>|DictionaryIterator<T, any> + ): LoDashImplicitObjectWrapper<Dictionary<T>>; + + /** + * @see _.keyBy + */ + keyBy<T>( + iteratee?: string + ): LoDashImplicitObjectWrapper<Dictionary<T>>; + + /** + * @see _.keyBy + */ + keyBy<W extends Object, T>( + iteratee?: W + ): LoDashImplicitObjectWrapper<Dictionary<T>>; + + /** + * @see _.keyBy + */ + keyBy<T>( + iteratee?: Object + ): LoDashImplicitObjectWrapper<Dictionary<T>>; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.keyBy + */ + keyBy( + iteratee?: ListIterator<T, any> + ): LoDashExplicitObjectWrapper<Dictionary<T>>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.keyBy + */ + keyBy( + iteratee?: ListIterator<T, any> + ): LoDashExplicitObjectWrapper<Dictionary<T>>; + + /** + * @see _.keyBy + */ + keyBy( + iteratee?: string + ): LoDashExplicitObjectWrapper<Dictionary<T>>; + + /** + * @see _.keyBy + */ + keyBy<W extends Object>( + iteratee?: W + ): LoDashExplicitObjectWrapper<Dictionary<T>>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.keyBy + */ + keyBy<T>( + iteratee?: ListIterator<T, any>|NumericDictionaryIterator<T, any>|DictionaryIterator<T, any> + ): LoDashExplicitObjectWrapper<Dictionary<T>>; + + /** + * @see _.keyBy + */ + keyBy<T>( + iteratee?: string + ): LoDashExplicitObjectWrapper<Dictionary<T>>; + + /** + * @see _.keyBy + */ + keyBy<W extends Object, T>( + iteratee?: W + ): LoDashExplicitObjectWrapper<Dictionary<T>>; + + /** + * @see _.keyBy + */ + keyBy<T>( + iteratee?: Object + ): LoDashExplicitObjectWrapper<Dictionary<T>>; + } + + //_.invoke + interface LoDashStatic { + /** + * Invokes the method at path of object. + * @param object The object to query. + * @param path The path of the method to invoke. + * @param args The arguments to invoke the method with. + **/ + invoke<TObject extends Object, TResult>( + object: TObject, + path: StringRepresentable|StringRepresentable[], + ...args: any[]): TResult; + + /** + * @see _.invoke + **/ + invoke<TValue, TResult>( + object: Dictionary<TValue>|TValue[], + path: StringRepresentable|StringRepresentable[], + ...args: any[]): TResult; + + /** + * @see _.invoke + **/ + invoke<TResult>( + object: any, + path: StringRepresentable|StringRepresentable[], + ...args: any[]): TResult; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.invoke + **/ + invoke<TResult>( + path: StringRepresentable|StringRepresentable[], + ...args: any[]): TResult; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.invoke + **/ + invoke<TResult>( + path: StringRepresentable|StringRepresentable[], + ...args: any[]): TResult; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.invoke + **/ + invoke<TResult>( + path: StringRepresentable|StringRepresentable[], + ...args: any[]): TResult; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.invoke + **/ + invoke<TResult>( + path: StringRepresentable|StringRepresentable[], + ...args: any[]): TResult; + } + + //_.invokeMap + interface LoDashStatic { + /** + * Invokes the method named by methodName on each element in the collection returning + * an array of the results of each invoked method. Additional arguments will be provided + * to each invoked method. If methodName is a function it will be invoked for, and this + * bound to, each element in the collection. + * @param collection The collection to iterate over. + * @param methodName The name of the method to invoke. + * @param args Arguments to invoke the method with. + **/ + invokeMap<TValue extends {}, TResult>( + collection: TValue[], + methodName: string, + ...args: any[]): TResult[]; + + /** + * @see _.invokeMap + **/ + invokeMap<TValue extends {}, TResult>( + collection: Dictionary<TValue>, + methodName: string, + ...args: any[]): TResult[]; + + /** + * @see _.invokeMap + **/ + invokeMap<TResult>( + collection: {}[], + methodName: string, + ...args: any[]): TResult[]; + + /** + * @see _.invokeMap + **/ + invokeMap<TResult>( + collection: Dictionary<{}>, + methodName: string, + ...args: any[]): TResult[]; + + /** + * @see _.invokeMap + **/ + invokeMap<TValue extends {}, TResult>( + collection: TValue[], + method: (...args: any[]) => TResult, + ...args: any[]): TResult[]; + + /** + * @see _.invokeMap + **/ + invokeMap<TValue extends {}, TResult>( + collection: Dictionary<TValue>, + method: (...args: any[]) => TResult, + ...args: any[]): TResult[]; + + /** + * @see _.invokeMap + **/ + invokeMap<TResult>( + collection: {}[], + method: (...args: any[]) => TResult, + ...args: any[]): TResult[]; + + /** + * @see _.invokeMap + **/ + invokeMap<TResult>( + collection: Dictionary<{}>, + method: (...args: any[]) => TResult, + ...args: any[]): TResult[]; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.invokeMap + **/ + invokeMap<TResult>( + methodName: string, + ...args: any[]): LoDashImplicitArrayWrapper<TResult>; + + /** + * @see _.invokeMap + **/ + invokeMap<TResult>( + method: (...args: any[]) => TResult, + ...args: any[]): LoDashImplicitArrayWrapper<TResult>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.invokeMap + **/ + invokeMap<TResult>( + methodName: string, + ...args: any[]): LoDashImplicitArrayWrapper<TResult>; + + /** + * @see _.invokeMap + **/ + invokeMap<TResult>( + method: (...args: any[]) => TResult, + ...args: any[]): LoDashImplicitArrayWrapper<TResult>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.invokeMap + **/ + invokeMap<TResult>( + methodName: string, + ...args: any[]): LoDashExplicitArrayWrapper<TResult>; + + /** + * @see _.invokeMap + **/ + invokeMap<TResult>( + method: (...args: any[]) => TResult, + ...args: any[]): LoDashExplicitArrayWrapper<TResult>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.invokeMap + **/ + invokeMap<TResult>( + methodName: string, + ...args: any[]): LoDashExplicitArrayWrapper<TResult>; + + /** + * @see _.invokeMap + **/ + invokeMap<TResult>( + method: (...args: any[]) => TResult, + ...args: any[]): LoDashExplicitArrayWrapper<TResult>; + } + + //_.map + interface LoDashStatic { + /** + * Creates an array of values by running each element in collection through iteratee. The iteratee is bound to + * thisArg and invoked with three arguments: (value, index|key, collection). + * + * If a property name is provided for iteratee the created _.property style callback returns the property value + * of the given element. + * + * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for + * elements that have a matching property value, else false. + * + * If an object is provided for iteratee the created _.matches style callback returns true for elements that + * have the properties of the given object, else false. + * + * Many lodash methods are guarded to work as iteratees for methods like _.every, _.filter, _.map, _.mapValues, + * _.reject, and _.some. + * + * The guarded methods are: + * ary, callback, chunk, clone, create, curry, curryRight, drop, dropRight, every, fill, flatten, invert, max, + * min, parseInt, slice, sortBy, take, takeRight, template, trim, trimLeft, trimRight, trunc, random, range, + * sample, some, sum, uniq, and words + * + * @param collection The collection to iterate over. + * @param iteratee The function invoked per iteration. + * @param thisArg The this binding of iteratee. + * @return Returns the new mapped array. + */ + map<T, TResult>( + collection: List<T>, + iteratee?: ListIterator<T, TResult> + ): TResult[]; + + /** + * @see _.map + */ + map<T extends {}, TResult>( + collection: Dictionary<T>, + iteratee?: DictionaryIterator<T, TResult> + ): TResult[]; + + map<T extends {}, TResult>( + collection: NumericDictionary<T>, + iteratee?: NumericDictionaryIterator<T, TResult> + ): TResult[]; + + /** + * @see _.map + */ + map<T, TResult>( + collection: List<T>|Dictionary<T>|NumericDictionary<T>, + iteratee?: string + ): TResult[]; + + /** + * @see _.map + */ + map<T, TObject extends {}>( + collection: List<T>|Dictionary<T>|NumericDictionary<T>, + iteratee?: TObject + ): boolean[]; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.map + */ + map<TResult>( + iteratee?: ListIterator<T, TResult> + ): LoDashImplicitArrayWrapper<TResult>; + + /** + * @see _.map + */ + map<TResult>( + iteratee?: string + ): LoDashImplicitArrayWrapper<TResult>; + + /** + * @see _.map + */ + map<TObject extends {}>( + iteratee?: TObject + ): LoDashImplicitArrayWrapper<boolean>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.map + */ + map<TValue, TResult>( + iteratee?: ListIterator<TValue, TResult>|DictionaryIterator<TValue, TResult> + ): LoDashImplicitArrayWrapper<TResult>; + + /** + * @see _.map + */ + map<TValue, TResult>( + iteratee?: string + ): LoDashImplicitArrayWrapper<TResult>; + + /** + * @see _.map + */ + map<TObject extends {}>( + iteratee?: TObject + ): LoDashImplicitArrayWrapper<boolean>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.map + */ + map<TResult>( + iteratee?: ListIterator<T, TResult> + ): LoDashExplicitArrayWrapper<TResult>; + + /** + * @see _.map + */ + map<TResult>( + iteratee?: string + ): LoDashExplicitArrayWrapper<TResult>; + + /** + * @see _.map + */ + map<TObject extends {}>( + iteratee?: TObject + ): LoDashExplicitArrayWrapper<boolean>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.map + */ + map<TValue, TResult>( + iteratee?: ListIterator<TValue, TResult>|DictionaryIterator<TValue, TResult> + ): LoDashExplicitArrayWrapper<TResult>; + + /** + * @see _.map + */ + map<TValue, TResult>( + iteratee?: string + ): LoDashExplicitArrayWrapper<TResult>; + + /** + * @see _.map + */ + map<TObject extends {}>( + iteratee?: TObject + ): LoDashExplicitArrayWrapper<boolean>; + } + + //_.partition + interface LoDashStatic { + /** + * Creates an array of elements split into two groups, the first of which contains elements predicate returns truthy for, + * while the second of which contains elements predicate returns falsey for. + * The predicate is bound to thisArg and invoked with three arguments: (value, index|key, collection). + * + * If a property name is provided for predicate the created _.property style callback + * returns the property value of the given element. + * + * If a value is also provided for thisArg the created _.matchesProperty style callback + * returns true for elements that have a matching property value, else false. + * + * If an object is provided for predicate the created _.matches style callback returns + * true for elements that have the properties of the given object, else false. + * + * @param collection The collection to iterate over. + * @param callback The function called per iteration. + * @param thisArg The this binding of predicate. + * @return Returns the array of grouped elements. + **/ + partition<T>( + collection: List<T>, + callback: ListIterator<T, boolean>): T[][]; + + /** + * @see _.partition + **/ + partition<T>( + collection: Dictionary<T>, + callback: DictionaryIterator<T, boolean>): T[][]; + + /** + * @see _.partition + **/ + partition<W, T>( + collection: List<T>, + whereValue: W): T[][]; + + /** + * @see _.partition + **/ + partition<W, T>( + collection: Dictionary<T>, + whereValue: W): T[][]; + + /** + * @see _.partition + **/ + partition<T>( + collection: List<T>, + path: string, + srcValue: any): T[][]; + + /** + * @see _.partition + **/ + partition<T>( + collection: Dictionary<T>, + path: string, + srcValue: any): T[][]; + + /** + * @see _.partition + **/ + partition<T>( + collection: List<T>, + pluckValue: string): T[][]; + + /** + * @see _.partition + **/ + partition<T>( + collection: Dictionary<T>, + pluckValue: string): T[][]; + } + + interface LoDashImplicitStringWrapper { + /** + * @see _.partition + */ + partition( + callback: ListIterator<string, boolean>): LoDashImplicitArrayWrapper<string[]>; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.partition + */ + partition( + callback: ListIterator<T, boolean>): LoDashImplicitArrayWrapper<T[]>; + /** + * @see _.partition + */ + partition<W>( + whereValue: W): LoDashImplicitArrayWrapper<T[]>; + /** + * @see _.partition + */ + partition( + path: string, + srcValue: any): LoDashImplicitArrayWrapper<T[]>; + /** + * @see _.partition + */ + partition( + pluckValue: string): LoDashImplicitArrayWrapper<T[]>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.partition + */ + partition<TResult>( + callback: ListIterator<TResult, boolean>): LoDashImplicitArrayWrapper<TResult[]>; + + /** + * @see _.partition + */ + partition<TResult>( + callback: DictionaryIterator<TResult, boolean>): LoDashImplicitArrayWrapper<TResult[]>; + + /** + * @see _.partition + */ + partition<W, TResult>( + whereValue: W): LoDashImplicitArrayWrapper<TResult[]>; + + /** + * @see _.partition + */ + partition<TResult>( + path: string, + srcValue: any): LoDashImplicitArrayWrapper<TResult[]>; + + /** + * @see _.partition + */ + partition<TResult>( + pluckValue: string): LoDashImplicitArrayWrapper<TResult[]>; + } + + //_.reduce + interface LoDashStatic { + /** + * Reduces a collection to a value which is the accumulated result of running each + * element in the collection through the callback, where each successive callback execution + * consumes the return value of the previous execution. If accumulator is not provided the + * first element of the collection will be used as the initial accumulator value. The callback + * is bound to thisArg and invoked with four arguments; (accumulator, value, index|key, collection). + * @param collection The collection to iterate over. + * @param callback The function called per iteration. + * @param accumulator Initial value of the accumulator. + * @param thisArg The this binding of callback. + * @return Returns the accumulated value. + **/ + reduce<T, TResult>( + collection: Array<T>, + callback: MemoIterator<T, TResult>, + accumulator: TResult): TResult; + + /** + * @see _.reduce + **/ + reduce<T, TResult>( + collection: List<T>, + callback: MemoIterator<T, TResult>, + accumulator: TResult): TResult; + + /** + * @see _.reduce + **/ + reduce<T, TResult>( + collection: Dictionary<T>, + callback: MemoIterator<T, TResult>, + accumulator: TResult): TResult; + + /** + * @see _.reduce + **/ + reduce<T, TResult>( + collection: NumericDictionary<T>, + callback: MemoIterator<T, TResult>, + accumulator: TResult): TResult; + + /** + * @see _.reduce + **/ + reduce<T, TResult>( + collection: Array<T>, + callback: MemoIterator<T, TResult>): TResult; + + /** + * @see _.reduce + **/ + reduce<T, TResult>( + collection: List<T>, + callback: MemoIterator<T, TResult>): TResult; + + /** + * @see _.reduce + **/ + reduce<T, TResult>( + collection: Dictionary<T>, + callback: MemoIterator<T, TResult>): TResult; + + /** + * @see _.reduce + **/ + reduce<T, TResult>( + collection: NumericDictionary<T>, + callback: MemoIterator<T, TResult>): TResult; + + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.reduce + **/ + reduce<TResult>( + callback: MemoIterator<T, TResult>, + accumulator: TResult): TResult; + + /** + * @see _.reduce + **/ + reduce<TResult>( + callback: MemoIterator<T, TResult>): TResult; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.reduce + **/ + reduce<TValue, TResult>( + callback: MemoIterator<TValue, TResult>, + accumulator: TResult): TResult; + + /** + * @see _.reduce + **/ + reduce<TValue, TResult>( + callback: MemoIterator<TValue, TResult>): TResult; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.reduce + **/ + reduce<TValue, TResult>( + callback: MemoIterator<TValue, TResult>, + accumulator: TResult): LoDashExplicitObjectWrapper<TResult>; + + /** + * @see _.reduce + **/ + reduce<TValue, TResult>( + callback: MemoIterator<TValue, TResult>): LoDashExplicitObjectWrapper<TResult>; + } + + interface LoDashExplicitArrayWrapper<T> { + /**LoDashExplicitWrapper + * @see _.reduce + */ + reduce<TResult>( + callback: MemoIterator<T, TResult>, + accumulator: TResult): LoDashExplicitWrapper<TResult>; + + /** + * @see _.reduce + */ + reduce<TResult>( + callback: MemoIterator<T, TResult>): LoDashExplicitWrapper<TResult>; + } + + //_.reduceRight + interface LoDashStatic { + /** + * This method is like _.reduce except that it iterates over elements of a collection from + * right to left. + * @param collection The collection to iterate over. + * @param callback The function called per iteration. + * @param accumulator Initial value of the accumulator. + * @param thisArg The this binding of callback. + * @return The accumulated value. + **/ + reduceRight<T, TResult>( + collection: Array<T>, + callback: MemoIterator<T, TResult>, + accumulator: TResult): TResult; + + /** + * @see _.reduceRight + **/ + reduceRight<T, TResult>( + collection: List<T>, + callback: MemoIterator<T, TResult>, + accumulator: TResult): TResult; + + /** + * @see _.reduceRight + **/ + reduceRight<T, TResult>( + collection: Dictionary<T>, + callback: MemoIterator<T, TResult>, + accumulator: TResult): TResult; + + /** + * @see _.reduceRight + **/ + reduceRight<T, TResult>( + collection: Array<T>, + callback: MemoIterator<T, TResult>): TResult; + + /** + * @see _.reduceRight + **/ + reduceRight<T, TResult>( + collection: List<T>, + callback: MemoIterator<T, TResult>): TResult; + + /** + * @see _.reduceRight + **/ + reduceRight<T, TResult>( + collection: Dictionary<T>, + callback: MemoIterator<T, TResult>): TResult; + } + + //_.reject + interface LoDashStatic { + /** + * The opposite of _.filter; this method returns the elements of collection that predicate does not return + * truthy for. + * + * @param collection The collection to iterate over. + * @param predicate The function invoked per iteration. + * @param thisArg The this binding of predicate. + * @return Returns the new filtered array. + */ + reject<T>( + collection: List<T>, + predicate?: ListIterator<T, boolean> + ): T[]; + + /** + * @see _.reject + */ + reject<T>( + collection: Dictionary<T>, + predicate?: DictionaryIterator<T, boolean> + ): T[]; + + /** + * @see _.reject + */ + reject( + collection: string, + predicate?: StringIterator<boolean> + ): string[]; + + /** + * @see _.reject + */ + reject<T>( + collection: List<T>|Dictionary<T>, + predicate: string + ): T[]; + + /** + * @see _.reject + */ + reject<W extends {}, T>( + collection: List<T>|Dictionary<T>, + predicate: W + ): T[]; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.reject + */ + reject( + predicate?: StringIterator<boolean> + ): LoDashImplicitArrayWrapper<string>; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.reject + */ + reject( + predicate: ListIterator<T, boolean> + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.reject + */ + reject( + predicate: string + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.reject + */ + reject<W>(predicate: W): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.reject + */ + reject<T>( + predicate: ListIterator<T, boolean>|DictionaryIterator<T, boolean> + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.reject + */ + reject<T>( + predicate: string + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.reject + */ + reject<W, T>(predicate: W): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.reject + */ + reject( + predicate?: StringIterator<boolean> + ): LoDashExplicitArrayWrapper<string>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.reject + */ + reject( + predicate: ListIterator<T, boolean> + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.reject + */ + reject( + predicate: string + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.reject + */ + reject<W>(predicate: W): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.reject + */ + reject<T>( + predicate: ListIterator<T, boolean>|DictionaryIterator<T, boolean> + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.reject + */ + reject<T>( + predicate: string + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.reject + */ + reject<W, T>(predicate: W): LoDashExplicitArrayWrapper<T>; + } + + //_.sample + interface LoDashStatic { + /** + * Gets a random element from collection. + * + * @param collection The collection to sample. + * @return Returns the random element. + */ + sample<T>( + collection: List<T>|Dictionary<T>|NumericDictionary<T> + ): T; + + /** + * @see _.sample + */ + sample<O extends Object, T>( + collection: O + ): T; + + /** + * @see _.sample + */ + sample<T>( + collection: Object + ): T; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.sample + */ + sample(): string; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.sample + */ + sample(): T; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.sample + */ + sample<T>(): T; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.sample + */ + sample(): LoDashExplicitWrapper<string>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.sample + */ + sample<TWrapper>(): TWrapper; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.sample + */ + sample<TWrapper>(): TWrapper; + } + + //_.sampleSize + interface LoDashStatic { + /** + * Gets n random elements at unique keys from collection up to the size of collection. + * + * @param collection The collection to sample. + * @param n The number of elements to sample. + * @return Returns the random elements. + */ + sampleSize<T>( + collection: List<T>|Dictionary<T>|NumericDictionary<T>, + n?: number + ): T[]; + + /** + * @see _.sampleSize + */ + sampleSize<O extends Object, T>( + collection: O, + n?: number + ): T[]; + + /** + * @see _.sampleSize + */ + sampleSize<T>( + collection: Object, + n?: number + ): T[]; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.sampleSize + */ + sampleSize( + n?: number + ): LoDashImplicitArrayWrapper<string>; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.sampleSize + */ + sampleSize( + n?: number + ): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.sampleSize + */ + sampleSize<T>( + n?: number + ): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.sampleSize + */ + sampleSize( + n?: number + ): LoDashExplicitArrayWrapper<string>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.sampleSize + */ + sampleSize( + n?: number + ): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.sampleSize + */ + sampleSize<T>( + n?: number + ): LoDashExplicitArrayWrapper<T>; + } + + //_.shuffle + interface LoDashStatic { + /** + * Creates an array of shuffled values, using a version of the Fisher-Yates shuffle. + * + * @param collection The collection to shuffle. + * @return Returns the new shuffled array. + */ + shuffle<T>(collection: List<T>|Dictionary<T>): T[]; + + /** + * @see _.shuffle + */ + shuffle(collection: string): string[]; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.shuffle + */ + shuffle(): LoDashImplicitArrayWrapper<string>; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.shuffle + */ + shuffle(): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.shuffle + */ + shuffle<T>(): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.shuffle + */ + shuffle(): LoDashExplicitArrayWrapper<string>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.shuffle + */ + shuffle(): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.shuffle + */ + shuffle<T>(): LoDashExplicitArrayWrapper<T>; + } + + //_.size + interface LoDashStatic { + /** + * Gets the size of collection by returning its length for array-like values or the number of own enumerable + * properties for objects. + * + * @param collection The collection to inspect. + * @return Returns the size of collection. + */ + size<T>(collection: List<T>|Dictionary<T>): number; + + /** + * @see _.size + */ + size(collection: string): number; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.size + */ + size(): number; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.size + */ + size(): number; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.size + */ + size(): number; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.size + */ + size(): LoDashExplicitWrapper<number>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.size + */ + size(): LoDashExplicitWrapper<number>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.size + */ + size(): LoDashExplicitWrapper<number>; + } + + //_.some + interface LoDashStatic { + /** + * Checks if predicate returns truthy for any element of collection. Iteration is stopped once predicate + * returns truthy. The predicate is invoked with three arguments: (value, index|key, collection). + * + * @param collection The collection to iterate over. + * @param predicate The function invoked per iteration. + * @return Returns true if any element passes the predicate check, else false. + */ + some<T>( + collection: List<T>, + predicate?: ListIterator<T, boolean> + ): boolean; + + /** + * @see _.some + */ + some<T>( + collection: Dictionary<T>, + predicate?: DictionaryIterator<T, boolean> + ): boolean; + + /** + * @see _.some + */ + some<T>( + collection: NumericDictionary<T>, + predicate?: NumericDictionaryIterator<T, boolean> + ): boolean; + + /** + * @see _.some + */ + some( + collection: Object, + predicate?: ObjectIterator<any, boolean> + ): boolean; + + /** + * @see _.some + */ + some<T>( + collection: List<T>|Dictionary<T>|NumericDictionary<T>, + predicate?: string|[string, any] + ): boolean; + + + /** + * @see _.some + */ + some( + collection: Object, + predicate?: string|[string, any] + ): boolean; + + /** + * @see _.some + */ + some<TObject extends {}, T>( + collection: List<T>|Dictionary<T>|NumericDictionary<T>, + predicate?: TObject + ): boolean; + + /** + * @see _.some + */ + some<T>( + collection: List<T>|Dictionary<T>|NumericDictionary<T>, + predicate?: Object + ): boolean; + + /** + * @see _.some + */ + some<TObject extends {}>( + collection: Object, + predicate?: TObject + ): boolean; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.some + */ + some( + predicate?: ListIterator<T, boolean>|NumericDictionaryIterator<T, boolean> + ): boolean; + + /** + * @see _.some + */ + some( + predicate?: string|[string, any] + ): boolean; + + /** + * @see _.some + */ + some<TObject extends {}>( + predicate?: TObject + ): boolean; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.some + */ + some<TResult>( + predicate?: ListIterator<TResult, boolean>|DictionaryIterator<TResult, boolean>|NumericDictionaryIterator<T, boolean>|ObjectIterator<any, boolean> + ): boolean; + + /** + * @see _.some + */ + some( + predicate?: string|[string, any] + ): boolean; + + /** + * @see _.some + */ + some<TObject extends {}>( + predicate?: TObject + ): boolean; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.some + */ + some( + predicate?: ListIterator<T, boolean>|NumericDictionaryIterator<T, boolean> + ): LoDashExplicitWrapper<boolean>; + + /** + * @see _.some + */ + some( + predicate?: string|[string, any] + ): LoDashExplicitWrapper<boolean>; + + /** + * @see _.some + */ + some<TObject extends {}>( + predicate?: TObject + ): LoDashExplicitWrapper<boolean>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.some + */ + some<TResult>( + predicate?: ListIterator<TResult, boolean>|DictionaryIterator<TResult, boolean>|NumericDictionaryIterator<T, boolean>|ObjectIterator<any, boolean> + ): LoDashExplicitWrapper<boolean>; + + /** + * @see _.some + */ + some( + predicate?: string|[string, any] + ): LoDashExplicitWrapper<boolean>; + + /** + * @see _.some + */ + some<TObject extends {}>( + predicate?: TObject + ): LoDashExplicitWrapper<boolean>; + } + + //_.sortBy + interface LoDashStatic { + /** + * Creates an array of elements, sorted in ascending order by the results of + * running each element in a collection through each iteratee. This method + * performs a stable sort, that is, it preserves the original sort order of + * equal elements. The iteratees are invoked with one argument: (value). + * + * @static + * @memberOf _ + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {...(Function|Function[]|Object|Object[]|string|string[])} [iteratees=[_.identity]] + * The iteratees to sort by, specified individually or in arrays. + * @returns {Array} Returns the new sorted array. + * @example + * + * var users = [ + * { 'user': 'fred', 'age': 48 }, + * { 'user': 'barney', 'age': 36 }, + * { 'user': 'fred', 'age': 42 }, + * { 'user': 'barney', 'age': 34 } + * ]; + * + * _.sortBy(users, function(o) { return o.user; }); + * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 42]] + * + * _.sortBy(users, ['user', 'age']); + * // => objects for [['barney', 34], ['barney', 36], ['fred', 42], ['fred', 48]] + * + * _.sortBy(users, 'user', function(o) { + * return Math.floor(o.age / 10); + * }); + * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 42]] + */ + sortBy<T, TSort>( + collection: List<T>, + iteratee?: ListIterator<T, TSort> + ): T[]; + + /** + * @see _.sortBy + */ + sortBy<T, TSort>( + collection: Dictionary<T>, + iteratee?: DictionaryIterator<T, TSort> + ): T[]; + + /** + * @see _.sortBy + */ + sortBy<T>( + collection: List<T>|Dictionary<T>, + iteratee: string + ): T[]; + + /** + * @see _.sortBy + */ + sortBy<W extends {}, T>( + collection: List<T>|Dictionary<T>, + whereValue: W + ): T[]; + + /** + * @see _.sortBy + */ + sortBy<T>( + collection: List<T>|Dictionary<T> + ): T[]; + + /** + * @see _.sortBy + */ + sortBy<T>( + collection: (Array<T>|List<T>), + iteratees: (ListIterator<T, any>|string|Object)[]): T[]; + + /** + * @see _.sortBy + */ + sortBy<T>( + collection: (Array<T>|List<T>), + ...iteratees: (ListIterator<T, boolean>|Object|string)[]): T[]; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.sortBy + */ + sortBy<TSort>( + iteratee?: ListIterator<T, TSort> + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.sortBy + */ + sortBy(iteratee: string): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.sortBy + */ + sortBy<W extends {}>(whereValue: W): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.sortBy + */ + sortBy(): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.sortBy + */ + sortBy(...iteratees: (ListIterator<T, boolean>|Object|string)[]): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.sortBy + **/ + sortBy(iteratees: (ListIterator<T, any>|string|Object)[]): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.sortBy + */ + sortBy<T, TSort>( + iteratee?: ListIterator<T, TSort>|DictionaryIterator<T, TSort> + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.sortBy + */ + sortBy<T>(iteratee: string): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.sortBy + */ + sortBy<W extends {}, T>(whereValue: W): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.sortBy + */ + sortBy<T>(): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.sortBy + */ + sortBy<TSort>( + iteratee?: ListIterator<T, TSort> + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.sortBy + */ + sortBy(iteratee: string): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.sortBy + */ + sortBy<W extends {}>(whereValue: W): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.sortBy + */ + sortBy(): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.sortBy + */ + sortBy<T, TSort>( + iteratee?: ListIterator<T, TSort>|DictionaryIterator<T, TSort> + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.sortBy + */ + sortBy<T>(iteratee: string): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.sortBy + */ + sortBy<W extends {}, T>(whereValue: W): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.sortBy + */ + sortBy<T>(): LoDashExplicitArrayWrapper<T>; + } + + //_.orderBy + interface LoDashStatic { + /** + * This method is like `_.sortBy` except that it allows specifying the sort + * orders of the iteratees to sort by. If `orders` is unspecified, all values + * are sorted in ascending order. Otherwise, specify an order of "desc" for + * descending or "asc" for ascending sort order of corresponding values. + * + * @static + * @memberOf _ + * @category Collection + * @param {Array|Object} collection The collection to iterate over. + * @param {Function[]|Object[]|string[]} [iteratees=[_.identity]] The iteratees to sort by. + * @param {string[]} [orders] The sort orders of `iteratees`. + * @param- {Object} [guard] Enables use as an iteratee for functions like `_.reduce`. + * @returns {Array} Returns the new sorted array. + * @example + * + * var users = [ + * { 'user': 'fred', 'age': 48 }, + * { 'user': 'barney', 'age': 34 }, + * { 'user': 'fred', 'age': 42 }, + * { 'user': 'barney', 'age': 36 } + * ]; + * + * // sort by `user` in ascending order and by `age` in descending order + * _.orderBy(users, ['user', 'age'], ['asc', 'desc']); + * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 42]] + */ + orderBy<W extends Object, T>( + collection: List<T>, + iteratees: ListIterator<T, any>|string|W|(ListIterator<T, any>|string|W)[], + orders?: boolean|string|(boolean|string)[] + ): T[]; + + /** + * @see _.orderBy + */ + orderBy<T>( + collection: List<T>, + iteratees: ListIterator<T, any>|string|Object|(ListIterator<T, any>|string|Object)[], + orders?: boolean|string|(boolean|string)[] + ): T[]; + + /** + * @see _.orderBy + */ + orderBy<W extends Object, T>( + collection: NumericDictionary<T>, + iteratees: NumericDictionaryIterator<T, any>|string|W|(NumericDictionaryIterator<T, any>|string|W)[], + orders?: boolean|string|(boolean|string)[] + ): T[]; + + /** + * @see _.orderBy + */ + orderBy<T>( + collection: NumericDictionary<T>, + iteratees: NumericDictionaryIterator<T, any>|string|Object|(NumericDictionaryIterator<T, any>|string|Object)[], + orders?: boolean|string|(boolean|string)[] + ): T[]; + + /** + * @see _.orderBy + */ + orderBy<W extends Object, T>( + collection: Dictionary<T>, + iteratees: DictionaryIterator<T, any>|string|W|(DictionaryIterator<T, any>|string|W)[], + orders?: boolean|string|(boolean|string)[] + ): T[]; + + /** + * @see _.orderBy + */ + orderBy<T>( + collection: Dictionary<T>, + iteratees: DictionaryIterator<T, any>|string|Object|(DictionaryIterator<T, any>|string|Object)[], + orders?: boolean|string|(boolean|string)[] + ): T[]; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.orderBy + */ + orderBy( + iteratees: ListIterator<T, any>|string|(ListIterator<T, any>|string)[], + orders?: boolean|string|(boolean|string)[] + ): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.orderBy + */ + orderBy<W extends Object>( + iteratees: ListIterator<T, any>|string|W|(ListIterator<T, any>|string|W)[], + orders?: boolean|string|(boolean|string)[] + ): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.orderBy + */ + orderBy<W extends Object, T>( + iteratees: ListIterator<T, any>|string|W|(ListIterator<T, any>|string|W)[], + orders?: boolean|string|(boolean|string)[] + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.orderBy + */ + orderBy<T>( + iteratees: ListIterator<T, any>|string|Object|(ListIterator<T, any>|string|Object)[], + orders?: boolean|string|(boolean|string)[] + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.orderBy + */ + orderBy<W extends Object, T>( + iteratees: NumericDictionaryIterator<T, any>|string|W|(NumericDictionaryIterator<T, any>|string|W)[], + orders?: boolean|string|(boolean|string)[] + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.orderBy + */ + orderBy<T>( + iteratees: NumericDictionaryIterator<T, any>|string|Object|(NumericDictionaryIterator<T, any>|string|Object)[], + orders?: boolean|string|(boolean|string)[] + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.orderBy + */ + orderBy<W extends Object, T>( + iteratees: DictionaryIterator<T, any>|string|W|(DictionaryIterator<T, any>|string|W)[], + orders?: boolean|string|(boolean|string)[] + ): LoDashImplicitArrayWrapper<T>; + + /** + * @see _.orderBy + */ + orderBy<T>( + iteratees: DictionaryIterator<T, any>|string|Object|(DictionaryIterator<T, any>|string|Object)[], + orders?: boolean|string|(boolean|string)[] + ): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.orderBy + */ + orderBy( + iteratees: ListIterator<T, any>|string|(ListIterator<T, any>|string)[], + orders?: boolean|string|(boolean|string)[] + ): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.orderBy + */ + orderBy<W extends Object>( + iteratees: ListIterator<T, any>|string|W|(ListIterator<T, any>|string|W)[], + orders?: boolean|string|(boolean|string)[] + ): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.orderBy + */ + orderBy<W extends Object, T>( + iteratees: ListIterator<T, any>|string|W|(ListIterator<T, any>|string|W)[], + orders?: boolean|string|(boolean|string)[] + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.orderBy + */ + orderBy<T>( + iteratees: ListIterator<T, any>|string|Object|(ListIterator<T, any>|string|Object)[], + orders?: boolean|string|(boolean|string)[] + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.orderBy + */ + orderBy<W extends Object, T>( + iteratees: NumericDictionaryIterator<T, any>|string|W|(NumericDictionaryIterator<T, any>|string|W)[], + orders?: boolean|string|(boolean|string)[] + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.orderBy + */ + orderBy<T>( + iteratees: NumericDictionaryIterator<T, any>|string|Object|(NumericDictionaryIterator<T, any>|string|Object)[], + orders?: boolean|string|(boolean|string)[] + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.orderBy + */ + orderBy<W extends Object, T>( + iteratees: DictionaryIterator<T, any>|string|W|(DictionaryIterator<T, any>|string|W)[], + orders?: boolean|string|(boolean|string)[] + ): LoDashExplicitArrayWrapper<T>; + + /** + * @see _.orderBy + */ + orderBy<T>( + iteratees: DictionaryIterator<T, any>|string|Object|(DictionaryIterator<T, any>|string|Object)[], + orders?: boolean|string|(boolean|string)[] + ): LoDashExplicitArrayWrapper<T>; + } + + /******** + * Date * + ********/ + + //_.now + interface LoDashStatic { + /** + * Gets the number of milliseconds that have elapsed since the Unix epoch (1 January 1970 00:00:00 UTC). + * + * @return The number of milliseconds. + */ + now(): number; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.now + */ + now(): number; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.now + */ + now(): LoDashExplicitWrapper<number>; + } + + /************* + * Functions * + *************/ + + //_.after + interface LoDashStatic { + /** + * The opposite of _.before; this method creates a function that invokes func once it’s called n or more times. + * + * @param n The number of calls before func is invoked. + * @param func The function to restrict. + * @return Returns the new restricted function. + */ + after<TFunc extends Function>( + n: number, + func: TFunc + ): TFunc; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.after + **/ + after<TFunc extends Function>(func: TFunc): LoDashImplicitObjectWrapper<TFunc>; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.after + **/ + after<TFunc extends Function>(func: TFunc): LoDashExplicitObjectWrapper<TFunc>; + } + + //_.ary + interface LoDashStatic { + /** + * Creates a function that accepts up to n arguments ignoring any additional arguments. + * + * @param func The function to cap arguments for. + * @param n The arity cap. + * @returns Returns the new function. + */ + ary<TResult extends Function>( + func: Function, + n?: number + ): TResult; + + ary<T extends Function, TResult extends Function>( + func: T, + n?: number + ): TResult; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.ary + */ + ary<TResult extends Function>(n?: number): LoDashImplicitObjectWrapper<TResult>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.ary + */ + ary<TResult extends Function>(n?: number): LoDashExplicitObjectWrapper<TResult>; + } + + //_.before + interface LoDashStatic { + /** + * Creates a function that invokes func, with the this binding and arguments of the created function, while + * it’s called less than n times. Subsequent calls to the created function return the result of the last func + * invocation. + * + * @param n The number of calls at which func is no longer invoked. + * @param func The function to restrict. + * @return Returns the new restricted function. + */ + before<TFunc extends Function>( + n: number, + func: TFunc + ): TFunc; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.before + **/ + before<TFunc extends Function>(func: TFunc): LoDashImplicitObjectWrapper<TFunc>; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.before + **/ + before<TFunc extends Function>(func: TFunc): LoDashExplicitObjectWrapper<TFunc>; + } + + //_.bind + interface FunctionBind { + placeholder: any; + + <T extends Function, TResult extends Function>( + func: T, + thisArg: any, + ...partials: any[] + ): TResult; + + <TResult extends Function>( + func: Function, + thisArg: any, + ...partials: any[] + ): TResult; + } + + interface LoDashStatic { + /** + * Creates a function that invokes func with the this binding of thisArg and prepends any additional _.bind + * arguments to those provided to the bound function. + * + * The _.bind.placeholder value, which defaults to _ in monolithic builds, may be used as a placeholder for + * partially applied arguments. + * + * Note: Unlike native Function#bind this method does not set the "length" property of bound functions. + * + * @param func The function to bind. + * @param thisArg The this binding of func. + * @param partials The arguments to be partially applied. + * @return Returns the new bound function. + */ + bind: FunctionBind; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.bind + */ + bind<TResult extends Function>( + thisArg: any, + ...partials: any[] + ): LoDashImplicitObjectWrapper<TResult>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.bind + */ + bind<TResult extends Function>( + thisArg: any, + ...partials: any[] + ): LoDashExplicitObjectWrapper<TResult>; + } + + //_.bindAll + interface LoDashStatic { + /** + * Binds methods of an object to the object itself, overwriting the existing method. Method names may be + * specified as individual arguments or as arrays of method names. If no method names are provided all + * enumerable function properties, own and inherited, of object are bound. + * + * Note: This method does not set the "length" property of bound functions. + * + * @param object The object to bind and assign the bound methods to. + * @param methodNames The object method names to bind, specified as individual method names or arrays of + * method names. + * @return Returns object. + */ + bindAll<T>( + object: T, + ...methodNames: (string|string[])[] + ): T; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.bindAll + */ + bindAll(...methodNames: (string|string[])[]): LoDashImplicitObjectWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.bindAll + */ + bindAll(...methodNames: (string|string[])[]): LoDashExplicitObjectWrapper<T>; + } + + //_.bindKey + interface FunctionBindKey { + placeholder: any; + + <T extends Object, TResult extends Function>( + object: T, + key: any, + ...partials: any[] + ): TResult; + + <TResult extends Function>( + object: Object, + key: any, + ...partials: any[] + ): TResult; + } + + interface LoDashStatic { + /** + * Creates a function that invokes the method at object[key] and prepends any additional _.bindKey arguments + * to those provided to the bound function. + * + * This method differs from _.bind by allowing bound functions to reference methods that may be redefined + * or don’t yet exist. See Peter Michaux’s article for more details. + * + * The _.bindKey.placeholder value, which defaults to _ in monolithic builds, may be used as a placeholder + * for partially applied arguments. + * + * @param object The object the method belongs to. + * @param key The key of the method. + * @param partials The arguments to be partially applied. + * @return Returns the new bound function. + */ + bindKey: FunctionBindKey; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.bindKey + */ + bindKey<TResult extends Function>( + key: any, + ...partials: any[] + ): LoDashImplicitObjectWrapper<TResult>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.bindKey + */ + bindKey<TResult extends Function>( + key: any, + ...partials: any[] + ): LoDashExplicitObjectWrapper<TResult>; + } + + //_.createCallback + interface LoDashStatic { + /** + * Produces a callback bound to an optional thisArg. If func is a property name the created + * callback will return the property value for a given element. If func is an object the created + * callback will return true for elements that contain the equivalent object properties, + * otherwise it will return false. + * @param func The value to convert to a callback. + * @param thisArg The this binding of the created callback. + * @param argCount The number of arguments the callback accepts. + * @return A callback function. + **/ + createCallback( + func: string, + argCount?: number): () => any; + + /** + * @see _.createCallback + **/ + createCallback( + func: Dictionary<any>, + argCount?: number): () => boolean; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.createCallback + **/ + createCallback( + argCount?: number): LoDashImplicitObjectWrapper<() => any>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.createCallback + **/ + createCallback( + argCount?: number): LoDashImplicitObjectWrapper<() => any>; + } + + //_.curry + interface LoDashStatic { + /** + * Creates a function that accepts one or more arguments of func that when called either invokes func returning + * its result, if all func arguments have been provided, or returns a function that accepts one or more of the + * remaining func arguments, and so on. The arity of func may be specified if func.length is not sufficient. + * @param func The function to curry. + * @return Returns the new curried function. + */ + curry<T1, R>(func: (t1: T1) => R): + CurriedFunction1<T1, R>; + /** + * Creates a function that accepts one or more arguments of func that when called either invokes func returning + * its result, if all func arguments have been provided, or returns a function that accepts one or more of the + * remaining func arguments, and so on. The arity of func may be specified if func.length is not sufficient. + * @param func The function to curry. + * @return Returns the new curried function. + */ + curry<T1, T2, R>(func: (t1: T1, t2: T2) => R): + CurriedFunction2<T1, T2, R>; + /** + * Creates a function that accepts one or more arguments of func that when called either invokes func returning + * its result, if all func arguments have been provided, or returns a function that accepts one or more of the + * remaining func arguments, and so on. The arity of func may be specified if func.length is not sufficient. + * @param func The function to curry. + * @return Returns the new curried function. + */ + curry<T1, T2, T3, R>(func: (t1: T1, t2: T2, t3: T3) => R): + CurriedFunction3<T1, T2, T3, R>; + /** + * Creates a function that accepts one or more arguments of func that when called either invokes func returning + * its result, if all func arguments have been provided, or returns a function that accepts one or more of the + * remaining func arguments, and so on. The arity of func may be specified if func.length is not sufficient. + * @param func The function to curry. + * @return Returns the new curried function. + */ + curry<T1, T2, T3, T4, R>(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R): + CurriedFunction4<T1, T2, T3, T4, R>; + /** + * Creates a function that accepts one or more arguments of func that when called either invokes func returning + * its result, if all func arguments have been provided, or returns a function that accepts one or more of the + * remaining func arguments, and so on. The arity of func may be specified if func.length is not sufficient. + * @param func The function to curry. + * @return Returns the new curried function. + */ + curry<T1, T2, T3, T4, T5, R>(func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R): + CurriedFunction5<T1, T2, T3, T4, T5, R>; + /** + * Creates a function that accepts one or more arguments of func that when called either invokes func returning + * its result, if all func arguments have been provided, or returns a function that accepts one or more of the + * remaining func arguments, and so on. The arity of func may be specified if func.length is not sufficient. + * @param func The function to curry. + * @param arity The arity of func. + * @return Returns the new curried function. + */ + curry<TResult extends Function>( + func: Function, + arity?: number): TResult; + } + + interface CurriedFunction1<T1, R> { + (): CurriedFunction1<T1, R>; + (t1: T1): R; + } + + interface CurriedFunction2<T1, T2, R> { + (): CurriedFunction2<T1, T2, R>; + (t1: T1): CurriedFunction1<T2, R>; + (t1: T1, t2: T2): R; + } + + interface CurriedFunction3<T1, T2, T3, R> { + (): CurriedFunction3<T1, T2, T3, R>; + (t1: T1): CurriedFunction2<T2, T3, R>; + (t1: T1, t2: T2): CurriedFunction1<T3, R>; + (t1: T1, t2: T2, t3: T3): R; + } + + interface CurriedFunction4<T1, T2, T3, T4, R> { + (): CurriedFunction4<T1, T2, T3, T4, R>; + (t1: T1): CurriedFunction3<T2, T3, T4, R>; + (t1: T1, t2: T2): CurriedFunction2<T3, T4, R>; + (t1: T1, t2: T2, t3: T3): CurriedFunction1<T4, R>; + (t1: T1, t2: T2, t3: T3, t4: T4): R; + } + + interface CurriedFunction5<T1, T2, T3, T4, T5, R> { + (): CurriedFunction5<T1, T2, T3, T4, T5, R>; + (t1: T1): CurriedFunction4<T2, T3, T4, T5, R>; + (t1: T1, t2: T2): CurriedFunction3<T3, T4, T5, R>; + (t1: T1, t2: T2, t3: T3): CurriedFunction2<T4, T5, R>; + (t1: T1, t2: T2, t3: T3, t4: T4): CurriedFunction1<T5, R>; + (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5): R; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.curry + **/ + curry<TResult extends Function>(arity?: number): LoDashImplicitObjectWrapper<TResult>; + } + + //_.curryRight + interface LoDashStatic { + /** + * This method is like _.curry except that arguments are applied to func in the manner of _.partialRight + * instead of _.partial. + * @param func The function to curry. + * @return Returns the new curried function. + */ + curryRight<T1, R>(func: (t1: T1) => R): + CurriedFunction1<T1, R>; + /** + * This method is like _.curry except that arguments are applied to func in the manner of _.partialRight + * instead of _.partial. + * @param func The function to curry. + * @return Returns the new curried function. + */ + curryRight<T1, T2, R>(func: (t1: T1, t2: T2) => R): + CurriedFunction2<T2, T1, R>; + /** + * This method is like _.curry except that arguments are applied to func in the manner of _.partialRight + * instead of _.partial. + * @param func The function to curry. + * @return Returns the new curried function. + */ + curryRight<T1, T2, T3, R>(func: (t1: T1, t2: T2, t3: T3) => R): + CurriedFunction3<T3, T2, T1, R>; + /** + * This method is like _.curry except that arguments are applied to func in the manner of _.partialRight + * instead of _.partial. + * @param func The function to curry. + * @return Returns the new curried function. + */ + curryRight<T1, T2, T3, T4, R>(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R): + CurriedFunction4<T4, T3, T2, T1, R>; + /** + * This method is like _.curry except that arguments are applied to func in the manner of _.partialRight + * instead of _.partial. + * @param func The function to curry. + * @return Returns the new curried function. + */ + curryRight<T1, T2, T3, T4, T5, R>(func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R): + CurriedFunction5<T5, T4, T3, T2, T1, R>; + /** + * This method is like _.curry except that arguments are applied to func in the manner of _.partialRight + * instead of _.partial. + * @param func The function to curry. + * @param arity The arity of func. + * @return Returns the new curried function. + */ + curryRight<TResult extends Function>( + func: Function, + arity?: number): TResult; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.curryRight + **/ + curryRight<TResult extends Function>(arity?: number): LoDashImplicitObjectWrapper<TResult>; + } + + //_.debounce + interface DebounceSettings { + /** + * Specify invoking on the leading edge of the timeout. + */ + leading?: boolean; + + /** + * The maximum time func is allowed to be delayed before it’s invoked. + */ + maxWait?: number; + + /** + * Specify invoking on the trailing edge of the timeout. + */ + trailing?: boolean; + } + + interface LoDashStatic { + /** + * Creates a debounced function that delays invoking func until after wait milliseconds have elapsed since + * the last time the debounced function was invoked. The debounced function comes with a cancel method to + * cancel delayed invocations and a flush method to immediately invoke them. Provide an options object to + * indicate that func should be invoked on the leading and/or trailing edge of the wait timeout. Subsequent + * calls to the debounced function return the result of the last func invocation. + * + * Note: If leading and trailing options are true, func is invoked on the trailing edge of the timeout only + * if the the debounced function is invoked more than once during the wait timeout. + * + * See David Corbacho’s article for details over the differences between _.debounce and _.throttle. + * + * @param func The function to debounce. + * @param wait The number of milliseconds to delay. + * @param options The options object. + * @param options.leading Specify invoking on the leading edge of the timeout. + * @param options.maxWait The maximum time func is allowed to be delayed before it’s invoked. + * @param options.trailing Specify invoking on the trailing edge of the timeout. + * @return Returns the new debounced function. + */ + debounce<T extends Function>( + func: T, + wait?: number, + options?: DebounceSettings + ): T & Cancelable; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.debounce + */ + debounce( + wait?: number, + options?: DebounceSettings + ): LoDashImplicitObjectWrapper<T & Cancelable>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.debounce + */ + debounce( + wait?: number, + options?: DebounceSettings + ): LoDashExplicitObjectWrapper<T & Cancelable>; + } + + //_.defer + interface LoDashStatic { + /** + * Defers invoking the func until the current call stack has cleared. Any additional arguments are provided to + * func when it’s invoked. + * + * @param func The function to defer. + * @param args The arguments to invoke the function with. + * @return Returns the timer id. + */ + defer<T extends Function>( + func: T, + ...args: any[] + ): number; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.defer + */ + defer(...args: any[]): LoDashImplicitWrapper<number>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.defer + */ + defer(...args: any[]): LoDashExplicitWrapper<number>; + } + + //_.delay + interface LoDashStatic { + /** + * Invokes func after wait milliseconds. Any additional arguments are provided to func when it’s invoked. + * + * @param func The function to delay. + * @param wait The number of milliseconds to delay invocation. + * @param args The arguments to invoke the function with. + * @return Returns the timer id. + */ + delay<T extends Function>( + func: T, + wait: number, + ...args: any[] + ): number; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.delay + */ + delay( + wait: number, + ...args: any[] + ): LoDashImplicitWrapper<number>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.delay + */ + delay( + wait: number, + ...args: any[] + ): LoDashExplicitWrapper<number>; + } + + interface LoDashStatic { + /** + * Creates a function that invokes `func` with arguments reversed. + * + * @static + * @memberOf _ + * @category Function + * @param {Function} func The function to flip arguments for. + * @returns {Function} Returns the new function. + * @example + * + * var flipped = _.flip(function() { + * return _.toArray(arguments); + * }); + * + * flipped('a', 'b', 'c', 'd'); + * // => ['d', 'c', 'b', 'a'] + */ + flip<T extends Function>(func: T): T; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.flip + */ + flip(): LoDashImplicitObjectWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.flip + */ + flip(): LoDashExplicitObjectWrapper<T>; + } + + //_.flow + interface LoDashStatic { + /** + * Creates a function that returns the result of invoking the provided functions with the this binding of the + * created function, where each successive invocation is supplied the return value of the previous. + * + * @param funcs Functions to invoke. + * @return Returns the new function. + */ + // 1-argument first function + flow<A1, R1, R2>(f1: (a1: A1) => R1, f2: (a: R1) => R2): (a1: A1) => R2; + flow<A1, R1, R2, R3>(f1: (a1: A1) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3): (a1: A1) => R3; + flow<A1, R1, R2, R3, R4>(f1: (a1: A1) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): (a1: A1) => R4; + flow<A1, R1, R2, R3, R4, R5>(f1: (a1: A1) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): (a1: A1) => R5; + flow<A1, R1, R2, R3, R4, R5, R6>(f1: (a1: A1) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): (a1: A1) => R6; + flow<A1, R1, R2, R3, R4, R5, R6, R7>(f1: (a1: A1) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): (a1: A1) => R7; + // 2-argument first function + flow<A1, A2, R1, R2>(f1: (a1: A1, a2: A2) => R1, f2: (a: R1) => R2): (a1: A1, a2: A2) => R2; + flow<A1, A2, R1, R2, R3>(f1: (a1: A1, a2: A2) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3): (a1: A1, a2: A2) => R3; + flow<A1, A2, R1, R2, R3, R4>(f1: (a1: A1, a2: A2) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): (a1: A1, a2: A2) => R4; + flow<A1, A2, R1, R2, R3, R4, R5>(f1: (a1: A1, a2: A2) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): (a1: A1, a2: A2) => R5; + flow<A1, A2, R1, R2, R3, R4, R5, R6>(f1: (a1: A1, a2: A2) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): (a1: A1, a2: A2) => R6; + flow<A1, A2, R1, R2, R3, R4, R5, R6, R7>(f1: (a1: A1, a2: A2) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): (a1: A1, a2: A2) => R7; + // 3-argument first function + flow<A1, A2, A3, R1, R2>(f1: (a1: A1, a2: A2, a3: A3) => R1, f2: (a: R1) => R2): (a1: A1, a2: A2, a3: A3) => R2; + flow<A1, A2, A3, R1, R2, R3>(f1: (a1: A1, a2: A2, a3: A3) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3): (a1: A1, a2: A2, a3: A3) => R3; + flow<A1, A2, A3, R1, R2, R3, R4>(f1: (a1: A1, a2: A2, a3: A3) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): (a1: A1, a2: A2, a3: A3) => R4; + flow<A1, A2, A3, R1, R2, R3, R4, R5>(f1: (a1: A1, a2: A2, a3: A3) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): (a1: A1, a2: A2, a3: A3) => R5; + flow<A1, A2, A3, R1, R2, R3, R4, R5, R6>(f1: (a1: A1, a2: A2, a3: A3) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): (a1: A1, a2: A2, a3: A3) => R6; + flow<A1, A2, A3, R1, R2, R3, R4, R5, R6, R7>(f1: (a1: A1, a2: A2, a3: A3) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): (a1: A1, a2: A2, a3: A3) => R7; + // 4-argument first function + flow<A1, A2, A3, A4, R1, R2>(f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1, f2: (a: R1) => R2): (a1: A1, a2: A2, a3: A3, a4: A4) => R2; + flow<A1, A2, A3, A4, R1, R2, R3>(f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3): (a1: A1, a2: A2, a3: A3, a4: A4) => R3; + flow<A1, A2, A3, A4, R1, R2, R3, R4>(f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): (a1: A1, a2: A2, a3: A3, a4: A4) => R4; + flow<A1, A2, A3, A4, R1, R2, R3, R4, R5>(f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): (a1: A1, a2: A2, a3: A3, a4: A4) => R5; + flow<A1, A2, A3, A4, R1, R2, R3, R4, R5, R6>(f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): (a1: A1, a2: A2, a3: A3, a4: A4) => R6; + flow<A1, A2, A3, A4, R1, R2, R3, R4, R5, R6, R7>(f1: (a1: A1, a2: A2, a3: A3, a4: A4) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): (a1: A1, a2: A2, a3: A3, a4: A4) => R7; + // generic function + flow<TResult extends Function>(...funcs: Function[]): TResult; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.flow + */ + flow<TResult extends Function>(...funcs: Function[]): LoDashImplicitObjectWrapper<TResult>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.flow + */ + flow<TResult extends Function>(...funcs: Function[]): LoDashExplicitObjectWrapper<TResult>; + } + + //_.flowRight + interface LoDashStatic { + /** + * This method is like _.flow except that it creates a function that invokes the provided functions from right + * to left. + * + * @param funcs Functions to invoke. + * @return Returns the new function. + */ + flowRight<TResult extends Function>(...funcs: Function[]): TResult; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.flowRight + */ + flowRight<TResult extends Function>(...funcs: Function[]): LoDashImplicitObjectWrapper<TResult>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.flowRight + */ + flowRight<TResult extends Function>(...funcs: Function[]): LoDashExplicitObjectWrapper<TResult>; + } + + + //_.memoize + interface MemoizedFunction extends Function { + cache: MapCache; + } + + interface LoDashStatic { + /** + * Creates a function that memoizes the result of func. If resolver is provided it determines the cache key for + * storing the result based on the arguments provided to the memoized function. By default, the first argument + * provided to the memoized function is coerced to a string and used as the cache key. The func is invoked with + * the this binding of the memoized function. + * + * @param func The function to have its output memoized. + * @param resolver The function to resolve the cache key. + * @return Returns the new memoizing function. + */ + memoize: { + <T extends Function>(func: T, resolver?: Function): T & MemoizedFunction; + Cache: MapCacheConstructor; + } + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.memoize + */ + memoize(resolver?: Function): LoDashImplicitObjectWrapper<T & MemoizedFunction>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.memoize + */ + memoize(resolver?: Function): LoDashExplicitObjectWrapper<T & MemoizedFunction>; + } + + //_.overArgs (was _.modArgs) + interface LoDashStatic { + /** + * Creates a function that runs each argument through a corresponding transform function. + * + * @param func The function to wrap. + * @param transforms The functions to transform arguments, specified as individual functions or arrays + * of functions. + * @return Returns the new function. + */ + overArgs<T extends Function, TResult extends Function>( + func: T, + ...transforms: Function[] + ): TResult; + + /** + * @see _.overArgs + */ + overArgs<T extends Function, TResult extends Function>( + func: T, + transforms: Function[] + ): TResult; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.overArgs + */ + overArgs<TResult extends Function>(...transforms: Function[]): LoDashImplicitObjectWrapper<TResult>; + + /** + * @see _.overArgs + */ + overArgs<TResult extends Function>(transforms: Function[]): LoDashImplicitObjectWrapper<TResult>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.overArgs + */ + overArgs<TResult extends Function>(...transforms: Function[]): LoDashExplicitObjectWrapper<TResult>; + + /** + * @see _.overArgs + */ + overArgs<TResult extends Function>(transforms: Function[]): LoDashExplicitObjectWrapper<TResult>; + } + + //_.negate + interface LoDashStatic { + /** + * Creates a function that negates the result of the predicate func. The func predicate is invoked with + * the this binding and arguments of the created function. + * + * @param predicate The predicate to negate. + * @return Returns the new function. + */ + negate<T extends Function>(predicate: T): (...args: any[]) => boolean; + + /** + * @see _.negate + */ + negate<T extends Function, TResult extends Function>(predicate: T): TResult; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.negate + */ + negate(): LoDashImplicitObjectWrapper<(...args: any[]) => boolean>; + + /** + * @see _.negate + */ + negate<TResult extends Function>(): LoDashImplicitObjectWrapper<TResult>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.negate + */ + negate(): LoDashExplicitObjectWrapper<(...args: any[]) => boolean>; + + /** + * @see _.negate + */ + negate<TResult extends Function>(): LoDashExplicitObjectWrapper<TResult>; + } + + //_.once + interface LoDashStatic { + /** + * Creates a function that is restricted to invoking func once. Repeat calls to the function return the value + * of the first call. The func is invoked with the this binding and arguments of the created function. + * + * @param func The function to restrict. + * @return Returns the new restricted function. + */ + once<T extends Function>(func: T): T; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.once + */ + once(): LoDashImplicitObjectWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.once + */ + once(): LoDashExplicitObjectWrapper<T>; + } + + //_.partial + interface LoDashStatic { + /** + * Creates a function that, when called, invokes func with any additional partial arguments + * prepended to those provided to the new function. This method is similar to _.bind except + * it does not alter the this binding. + * @param func The function to partially apply arguments to. + * @param args Arguments to be partially applied. + * @return The new partially applied function. + **/ + partial: Partial; + } + + type PH = LoDashStatic; + + interface Function0<R> { + (): R; + } + interface Function1<T1, R> { + (t1: T1): R; + } + interface Function2<T1, T2, R> { + (t1: T1, t2: T2): R; + } + interface Function3<T1, T2, T3, R> { + (t1: T1, t2: T2, t3: T3): R; + } + interface Function4<T1, T2, T3, T4, R> { + (t1: T1, t2: T2, t3: T3, t4: T4): R; + } + + interface Partial { + // arity 0 + <R>(func: Function0<R>): Function0<R>; + // arity 1 + <T1, R>(func: Function1<T1, R>): Function1<T1, R>; + <T1, R>(func: Function1<T1, R>, arg1: T1): Function0<R>; + // arity 2 + <T1, T2, R>(func: Function2<T1, T2, R>): Function2<T1, T2, R>; + <T1, T2, R>(func: Function2<T1, T2, R>, arg1: T1): Function1< T2, R>; + <T1, T2, R>(func: Function2<T1, T2, R>, plc1: PH, arg2: T2): Function1<T1, R>; + <T1, T2, R>(func: Function2<T1, T2, R>, arg1: T1, arg2: T2): Function0< R>; + // arity 3 + <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>): Function3<T1, T2, T3, R>; + <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg1: T1): Function2< T2, T3, R>; + <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, plc1: PH, arg2: T2): Function2<T1, T3, R>; + <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg1: T1, arg2: T2): Function1< T3, R>; + <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, plc1: PH, plc2: PH, arg3: T3): Function2<T1, T2, R>; + <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg1: T1, plc2: PH, arg3: T3): Function1< T2, R>; + <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, plc1: PH, arg2: T2, arg3: T3): Function1<T1, R>; + <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): Function0< R>; + // arity 4 + <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>): Function4<T1, T2, T3, T4, R>; + <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1): Function3< T2, T3, T4, R>; + <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, plc1: PH, arg2: T2): Function3<T1, T3, T4, R>; + <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2): Function2< T3, T4, R>; + <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, plc1: PH, plc2: PH, arg3: T3): Function3<T1, T2, T4, R>; + <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: PH, arg3: T3): Function2< T2, T4, R>; + <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, plc1: PH, arg2: T2, arg3: T3): Function2<T1, T4, R>; + <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3): Function1< T4, R>; + <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, plc1: PH, plc2: PH, plc3: PH, arg4: T4): Function3<T1, T2, T3, R>; + <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: PH, plc3: PH, arg4: T4): Function2< T2, T3, R>; + <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, plc1: PH, arg2: T2, plc3: PH, arg4: T4): Function2<T1, T3, R>; + <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, plc3: PH, arg4: T4): Function1< T3, R>; + <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, plc1: PH, plc2: PH, arg3: T3, arg4: T4): Function2<T1, T2, R>; + <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: PH, arg3: T3, arg4: T4): Function1< T2, R>; + <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, plc1: PH, arg2: T2, arg3: T3, arg4: T4): Function1<T1, R>; + <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): Function0< R>; + // catch-all + (func: Function, ...args: any[]): Function; + } + + //_.partialRight + interface LoDashStatic { + /** + * This method is like _.partial except that partial arguments are appended to those provided + * to the new function. + * @param func The function to partially apply arguments to. + * @param args Arguments to be partially applied. + * @return The new partially applied function. + **/ + partialRight: PartialRight + } + + interface PartialRight { + // arity 0 + <R>(func: Function0<R>): Function0<R>; + // arity 1 + <T1, R>(func: Function1<T1, R>): Function1<T1, R>; + <T1, R>(func: Function1<T1, R>, arg1: T1): Function0<R>; + // arity 2 + <T1, T2, R>(func: Function2<T1, T2, R>): Function2<T1, T2, R>; + <T1, T2, R>(func: Function2<T1, T2, R>, arg1: T1, plc2: PH): Function1< T2, R>; + <T1, T2, R>(func: Function2<T1, T2, R>, arg2: T2): Function1<T1, R>; + <T1, T2, R>(func: Function2<T1, T2, R>, arg1: T1, arg2: T2): Function0< R>; + // arity 3 + <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>): Function3<T1, T2, T3, R>; + <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg1: T1, plc2: PH, plc3: PH): Function2< T2, T3, R>; + <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg2: T2, plc3: PH): Function2<T1, T3, R>; + <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg1: T1, arg2: T2, plc3: PH): Function1< T3, R>; + <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg3: T3): Function2<T1, T2, R>; + <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg1: T1, plc2: PH, arg3: T3): Function1< T2, R>; + <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg2: T2, arg3: T3): Function1<T1, R>; + <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): Function0< R>; + // arity 4 + <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>): Function4<T1, T2, T3, T4, R>; + <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: PH, plc3: PH, plc4: PH): Function3< T2, T3, T4, R>; + <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg2: T2, plc3: PH, plc4: PH): Function3<T1, T3, T4, R>; + <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, plc3: PH, plc4: PH): Function2< T3, T4, R>; + <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg3: T3, plc4: PH): Function3<T1, T2, T4, R>; + <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: PH, arg3: T3, plc4: PH): Function2< T2, T4, R>; + <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg2: T2, arg3: T3, plc4: PH): Function2<T1, T4, R>; + <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, plc4: PH): Function1< T4, R>; + <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg4: T4): Function3<T1, T2, T3, R>; + <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: PH, plc3: PH, arg4: T4): Function2< T2, T3, R>; + <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg2: T2, plc3: PH, arg4: T4): Function2<T1, T3, R>; + <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, plc3: PH, arg4: T4): Function1< T3, R>; + <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg3: T3, arg4: T4): Function2<T1, T2, R>; + <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: PH, arg3: T3, arg4: T4): Function1< T2, R>; + <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg2: T2, arg3: T3, arg4: T4): Function1<T1, R>; + <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): Function0< R>; + // catch-all + (func: Function, ...args: any[]): Function; + } + + //_.rearg + interface LoDashStatic { + /** + * Creates a function that invokes func with arguments arranged according to the specified indexes where the + * argument value at the first index is provided as the first argument, the argument value at the second index + * is provided as the second argument, and so on. + * @param func The function to rearrange arguments for. + * @param indexes The arranged argument indexes, specified as individual indexes or arrays of indexes. + * @return Returns the new function. + */ + rearg<TResult extends Function>(func: Function, indexes: number[]): TResult; + + /** + * @see _.rearg + */ + rearg<TResult extends Function>(func: Function, ...indexes: number[]): TResult; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.rearg + */ + rearg<TResult extends Function>(indexes: number[]): LoDashImplicitObjectWrapper<TResult>; + + /** + * @see _.rearg + */ + rearg<TResult extends Function>(...indexes: number[]): LoDashImplicitObjectWrapper<TResult>; + } + + //_.rest + interface LoDashStatic { + /** + * Creates a function that invokes func with the this binding of the created function and arguments from start + * and beyond provided as an array. + * + * Note: This method is based on the rest parameter. + * + * @param func The function to apply a rest parameter to. + * @param start The start position of the rest parameter. + * @return Returns the new function. + */ + rest<TResult extends Function>( + func: Function, + start?: number + ): TResult; + + /** + * @see _.rest + */ + rest<TResult extends Function, TFunc extends Function>( + func: TFunc, + start?: number + ): TResult; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.rest + */ + rest<TResult extends Function>(start?: number): LoDashImplicitObjectWrapper<TResult>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.rest + */ + rest<TResult extends Function>(start?: number): LoDashExplicitObjectWrapper<TResult>; + } + + //_.spread + interface LoDashStatic { + /** + * Creates a function that invokes func with the this binding of the created function and an array of arguments + * much like Function#apply. + * + * Note: This method is based on the spread operator. + * + * @param func The function to spread arguments over. + * @return Returns the new function. + */ + spread<F extends Function, T extends Function>(func: F): T; + + /** + * @see _.spread + */ + spread<T extends Function>(func: Function): T; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.spread + */ + spread<T extends Function>(): LoDashImplicitObjectWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.spread + */ + spread<T extends Function>(): LoDashExplicitObjectWrapper<T>; + } + + //_.throttle + interface ThrottleSettings { + /** + * If you'd like to disable the leading-edge call, pass this as false. + */ + leading?: boolean; + + /** + * If you'd like to disable the execution on the trailing-edge, pass false. + */ + trailing?: boolean; + } + + interface LoDashStatic { + /** + * Creates a throttled function that only invokes func at most once per every wait milliseconds. The throttled + * function comes with a cancel method to cancel delayed invocations and a flush method to immediately invoke + * them. Provide an options object to indicate that func should be invoked on the leading and/or trailing edge + * of the wait timeout. Subsequent calls to the throttled function return the result of the last func call. + * + * Note: If leading and trailing options are true, func is invoked on the trailing edge of the timeout only if + * the the throttled function is invoked more than once during the wait timeout. + * + * @param func The function to throttle. + * @param wait The number of milliseconds to throttle invocations to. + * @param options The options object. + * @param options.leading Specify invoking on the leading edge of the timeout. + * @param options.trailing Specify invoking on the trailing edge of the timeout. + * @return Returns the new throttled function. + */ + throttle<T extends Function>( + func: T, + wait?: number, + options?: ThrottleSettings + ): T & Cancelable; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.throttle + */ + throttle( + wait?: number, + options?: ThrottleSettings + ): LoDashImplicitObjectWrapper<T & Cancelable>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.throttle + */ + throttle( + wait?: number, + options?: ThrottleSettings + ): LoDashExplicitObjectWrapper<T & Cancelable>; + } + + //_.unary + interface LoDashStatic { + /** + * Creates a function that accepts up to one argument, ignoring any + * additional arguments. + * + * @static + * @memberOf _ + * @category Function + * @param {Function} func The function to cap arguments for. + * @returns {Function} Returns the new function. + * @example + * + * _.map(['6', '8', '10'], _.unary(parseInt)); + * // => [6, 8, 10] + */ + unary<T extends Function>(func: T): T; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.unary + */ + unary(): LoDashImplicitObjectWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.unary + */ + unary(): LoDashExplicitObjectWrapper<T>; + } + + //_.wrap + interface LoDashStatic { + /** + * Creates a function that provides value to the wrapper function as its first argument. Any additional + * arguments provided to the function are appended to those provided to the wrapper function. The wrapper is + * invoked with the this binding of the created function. + * + * @param value The value to wrap. + * @param wrapper The wrapper function. + * @return Returns the new function. + */ + wrap<V, W extends Function, R extends Function>( + value: V, + wrapper: W + ): R; + + /** + * @see _.wrap + */ + wrap<V, R extends Function>( + value: V, + wrapper: Function + ): R; + + /** + * @see _.wrap + */ + wrap<R extends Function>( + value: any, + wrapper: Function + ): R; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.wrap + */ + wrap<W extends Function, R extends Function>(wrapper: W): LoDashImplicitObjectWrapper<R>; + + /** + * @see _.wrap + */ + wrap<R extends Function>(wrapper: Function): LoDashImplicitObjectWrapper<R>; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.wrap + */ + wrap<W extends Function, R extends Function>(wrapper: W): LoDashImplicitObjectWrapper<R>; + + /** + * @see _.wrap + */ + wrap<R extends Function>(wrapper: Function): LoDashImplicitObjectWrapper<R>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.wrap + */ + wrap<W extends Function, R extends Function>(wrapper: W): LoDashImplicitObjectWrapper<R>; + + /** + * @see _.wrap + */ + wrap<R extends Function>(wrapper: Function): LoDashImplicitObjectWrapper<R>; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.wrap + */ + wrap<W extends Function, R extends Function>(wrapper: W): LoDashExplicitObjectWrapper<R>; + + /** + * @see _.wrap + */ + wrap<R extends Function>(wrapper: Function): LoDashExplicitObjectWrapper<R>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.wrap + */ + wrap<W extends Function, R extends Function>(wrapper: W): LoDashExplicitObjectWrapper<R>; + + /** + * @see _.wrap + */ + wrap<R extends Function>(wrapper: Function): LoDashExplicitObjectWrapper<R>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.wrap + */ + wrap<W extends Function, R extends Function>(wrapper: W): LoDashExplicitObjectWrapper<R>; + + /** + * @see _.wrap + */ + wrap<R extends Function>(wrapper: Function): LoDashExplicitObjectWrapper<R>; + } + + /******** + * Lang * + ********/ + + //_.castArray + interface LoDashStatic { + /** + * Casts value as an array if it’s not one. + * + * @param value The value to inspect. + * @return Returns the cast array. + */ + castArray<T>(value: T): T[]; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.castArray + */ + castArray(): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.castArray + */ + castArray(): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.castArray + */ + castArray(): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.castArray + */ + castArray(): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.castArray + */ + castArray(): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.castArray + */ + castArray(): LoDashExplicitArrayWrapper<T>; + } + + //_.clone + interface LoDashStatic { + /** + * Creates a shallow clone of value. + * + * Note: This method is loosely based on the structured clone algorithm and supports cloning arrays, + * array buffers, booleans, date objects, maps, numbers, Object objects, regexes, sets, strings, symbols, + * and typed arrays. The own enumerable properties of arguments objects are cloned as plain objects. An empty + * object is returned for uncloneable values such as error objects, functions, DOM nodes, and WeakMaps. + * + * @param value The value to clone. + * @return Returns the cloned value. + */ + clone<T>(value: T): T; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.clone + */ + clone(): T; + } + + interface LoDashImplicitArrayWrapper<T> { + + /** + * @see _.clone + */ + clone(): T[]; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.clone + */ + clone(): T; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.clone + */ + clone(): LoDashExplicitWrapper<T>; + } + + interface LoDashExplicitArrayWrapper<T> { + + /** + * @see _.clone + */ + clone(): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.clone + */ + clone(): LoDashExplicitObjectWrapper<T>; + } + + //_.cloneDeep + interface LoDashStatic { + /** + * This method is like _.clone except that it recursively clones value. + * + * @param value The value to recursively clone. + * @return Returns the deep cloned value. + */ + cloneDeep<T>(value: T): T; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.cloneDeep + */ + cloneDeep(): T; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.cloneDeep + */ + cloneDeep(): T[]; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.cloneDeep + */ + cloneDeep(): T; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.cloneDeep + */ + cloneDeep(): LoDashExplicitWrapper<T>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.cloneDeep + */ + cloneDeep(): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.cloneDeep + */ + cloneDeep(): LoDashExplicitObjectWrapper<T>; + } + + //_.cloneDeepWith + interface CloneDeepWithCustomizer<TValue, TResult> { + (value: TValue): TResult; + } + + interface LoDashStatic { + /** + * This method is like _.cloneWith except that it recursively clones value. + * + * @param value The value to recursively clone. + * @param customizer The function to customize cloning. + * @return Returns the deep cloned value. + */ + cloneDeepWith<TResult>( + value: any, + customizer?: CloneDeepWithCustomizer<any, TResult> + ): TResult; + + /** + * @see _.clonDeepeWith + */ + cloneDeepWith<T, TResult>( + value: T, + customizer?: CloneDeepWithCustomizer<T, TResult> + ): TResult; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.cloneDeepWith + */ + cloneDeepWith<TResult>( + customizer?: CloneDeepWithCustomizer<T, TResult> + ): TResult; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.cloneDeepWith + */ + cloneDeepWith<TResult>( + customizer?: CloneDeepWithCustomizer<T[], TResult> + ): TResult; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.cloneDeepWith + */ + cloneDeepWith<TResult>( + customizer?: CloneDeepWithCustomizer<T, TResult> + ): TResult; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.cloneDeepWith + */ + cloneDeepWith<TResult extends (number|string|boolean)>( + customizer?: CloneDeepWithCustomizer<T, TResult> + ): LoDashExplicitWrapper<TResult>; + + /** + * @see _.cloneDeepWith + */ + cloneDeepWith<TResult>( + customizer?: CloneDeepWithCustomizer<T, TResult[]> + ): LoDashExplicitArrayWrapper<TResult>; + + /** + * @see _.cloneDeepWith + */ + cloneDeepWith<TResult extends Object>( + customizer?: CloneDeepWithCustomizer<T, TResult> + ): LoDashExplicitObjectWrapper<TResult>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.cloneDeepWith + */ + cloneDeepWith<TResult extends (number|string|boolean)>( + customizer?: CloneDeepWithCustomizer<T[], TResult> + ): LoDashExplicitWrapper<TResult>; + + /** + * @see _.cloneDeepWith + */ + cloneDeepWith<TResult>( + customizer?: CloneDeepWithCustomizer<T[], TResult[]> + ): LoDashExplicitArrayWrapper<TResult>; + + /** + * @see _.cloneDeepWith + */ + cloneDeepWith<TResult extends Object>( + customizer?: CloneDeepWithCustomizer<T[], TResult> + ): LoDashExplicitObjectWrapper<TResult>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.cloneDeepWith + */ + cloneDeepWith<TResult extends (number|string|boolean)>( + customizer?: CloneDeepWithCustomizer<T, TResult> + ): LoDashExplicitWrapper<TResult>; + + /** + * @see _.cloneDeepWith + */ + cloneDeepWith<TResult>( + customizer?: CloneDeepWithCustomizer<T, TResult[]> + ): LoDashExplicitArrayWrapper<TResult>; + + /** + * @see _.cloneDeepWith + */ + cloneDeepWith<TResult extends Object>( + customizer?: CloneDeepWithCustomizer<T, TResult> + ): LoDashExplicitObjectWrapper<TResult>; + } + + //_.cloneWith + interface CloneWithCustomizer<TValue, TResult> { + (value: TValue): TResult; + } + + interface LoDashStatic { + /** + * This method is like _.clone except that it accepts customizer which is invoked to produce the cloned value. + * If customizer returns undefined cloning is handled by the method instead. + * + * @param value The value to clone. + * @param customizer The function to customize cloning. + * @return Returns the cloned value. + */ + cloneWith<TResult>( + value: any, + customizer?: CloneWithCustomizer<any, TResult> + ): TResult; + + /** + * @see _.cloneWith + */ + cloneWith<T, TResult>( + value: T, + customizer?: CloneWithCustomizer<T, TResult> + ): TResult; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.cloneWith + */ + cloneWith<TResult>( + customizer?: CloneWithCustomizer<T, TResult> + ): TResult; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.cloneWith + */ + cloneWith<TResult>( + customizer?: CloneWithCustomizer<T[], TResult> + ): TResult; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.cloneWith + */ + cloneWith<TResult>( + customizer?: CloneWithCustomizer<T, TResult> + ): TResult; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.cloneWith + */ + cloneWith<TResult extends (number|string|boolean)>( + customizer?: CloneWithCustomizer<T, TResult> + ): LoDashExplicitWrapper<TResult>; + + /** + * @see _.cloneWith + */ + cloneWith<TResult>( + customizer?: CloneWithCustomizer<T, TResult[]> + ): LoDashExplicitArrayWrapper<TResult>; + + /** + * @see _.cloneWith + */ + cloneWith<TResult extends Object>( + customizer?: CloneWithCustomizer<T, TResult> + ): LoDashExplicitObjectWrapper<TResult>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.cloneWith + */ + cloneWith<TResult extends (number|string|boolean)>( + customizer?: CloneWithCustomizer<T[], TResult> + ): LoDashExplicitWrapper<TResult>; + + /** + * @see _.cloneWith + */ + cloneWith<TResult>( + customizer?: CloneWithCustomizer<T[], TResult[]> + ): LoDashExplicitArrayWrapper<TResult>; + + /** + * @see _.cloneWith + */ + cloneWith<TResult extends Object>( + customizer?: CloneWithCustomizer<T[], TResult> + ): LoDashExplicitObjectWrapper<TResult>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.cloneWith + */ + cloneWith<TResult extends (number|string|boolean)>( + customizer?: CloneWithCustomizer<T, TResult> + ): LoDashExplicitWrapper<TResult>; + + /** + * @see _.cloneWith + */ + cloneWith<TResult>( + customizer?: CloneWithCustomizer<T, TResult[]> + ): LoDashExplicitArrayWrapper<TResult>; + + /** + * @see _.cloneWith + */ + cloneWith<TResult extends Object>( + customizer?: CloneWithCustomizer<T, TResult> + ): LoDashExplicitObjectWrapper<TResult>; + } + + //_.eq + interface LoDashStatic { + /** + * Performs a [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero) + * comparison between two values to determine if they are equivalent. + * + * @static + * @memberOf _ + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + * @example + * + * var object = { 'user': 'fred' }; + * var other = { 'user': 'fred' }; + * + * _.eq(object, object); + * // => true + * + * _.eq(object, other); + * // => false + * + * _.eq('a', 'a'); + * // => true + * + * _.eq('a', Object('a')); + * // => false + * + * _.eq(NaN, NaN); + * // => true + */ + eq( + value: any, + other: any + ): boolean; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.isEqual + */ + eq( + other: any + ): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.isEqual + */ + eq( + other: any + ): LoDashExplicitWrapper<boolean>; + } + + //_.gt + interface LoDashStatic { + /** + * Checks if value is greater than other. + * + * @param value The value to compare. + * @param other The other value to compare. + * @return Returns true if value is greater than other, else false. + */ + gt( + value: any, + other: any + ): boolean; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.gt + */ + gt(other: any): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.gt + */ + gt(other: any): LoDashExplicitWrapper<boolean>; + } + + //_.gte + interface LoDashStatic { + /** + * Checks if value is greater than or equal to other. + * + * @param value The value to compare. + * @param other The other value to compare. + * @return Returns true if value is greater than or equal to other, else false. + */ + gte( + value: any, + other: any + ): boolean; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.gte + */ + gte(other: any): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.gte + */ + gte(other: any): LoDashExplicitWrapper<boolean>; + } + + //_.isArguments + interface LoDashStatic { + /** + * Checks if value is classified as an arguments object. + * + * @param value The value to check. + * @return Returns true if value is correctly classified, else false. + */ + isArguments(value?: any): value is IArguments; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.isArguments + */ + isArguments(): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.isArguments + */ + isArguments(): LoDashExplicitWrapper<boolean>; + } + + //_.isArray + interface LoDashStatic { + /** + * Checks if value is classified as an Array object. + * @param value The value to check. + * + * @return Returns true if value is correctly classified, else false. + */ + isArray<T>(value?: any): value is T[]; + } + + interface LoDashImplicitWrapperBase<T,TWrapper> { + /** + * @see _.isArray + */ + isArray(): boolean; + } + + interface LoDashExplicitWrapperBase<T,TWrapper> { + /** + * @see _.isArray + */ + isArray(): LoDashExplicitWrapper<boolean>; + } + + //_.isArrayBuffer + interface LoDashStatic { + /** + * Checks if value is classified as an ArrayBuffer object. + * + * @param value The value to check. + * @return Returns true if value is correctly classified, else false. + */ + isArrayBuffer(value?: any): value is ArrayBuffer; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.isArrayBuffer + */ + isArrayBuffer(): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.isArrayBuffer + */ + isArrayBuffer(): LoDashExplicitWrapper<boolean>; + } + + //_.isArrayLike + interface LoDashStatic { + /** + * Checks if `value` is array-like. A value is considered array-like if it's + * not a function and has a `value.length` that's an integer greater than or + * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`. + * + * @static + * @memberOf _ + * @type Function + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is array-like, else `false`. + * @example + * + * _.isArrayLike([1, 2, 3]); + * // => true + * + * _.isArrayLike(document.body.children); + * // => true + * + * _.isArrayLike('abc'); + * // => true + * + * _.isArrayLike(_.noop); + * // => false + */ + isArrayLike<T>(value?: any): value is T[]; + } + + interface LoDashImplicitWrapperBase<T,TWrapper> { + /** + * @see _.isArrayLike + */ + isArrayLike(): boolean; + } + + interface LoDashExplicitWrapperBase<T,TWrapper> { + /** + * @see _.isArrayLike + */ + isArrayLike(): LoDashExplicitWrapper<boolean>; + } + + //_.isArrayLikeObject + interface LoDashStatic { + /** + * This method is like `_.isArrayLike` except that it also checks if `value` + * is an object. + * + * @static + * @memberOf _ + * @type Function + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array-like object, else `false`. + * @example + * + * _.isArrayLikeObject([1, 2, 3]); + * // => true + * + * _.isArrayLikeObject(document.body.children); + * // => true + * + * _.isArrayLikeObject('abc'); + * // => false + * + * _.isArrayLikeObject(_.noop); + * // => false + */ + isArrayLikeObject<T>(value?: any): value is T[]; + } + + interface LoDashImplicitWrapperBase<T,TWrapper> { + /** + * @see _.isArrayLikeObject + */ + isArrayLikeObject(): boolean; + } + + interface LoDashExplicitWrapperBase<T,TWrapper> { + /** + * @see _.isArrayLikeObject + */ + isArrayLikeObject(): LoDashExplicitWrapper<boolean>; + } + + //_.isBoolean + interface LoDashStatic { + /** + * Checks if value is classified as a boolean primitive or object. + * + * @param value The value to check. + * @return Returns true if value is correctly classified, else false. + */ + isBoolean(value?: any): value is boolean; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.isBoolean + */ + isBoolean(): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.isBoolean + */ + isBoolean(): LoDashExplicitWrapper<boolean>; + } + + //_.isBuffer + interface LoDashStatic { + /** + * Checks if value is a buffer. + * + * @param value The value to check. + * @return Returns true if value is a buffer, else false. + */ + isBuffer(value?: any): boolean; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.isBuffer + */ + isBuffer(): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.isBuffer + */ + isBuffer(): LoDashExplicitWrapper<boolean>; + } + + //_.isDate + interface LoDashStatic { + /** + * Checks if value is classified as a Date object. + * @param value The value to check. + * + * @return Returns true if value is correctly classified, else false. + */ + isDate(value?: any): value is Date; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.isDate + */ + isDate(): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.isDate + */ + isDate(): LoDashExplicitWrapper<boolean>; + } + + //_.isElement + interface LoDashStatic { + /** + * Checks if value is a DOM element. + * + * @param value The value to check. + * @return Returns true if value is a DOM element, else false. + */ + isElement(value?: any): boolean; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.isElement + */ + isElement(): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.isElement + */ + isElement(): LoDashExplicitWrapper<boolean>; + } + + //_.isEmpty + interface LoDashStatic { + /** + * Checks if value is empty. A value is considered empty unless it’s an arguments object, array, string, or + * jQuery-like collection with a length greater than 0 or an object with own enumerable properties. + * + * @param value The value to inspect. + * @return Returns true if value is empty, else false. + */ + isEmpty(value?: any): boolean; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.isEmpty + */ + isEmpty(): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.isEmpty + */ + isEmpty(): LoDashExplicitWrapper<boolean>; + } + + //_.isEqual + interface LoDashStatic { + /** + * Performs a deep comparison between two values to determine if they are + * equivalent. + * + * **Note:** This method supports comparing arrays, array buffers, booleans, + * date objects, error objects, maps, numbers, `Object` objects, regexes, + * sets, strings, symbols, and typed arrays. `Object` objects are compared + * by their own, not inherited, enumerable properties. Functions and DOM + * nodes are **not** supported. + * + * @static + * @memberOf _ + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + * @example + * + * var object = { 'user': 'fred' }; + * var other = { 'user': 'fred' }; + * + * _.isEqual(object, other); + * // => true + * + * object === other; + * // => false + */ + isEqual( + value: any, + other: any + ): boolean; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.isEqual + */ + isEqual( + other: any + ): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.isEqual + */ + isEqual( + other: any + ): LoDashExplicitWrapper<boolean>; + } + + // _.isEqualWith + interface IsEqualCustomizer { + (value: any, other: any, indexOrKey?: number|string): boolean; + } + + interface LoDashStatic { + /** + * This method is like `_.isEqual` except that it accepts `customizer` which is + * invoked to compare values. If `customizer` returns `undefined` comparisons are + * handled by the method instead. The `customizer` is invoked with up to seven arguments: + * (objValue, othValue [, index|key, object, other, stack]). + * + * @static + * @memberOf _ + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @param {Function} [customizer] The function to customize comparisons. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + * @example + * + * function isGreeting(value) { + * return /^h(?:i|ello)$/.test(value); + * } + * + * function customizer(objValue, othValue) { + * if (isGreeting(objValue) && isGreeting(othValue)) { + * return true; + * } + * } + * + * var array = ['hello', 'goodbye']; + * var other = ['hi', 'goodbye']; + * + * _.isEqualWith(array, other, customizer); + * // => true + */ + isEqualWith( + value: any, + other: any, + customizer: IsEqualCustomizer + ): boolean; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.isEqualWith + */ + isEqualWith( + other: any, + customizer: IsEqualCustomizer + ): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.isEqualWith + */ + isEqualWith( + other: any, + customizer: IsEqualCustomizer + ): LoDashExplicitWrapper<boolean>; + } + + //_.isError + interface LoDashStatic { + /** + * Checks if value is an Error, EvalError, RangeError, ReferenceError, SyntaxError, TypeError, or URIError + * object. + * + * @param value The value to check. + * @return Returns true if value is an error object, else false. + */ + isError(value: any): value is Error; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.isError + */ + isError(): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.isError + */ + isError(): LoDashExplicitWrapper<boolean>; + } + + //_.isFinite + interface LoDashStatic { + /** + * Checks if value is a finite primitive number. + * + * Note: This method is based on Number.isFinite. + * + * @param value The value to check. + * @return Returns true if value is a finite number, else false. + */ + isFinite(value?: any): boolean; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.isFinite + */ + isFinite(): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.isFinite + */ + isFinite(): LoDashExplicitWrapper<boolean>; + } + + //_.isFunction + interface LoDashStatic { + /** + * Checks if value is classified as a Function object. + * + * @param value The value to check. + * @return Returns true if value is correctly classified, else false. + */ + isFunction(value?: any): value is Function; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.isFunction + */ + isFunction(): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.isFunction + */ + isFunction(): LoDashExplicitWrapper<boolean>; + } + + //_.isInteger + interface LoDashStatic { + /** + * Checks if `value` is an integer. + * + * **Note:** This method is based on [`Number.isInteger`](https://mdn.io/Number/isInteger). + * + * @static + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an integer, else `false`. + * @example + * + * _.isInteger(3); + * // => true + * + * _.isInteger(Number.MIN_VALUE); + * // => false + * + * _.isInteger(Infinity); + * // => false + * + * _.isInteger('3'); + * // => false + */ + isInteger(value?: any): boolean; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.isInteger + */ + isInteger(): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.isInteger + */ + isInteger(): LoDashExplicitWrapper<boolean>; + } + + //_.isLength + interface LoDashStatic { + /** + * Checks if `value` is a valid array-like length. + * + * **Note:** This function is loosely based on [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength). + * + * @static + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a valid length, else `false`. + * @example + * + * _.isLength(3); + * // => true + * + * _.isLength(Number.MIN_VALUE); + * // => false + * + * _.isLength(Infinity); + * // => false + * + * _.isLength('3'); + * // => false + */ + isLength(value?: any): boolean; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.isLength + */ + isLength(): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.isLength + */ + isLength(): LoDashExplicitWrapper<boolean>; + } + + //_.isMap + interface LoDashStatic { + /** + * Checks if value is classified as a Map object. + * + * @param value The value to check. + * @returns Returns true if value is correctly classified, else false. + */ + isMap<K, V>(value?: any): value is Map<K, V>; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.isMap + */ + isMap(): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.isMap + */ + isMap(): LoDashExplicitWrapper<boolean>; + } + + //_.isMatch + interface isMatchCustomizer { + (value: any, other: any, indexOrKey?: number|string): boolean; + } + + interface LoDashStatic { + /** + * Performs a deep comparison between `object` and `source` to determine if + * `object` contains equivalent property values. + * + * **Note:** This method supports comparing the same values as `_.isEqual`. + * + * @static + * @memberOf _ + * @category Lang + * @param {Object} object The object to inspect. + * @param {Object} source The object of property values to match. + * @returns {boolean} Returns `true` if `object` is a match, else `false`. + * @example + * + * var object = { 'user': 'fred', 'age': 40 }; + * + * _.isMatch(object, { 'age': 40 }); + * // => true + * + * _.isMatch(object, { 'age': 36 }); + * // => false + */ + isMatch(object: Object, source: Object): boolean; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.isMatch + */ + isMatch(source: Object): boolean; + } + + //_.isMatchWith + interface isMatchWithCustomizer { + (value: any, other: any, indexOrKey?: number|string): boolean; + } + + interface LoDashStatic { + /** + * This method is like `_.isMatch` except that it accepts `customizer` which + * is invoked to compare values. If `customizer` returns `undefined` comparisons + * are handled by the method instead. The `customizer` is invoked with three + * arguments: (objValue, srcValue, index|key, object, source). + * + * @static + * @memberOf _ + * @category Lang + * @param {Object} object The object to inspect. + * @param {Object} source The object of property values to match. + * @param {Function} [customizer] The function to customize comparisons. + * @returns {boolean} Returns `true` if `object` is a match, else `false`. + * @example + * + * function isGreeting(value) { + * return /^h(?:i|ello)$/.test(value); + * } + * + * function customizer(objValue, srcValue) { + * if (isGreeting(objValue) && isGreeting(srcValue)) { + * return true; + * } + * } + * + * var object = { 'greeting': 'hello' }; + * var source = { 'greeting': 'hi' }; + * + * _.isMatchWith(object, source, customizer); + * // => true + */ + isMatchWith(object: Object, source: Object, customizer: isMatchWithCustomizer): boolean; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.isMatchWith + */ + isMatchWith(source: Object, customizer: isMatchWithCustomizer): boolean; + } + + //_.isNaN + interface LoDashStatic { + /** + * Checks if value is NaN. + * + * Note: This method is not the same as isNaN which returns true for undefined and other non-numeric values. + * + * @param value The value to check. + * @return Returns true if value is NaN, else false. + */ + isNaN(value?: any): boolean; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.isNaN + */ + isNaN(): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.isNaN + */ + isNaN(): LoDashExplicitWrapper<boolean>; + } + + //_.isNative + interface LoDashStatic { + /** + * Checks if value is a native function. + * @param value The value to check. + * + * @retrun Returns true if value is a native function, else false. + */ + isNative(value: any): value is Function; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * see _.isNative + */ + isNative(): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * see _.isNative + */ + isNative(): LoDashExplicitWrapper<boolean>; + } + + //_.isNil + interface LoDashStatic { + /** + * Checks if `value` is `null` or `undefined`. + * + * @static + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is nullish, else `false`. + * @example + * + * _.isNil(null); + * // => true + * + * _.isNil(void 0); + * // => true + * + * _.isNil(NaN); + * // => false + */ + isNil(value?: any): boolean; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * see _.isNil + */ + isNil(): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * see _.isNil + */ + isNil(): LoDashExplicitWrapper<boolean>; + } + + //_.isNull + interface LoDashStatic { + /** + * Checks if value is null. + * + * @param value The value to check. + * @return Returns true if value is null, else false. + */ + isNull(value?: any): boolean; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * see _.isNull + */ + isNull(): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * see _.isNull + */ + isNull(): LoDashExplicitWrapper<boolean>; + } + + //_.isNumber + interface LoDashStatic { + /** + * Checks if value is classified as a Number primitive or object. + * + * Note: To exclude Infinity, -Infinity, and NaN, which are classified as numbers, use the _.isFinite method. + * + * @param value The value to check. + * @return Returns true if value is correctly classified, else false. + */ + isNumber(value?: any): value is number; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * see _.isNumber + */ + isNumber(): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * see _.isNumber + */ + isNumber(): LoDashExplicitWrapper<boolean>; + } + + //_.isObject + interface LoDashStatic { + /** + * Checks if value is the language type of Object. (e.g. arrays, functions, objects, regexes, new Number(0), + * and new String('')) + * + * @param value The value to check. + * @return Returns true if value is an object, else false. + */ + isObject(value?: any): boolean; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * see _.isObject + */ + isObject(): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * see _.isObject + */ + isObject(): LoDashExplicitWrapper<boolean>; + } + + //_.isObjectLike + interface LoDashStatic { + /** + * Checks if `value` is object-like. A value is object-like if it's not `null` + * and has a `typeof` result of "object". + * + * @static + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is object-like, else `false`. + * @example + * + * _.isObjectLike({}); + * // => true + * + * _.isObjectLike([1, 2, 3]); + * // => true + * + * _.isObjectLike(_.noop); + * // => false + * + * _.isObjectLike(null); + * // => false + */ + isObjectLike(value?: any): boolean; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * see _.isObjectLike + */ + isObjectLike(): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * see _.isObjectLike + */ + isObjectLike(): LoDashExplicitWrapper<boolean>; + } + + //_.isPlainObject + interface LoDashStatic { + /** + * Checks if value is a plain object, that is, an object created by the Object constructor or one with a + * [[Prototype]] of null. + * + * Note: This method assumes objects created by the Object constructor have no inherited enumerable properties. + * + * @param value The value to check. + * @return Returns true if value is a plain object, else false. + */ + isPlainObject(value?: any): boolean; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * see _.isPlainObject + */ + isPlainObject(): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * see _.isPlainObject + */ + isPlainObject(): LoDashExplicitWrapper<boolean>; + } + + //_.isRegExp + interface LoDashStatic { + /** + * Checks if value is classified as a RegExp object. + * @param value The value to check. + * + * @return Returns true if value is correctly classified, else false. + */ + isRegExp(value?: any): value is RegExp; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * see _.isRegExp + */ + isRegExp(): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * see _.isRegExp + */ + isRegExp(): LoDashExplicitWrapper<boolean>; + } + + //_.isSafeInteger + interface LoDashStatic { + /** + * Checks if `value` is a safe integer. An integer is safe if it's an IEEE-754 + * double precision number which isn't the result of a rounded unsafe integer. + * + * **Note:** This method is based on [`Number.isSafeInteger`](https://mdn.io/Number/isSafeInteger). + * + * @static + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a safe integer, else `false`. + * @example + * + * _.isSafeInteger(3); + * // => true + * + * _.isSafeInteger(Number.MIN_VALUE); + * // => false + * + * _.isSafeInteger(Infinity); + * // => false + * + * _.isSafeInteger('3'); + * // => false + */ + isSafeInteger(value: any): boolean; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * see _.isSafeInteger + */ + isSafeInteger(): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * see _.isSafeInteger + */ + isSafeInteger(): LoDashExplicitWrapper<boolean>; + } + + //_.isSet + interface LoDashStatic { + /** + * Checks if value is classified as a Set object. + * + * @param value The value to check. + * @returns Returns true if value is correctly classified, else false. + */ + isSet<T>(value?: any): value is Set<T>; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.isSet + */ + isSet(): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.isSet + */ + isSet(): LoDashExplicitWrapper<boolean>; + } + + //_.isString + interface LoDashStatic { + /** + * Checks if value is classified as a String primitive or object. + * + * @param value The value to check. + * @return Returns true if value is correctly classified, else false. + */ + isString(value?: any): value is string; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * see _.isString + */ + isString(): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * see _.isString + */ + isString(): LoDashExplicitWrapper<boolean>; + } + + //_.isSymbol + interface LoDashStatic { + /** + * Checks if `value` is classified as a `Symbol` primitive or object. + * + * @static + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`. + * @example + * + * _.isSymbol(Symbol.iterator); + * // => true + * + * _.isSymbol('abc'); + * // => false + */ + isSymbol(value: any): boolean; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * see _.isSymbol + */ + isSymbol(): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * see _.isSymbol + */ + isSymbol(): LoDashExplicitWrapper<boolean>; + } + + //_.isTypedArray + interface LoDashStatic { + /** + * Checks if value is classified as a typed array. + * + * @param value The value to check. + * @return Returns true if value is correctly classified, else false. + */ + isTypedArray(value: any): boolean; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * see _.isTypedArray + */ + isTypedArray(): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * see _.isTypedArray + */ + isTypedArray(): LoDashExplicitWrapper<boolean>; + } + + //_.isUndefined + interface LoDashStatic { + /** + * Checks if value is undefined. + * + * @param value The value to check. + * @return Returns true if value is undefined, else false. + */ + isUndefined(value: any): boolean; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * see _.isUndefined + */ + isUndefined(): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * see _.isUndefined + */ + isUndefined(): LoDashExplicitWrapper<boolean>; + } + + //_.isWeakMap + interface LoDashStatic { + /** + * Checks if value is classified as a WeakMap object. + * + * @param value The value to check. + * @returns Returns true if value is correctly classified, else false. + */ + isWeakMap<K, V>(value?: any): value is WeakMap<K, V>; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.isSet + */ + isWeakMap(): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.isSet + */ + isWeakMap(): LoDashExplicitWrapper<boolean>; + } + + //_.isWeakSet + interface LoDashStatic { + /** + * Checks if value is classified as a WeakSet object. + * + * @param value The value to check. + * @returns Returns true if value is correctly classified, else false. + */ + isWeakSet<T>(value?: any): value is WeakSet<T>; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.isWeakSet + */ + isWeakSet(): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.isWeakSet + */ + isWeakSet(): LoDashExplicitWrapper<boolean>; + } + + //_.lt + interface LoDashStatic { + /** + * Checks if value is less than other. + * + * @param value The value to compare. + * @param other The other value to compare. + * @return Returns true if value is less than other, else false. + */ + lt( + value: any, + other: any + ): boolean; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.lt + */ + lt(other: any): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.lt + */ + lt(other: any): LoDashExplicitWrapper<boolean>; + } + + //_.lte + interface LoDashStatic { + /** + * Checks if value is less than or equal to other. + * + * @param value The value to compare. + * @param other The other value to compare. + * @return Returns true if value is less than or equal to other, else false. + */ + lte( + value: any, + other: any + ): boolean; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.lte + */ + lte(other: any): boolean; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.lte + */ + lte(other: any): LoDashExplicitWrapper<boolean>; + } + + //_.toArray + interface LoDashStatic { + /** + * Converts value to an array. + * + * @param value The value to convert. + * @return Returns the converted array. + */ + toArray<T>(value: List<T>|Dictionary<T>|NumericDictionary<T>): T[]; + + /** + * @see _.toArray + */ + toArray<TValue, TResult>(value: TValue): TResult[]; + + /** + * @see _.toArray + */ + toArray<TResult>(value?: any): TResult[]; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.toArray + */ + toArray<TResult>(): LoDashImplicitArrayWrapper<TResult>; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.toArray + */ + toArray(): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.toArray + */ + toArray<TResult>(): LoDashImplicitArrayWrapper<TResult>; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.toArray + */ + toArray<TResult>(): LoDashExplicitArrayWrapper<TResult>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.toArray + */ + toArray(): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.toArray + */ + toArray<TResult>(): LoDashExplicitArrayWrapper<TResult>; + } + + //_.toPlainObject + interface LoDashStatic { + /** + * Converts value to a plain object flattening inherited enumerable properties of value to own properties + * of the plain object. + * + * @param value The value to convert. + * @return Returns the converted plain object. + */ + toPlainObject<TResult extends {}>(value?: any): TResult; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.toPlainObject + */ + toPlainObject<TResult extends {}>(): LoDashImplicitObjectWrapper<TResult>; + } + + //_.toInteger + interface LoDashStatic { + /** + * Converts `value` to an integer. + * + * **Note:** This function is loosely based on [`ToInteger`](http://www.ecma-international.org/ecma-262/6.0/#sec-tointeger). + * + * @static + * @memberOf _ + * @category Lang + * @param {*} value The value to convert. + * @returns {number} Returns the converted integer. + * @example + * + * _.toInteger(3); + * // => 3 + * + * _.toInteger(Number.MIN_VALUE); + * // => 0 + * + * _.toInteger(Infinity); + * // => 1.7976931348623157e+308 + * + * _.toInteger('3'); + * // => 3 + */ + toInteger(value: any): number; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.toInteger + */ + toInteger(): LoDashImplicitWrapper<number>; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.toInteger + */ + toInteger(): LoDashExplicitWrapper<number>; + } + + //_.toLength + interface LoDashStatic { + /** + * Converts `value` to an integer suitable for use as the length of an + * array-like object. + * + * **Note:** This method is based on [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength). + * + * @static + * @memberOf _ + * @category Lang + * @param {*} value The value to convert. + * @return {number} Returns the converted integer. + * @example + * + * _.toLength(3); + * // => 3 + * + * _.toLength(Number.MIN_VALUE); + * // => 0 + * + * _.toLength(Infinity); + * // => 4294967295 + * + * _.toLength('3'); + * // => 3 + */ + toLength(value: any): number; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.toLength + */ + toLength(): LoDashImplicitWrapper<number>; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.toLength + */ + toLength(): LoDashExplicitWrapper<number>; + } + + //_.toNumber + interface LoDashStatic { + /** + * Converts `value` to a number. + * + * @static + * @memberOf _ + * @category Lang + * @param {*} value The value to process. + * @returns {number} Returns the number. + * @example + * + * _.toNumber(3); + * // => 3 + * + * _.toNumber(Number.MIN_VALUE); + * // => 5e-324 + * + * _.toNumber(Infinity); + * // => Infinity + * + * _.toNumber('3'); + * // => 3 + */ + toNumber(value: any): number; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.toNumber + */ + toNumber(): LoDashImplicitWrapper<number>; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.toNumber + */ + toNumber(): LoDashExplicitWrapper<number>; + } + + //_.toSafeInteger + interface LoDashStatic { + /** + * Converts `value` to a safe integer. A safe integer can be compared and + * represented correctly. + * + * @static + * @memberOf _ + * @category Lang + * @param {*} value The value to convert. + * @returns {number} Returns the converted integer. + * @example + * + * _.toSafeInteger(3); + * // => 3 + * + * _.toSafeInteger(Number.MIN_VALUE); + * // => 0 + * + * _.toSafeInteger(Infinity); + * // => 9007199254740991 + * + * _.toSafeInteger('3'); + * // => 3 + */ + toSafeInteger(value: any): number; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.toSafeInteger + */ + toSafeInteger(): LoDashImplicitWrapper<number>; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.toSafeInteger + */ + toSafeInteger(): LoDashExplicitWrapper<number>; + } + + //_.toString DUMMY + interface LoDashStatic { + /** + * Converts `value` to a string if it's not one. An empty string is returned + * for `null` and `undefined` values. The sign of `-0` is preserved. + * + * @static + * @memberOf _ + * @category Lang + * @param {*} value The value to process. + * @returns {string} Returns the string. + * @example + * + * _.toString(null); + * // => '' + * + * _.toString(-0); + * // => '-0' + * + * _.toString([1, 2, 3]); + * // => '1,2,3' + */ + toString(value: any): string; + } + + /******** + * Math * + ********/ + + //_.add + interface LoDashStatic { + /** + * Adds two numbers. + * + * @param augend The first number to add. + * @param addend The second number to add. + * @return Returns the sum. + */ + add( + augend: number, + addend: number + ): number; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.add + */ + add(addend: number): number; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.add + */ + add(addend: number): LoDashExplicitWrapper<number>; + } + + //_.ceil + interface LoDashStatic { + /** + * Calculates n rounded up to precision. + * + * @param n The number to round up. + * @param precision The precision to round up to. + * @return Returns the rounded up number. + */ + ceil( + n: number, + precision?: number + ): number; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.ceil + */ + ceil(precision?: number): number; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.ceil + */ + ceil(precision?: number): LoDashExplicitWrapper<number>; + } + + //_.floor + interface LoDashStatic { + /** + * Calculates n rounded down to precision. + * + * @param n The number to round down. + * @param precision The precision to round down to. + * @return Returns the rounded down number. + */ + floor( + n: number, + precision?: number + ): number; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.floor + */ + floor(precision?: number): number; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.floor + */ + floor(precision?: number): LoDashExplicitWrapper<number>; + } + + //_.max + interface LoDashStatic { + /** + * Computes the maximum value of `array`. If `array` is empty or falsey + * `undefined` is returned. + * + * @static + * @memberOf _ + * @category Math + * @param {Array} array The array to iterate over. + * @returns {*} Returns the maximum value. + */ + max<T>( + collection: List<T> + ): T; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.max + */ + max(): T; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.max + */ + max<T>(): T; + } + + //_.maxBy + interface LoDashStatic { + /** + * This method is like `_.max` except that it accepts `iteratee` which is + * invoked for each element in `array` to generate the criterion by which + * the value is ranked. The iteratee is invoked with one argument: (value). + * + * @static + * @memberOf _ + * @category Math + * @param {Array} array The array to iterate over. + * @param {Function|Object|string} [iteratee=_.identity] The iteratee invoked per element. + * @returns {*} Returns the maximum value. + * @example + * + * var objects = [{ 'n': 1 }, { 'n': 2 }]; + * + * _.maxBy(objects, function(o) { return o.a; }); + * // => { 'n': 2 } + * + * // using the `_.property` iteratee shorthand + * _.maxBy(objects, 'n'); + * // => { 'n': 2 } + */ + maxBy<T>( + collection: List<T>, + iteratee?: ListIterator<T, any> + ): T; + + /** + * @see _.maxBy + */ + maxBy<T>( + collection: Dictionary<T>, + iteratee?: DictionaryIterator<T, any> + ): T; + + /** + * @see _.maxBy + */ + maxBy<T>( + collection: List<T>|Dictionary<T>, + iteratee?: string + ): T; + + /** + * @see _.maxBy + */ + maxBy<TObject extends {}, T>( + collection: List<T>|Dictionary<T>, + whereValue?: TObject + ): T; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.maxBy + */ + maxBy( + iteratee?: ListIterator<T, any> + ): T; + + /** + * @see _.maxBy + */ + maxBy( + iteratee?: string + ): T; + + /** + * @see _.maxBy + */ + maxBy<TObject extends {}>( + whereValue?: TObject + ): T; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.maxBy + */ + maxBy<T>( + iteratee?: ListIterator<T, any>|DictionaryIterator<T, any> + ): T; + + /** + * @see _.maxBy + */ + maxBy<T>( + iteratee?: string + ): T; + + /** + * @see _.maxBy + */ + maxBy<TObject extends {}, T>( + whereValue?: TObject + ): T; + } + + //_.mean + interface LoDashStatic { + /** + * Computes the mean of the values in `array`. + * + * @static + * @memberOf _ + * @category Math + * @param {Array} array The array to iterate over. + * @returns {number} Returns the mean. + * @example + * + * _.mean([4, 2, 8, 6]); + * // => 5 + */ + mean<T>( + collection: List<T> + ): number; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.mean + */ + mean<T>(): number; + + /** + * @see _.mean + */ + mean(): number; + } + + //_.min + interface LoDashStatic { + /** + * Computes the minimum value of `array`. If `array` is empty or falsey + * `undefined` is returned. + * + * @static + * @memberOf _ + * @category Math + * @param {Array} array The array to iterate over. + * @returns {*} Returns the minimum value. + */ + min<T>( + collection: List<T> + ): T; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.min + */ + min(): T; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.min + */ + min<T>(): T; + } + + //_.minBy + interface LoDashStatic { + /** + * This method is like `_.min` except that it accepts `iteratee` which is + * invoked for each element in `array` to generate the criterion by which + * the value is ranked. The iteratee is invoked with one argument: (value). + * + * @static + * @memberOf _ + * @category Math + * @param {Array} array The array to iterate over. + * @param {Function|Object|string} [iteratee=_.identity] The iteratee invoked per element. + * @returns {*} Returns the minimum value. + * @example + * + * var objects = [{ 'n': 1 }, { 'n': 2 }]; + * + * _.minBy(objects, function(o) { return o.a; }); + * // => { 'n': 1 } + * + * // using the `_.property` iteratee shorthand + * _.minBy(objects, 'n'); + * // => { 'n': 1 } + */ + minBy<T>( + collection: List<T>, + iteratee?: ListIterator<T, any> + ): T; + + /** + * @see _.minBy + */ + minBy<T>( + collection: Dictionary<T>, + iteratee?: DictionaryIterator<T, any> + ): T; + + /** + * @see _.minBy + */ + minBy<T>( + collection: List<T>|Dictionary<T>, + iteratee?: string + ): T; + + /** + * @see _.minBy + */ + minBy<TObject extends {}, T>( + collection: List<T>|Dictionary<T>, + whereValue?: TObject + ): T; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.minBy + */ + minBy( + iteratee?: ListIterator<T, any> + ): T; + + /** + * @see _.minBy + */ + minBy( + iteratee?: string + ): T; + + /** + * @see _.minBy + */ + minBy<TObject extends {}>( + whereValue?: TObject + ): T; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.minBy + */ + minBy<T>( + iteratee?: ListIterator<T, any>|DictionaryIterator<T, any> + ): T; + + /** + * @see _.minBy + */ + minBy<T>( + iteratee?: string + ): T; + + /** + * @see _.minBy + */ + minBy<TObject extends {}, T>( + whereValue?: TObject + ): T; + } + + //_.round + interface LoDashStatic { + /** + * Calculates n rounded to precision. + * + * @param n The number to round. + * @param precision The precision to round to. + * @return Returns the rounded number. + */ + round( + n: number, + precision?: number + ): number; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.round + */ + round(precision?: number): number; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.round + */ + round(precision?: number): LoDashExplicitWrapper<number>; + } + + //_.sum + interface LoDashStatic { + /** + * Computes the sum of the values in `array`. + * + * @static + * @memberOf _ + * @category Math + * @param {Array} array The array to iterate over. + * @returns {number} Returns the sum. + * @example + * + * _.sum([4, 2, 8, 6]); + * // => 20 + */ + sum<T>(collection: List<T>): number; + + /** + * @see _.sum + */ + sum(collection: List<number>|Dictionary<number>): number; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.sum + */ + sum(): number; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.sum + **/ + sum<TValue>(): number; + + /** + * @see _.sum + */ + sum(): number; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.sum + */ + sum(): LoDashExplicitWrapper<number>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.sum + */ + sum<TValue>(): LoDashExplicitWrapper<number>; + + /** + * @see _.sum + */ + sum(): LoDashExplicitWrapper<number>; + } + + //_.sumBy + interface LoDashStatic { + /** + * This method is like `_.sum` except that it accepts `iteratee` which is + * invoked for each element in `array` to generate the value to be summed. + * The iteratee is invoked with one argument: (value). + * + * @static + * @memberOf _ + * @category Math + * @param {Array} array The array to iterate over. + * @param {Function|Object|string} [iteratee=_.identity] The iteratee invoked per element. + * @returns {number} Returns the sum. + * @example + * + * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }]; + * + * _.sumBy(objects, function(o) { return o.n; }); + * // => 20 + * + * // using the `_.property` iteratee shorthand + * _.sumBy(objects, 'n'); + * // => 20 + */ + sumBy<T>( + collection: List<T>, + iteratee: ListIterator<T, number> + ): number; + + /** + * @see _.sumBy + */ + sumBy( + collection: List<{}>, + iteratee: string + ): number; + + /** + * @see _.sumBy + */ + sumBy( + collection: List<number> + ): number; + + /** + * @see _.sumBy + */ + sumBy( + collection: List<{}>, + iteratee: Dictionary<{}> + ): number; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.sumBy + */ + sumBy( + iteratee: ListIterator<T, number> + ): number; + + /** + * @see _.sumBy + */ + sumBy(iteratee: string): number; + + /** + * @see _.sumBy + */ + sumBy(iteratee: Dictionary<{}>): number; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.sumBy + */ + sumBy( + iteratee: ListIterator<{}, number> + ): number; + + /** + * @see _.sumBy + */ + sumBy(iteratee: string): number; + + /** + * @see _.sumBy + */ + sumBy(iteratee: Dictionary<{}>): number; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.sumBy + */ + sumBy( + iteratee: ListIterator<T, number> + ): LoDashExplicitWrapper<number>; + + /** + * @see _.sumBy + */ + sumBy(iteratee: string): LoDashExplicitWrapper<number>; + + /** + * @see _.sumBy + */ + sumBy(): LoDashExplicitWrapper<number>; + + /** + * @see _.sumBy + */ + sumBy(iteratee: Dictionary<{}>): LoDashExplicitWrapper<number>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.sumBy + */ + sumBy( + iteratee: ListIterator<{}, number> + ): LoDashExplicitWrapper<number>; + + /** + * @see _.sumBy + */ + sumBy(iteratee: string): LoDashExplicitWrapper<number>; + + /** + * @see _.sumBy + */ + sumBy(iteratee: Dictionary<{}>): LoDashExplicitWrapper<number>; + } + + /********** + * Number * + **********/ + + //_.subtract + interface LoDashStatic { + /** + * Subtract two numbers. + * + * @static + * @memberOf _ + * @category Math + * @param {number} minuend The first number in a subtraction. + * @param {number} subtrahend The second number in a subtraction. + * @returns {number} Returns the difference. + * @example + * + * _.subtract(6, 4); + * // => 2 + */ + subtract( + minuend: number, + subtrahend: number + ): number; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.subtract + */ + subtract( + subtrahend: number + ): number; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.subtract + */ + subtract( + subtrahend: number + ): LoDashExplicitWrapper<number>; + } + + //_.clamp + interface LoDashStatic { + /** + * Clamps `number` within the inclusive `lower` and `upper` bounds. + * + * @static + * @memberOf _ + * @category Number + * @param {number} number The number to clamp. + * @param {number} [lower] The lower bound. + * @param {number} upper The upper bound. + * @returns {number} Returns the clamped number. + * @example + * + * _.clamp(-10, -5, 5); + * // => -5 + * + * _.clamp(10, -5, 5); + * // => 5 + */ + clamp( + number: number, + lower: number, + upper: number + ): number; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.clamp + */ + clamp( + lower: number, + upper: number + ): number; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.clamp + */ + clamp( + lower: number, + upper: number + ): LoDashExplicitWrapper<number>; + } + + //_.inRange + interface LoDashStatic { + /** + * Checks if n is between start and up to but not including, end. If end is not specified it’s set to start + * with start then set to 0. + * + * @param n The number to check. + * @param start The start of the range. + * @param end The end of the range. + * @return Returns true if n is in the range, else false. + */ + inRange( + n: number, + start: number, + end: number + ): boolean; + + + /** + * @see _.inRange + */ + inRange( + n: number, + end: number + ): boolean; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.inRange + */ + inRange( + start: number, + end: number + ): boolean; + + /** + * @see _.inRange + */ + inRange(end: number): boolean; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.inRange + */ + inRange( + start: number, + end: number + ): LoDashExplicitWrapper<boolean>; + + /** + * @see _.inRange + */ + inRange(end: number): LoDashExplicitWrapper<boolean>; + } + + //_.random + interface LoDashStatic { + /** + * Produces a random number between min and max (inclusive). If only one argument is provided a number between + * 0 and the given number is returned. If floating is true, or either min or max are floats, a floating-point + * number is returned instead of an integer. + * + * @param min The minimum possible value. + * @param max The maximum possible value. + * @param floating Specify returning a floating-point number. + * @return Returns the random number. + */ + random( + min?: number, + max?: number, + floating?: boolean + ): number; + + /** + * @see _.random + */ + random( + min?: number, + floating?: boolean + ): number; + + /** + * @see _.random + */ + random(floating?: boolean): number; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.random + */ + random( + max?: number, + floating?: boolean + ): number; + + /** + * @see _.random + */ + random(floating?: boolean): number; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.random + */ + random( + max?: number, + floating?: boolean + ): LoDashExplicitWrapper<number>; + + /** + * @see _.random + */ + random(floating?: boolean): LoDashExplicitWrapper<number>; + } + + /********** + * Object * + **********/ + + //_.assign + interface LoDashStatic { + /** + * Assigns own enumerable properties of source objects to the destination + * object. Source objects are applied from left to right. Subsequent sources + * overwrite property assignments of previous sources. + * + * **Note:** This method mutates `object` and is loosely based on + * [`Object.assign`](https://mdn.io/Object/assign). + * + * @static + * @memberOf _ + * @category Object + * @param {Object} object The destination object. + * @param {...Object} [sources] The source objects. + * @returns {Object} Returns `object`. + * @example + * + * function Foo() { + * this.c = 3; + * } + * + * function Bar() { + * this.e = 5; + * } + * + * Foo.prototype.d = 4; + * Bar.prototype.f = 6; + * + * _.assign({ 'a': 1 }, new Foo, new Bar); + * // => { 'a': 1, 'c': 3, 'e': 5 } + */ + assign<TObject, TSource>( + object: TObject, + source: TSource + ): TObject & TSource; + + /** + * @see assign + */ + assign<TObject, TSource1, TSource2>( + object: TObject, + source1: TSource1, + source2: TSource2 + ): TObject & TSource1 & TSource2; + + /** + * @see assign + */ + assign<TObject, TSource1, TSource2, TSource3>( + object: TObject, + source1: TSource1, + source2: TSource2, + source3: TSource3 + ): TObject & TSource1 & TSource2 & TSource3; + + /** + * @see assign + */ + assign<TObject, TSource1, TSource2, TSource3, TSource4>( + object: TObject, + source1: TSource1, + source2: TSource2, + source3: TSource3, + source4: TSource4 + ): TObject & TSource1 & TSource2 & TSource3 & TSource4; + + /** + * @see _.assign + */ + assign<TObject>(object: TObject): TObject; + + /** + * @see _.assign + */ + assign<TResult>( + object: any, + ...otherArgs: any[] + ): TResult; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.assign + */ + assign<TSource>( + source: TSource + ): LoDashImplicitObjectWrapper<T & TSource>; + + /** + * @see assign + */ + assign<TSource1, TSource2>( + source1: TSource1, + source2: TSource2 + ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2>; + + /** + * @see assign + */ + assign<TSource1, TSource2, TSource3>( + source1: TSource1, + source2: TSource2, + source3: TSource3 + ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>; + + /** + * @see assign + */ + assign<TSource1, TSource2, TSource3, TSource4>( + source1: TSource1, + source2: TSource2, + source3: TSource3, + source4: TSource4 + ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>; + + /** + * @see _.assign + */ + assign(): LoDashImplicitObjectWrapper<T>; + + /** + * @see _.assign + */ + assign<TResult>(...otherArgs: any[]): LoDashImplicitObjectWrapper<TResult>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.assign + */ + assign<TSource>( + source: TSource + ): LoDashExplicitObjectWrapper<T & TSource>; + + /** + * @see assign + */ + assign<TSource1, TSource2>( + source1: TSource1, + source2: TSource2 + ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2>; + + /** + * @see assign + */ + assign<TSource1, TSource2, TSource3>( + source1: TSource1, + source2: TSource2, + source3: TSource3 + ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>; + + /** + * @see assign + */ + assign<TSource1, TSource2, TSource3, TSource4>( + source1: TSource1, + source2: TSource2, + source3: TSource3, + source4: TSource4 + ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>; + + /** + * @see _.assign + */ + assign(): LoDashExplicitObjectWrapper<T>; + + /** + * @see _.assign + */ + assign<TResult>(...otherArgs: any[]): LoDashExplicitObjectWrapper<TResult>; + } + + //_.assignWith + interface AssignCustomizer { + (objectValue: any, sourceValue: any, key?: string, object?: {}, source?: {}): any; + } + + interface LoDashStatic { + /** + * This method is like `_.assign` except that it accepts `customizer` which + * is invoked to produce the assigned values. If `customizer` returns `undefined` + * assignment is handled by the method instead. The `customizer` is invoked + * with five arguments: (objValue, srcValue, key, object, source). + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @category Object + * @param {Object} object The destination object. + * @param {...Object} sources The source objects. + * @param {Function} [customizer] The function to customize assigned values. + * @returns {Object} Returns `object`. + * @example + * + * function customizer(objValue, srcValue) { + * return _.isUndefined(objValue) ? srcValue : objValue; + * } + * + * var defaults = _.partialRight(_.assignWith, customizer); + * + * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 }); + * // => { 'a': 1, 'b': 2 } + */ + assignWith<TObject, TSource>( + object: TObject, + source: TSource, + customizer: AssignCustomizer + ): TObject & TSource; + + /** + * @see assignWith + */ + assignWith<TObject, TSource1, TSource2>( + object: TObject, + source1: TSource1, + source2: TSource2, + customizer: AssignCustomizer + ): TObject & TSource1 & TSource2; + + /** + * @see assignWith + */ + assignWith<TObject, TSource1, TSource2, TSource3>( + object: TObject, + source1: TSource1, + source2: TSource2, + source3: TSource3, + customizer: AssignCustomizer + ): TObject & TSource1 & TSource2 & TSource3; + + /** + * @see assignWith + */ + assignWith<TObject, TSource1, TSource2, TSource3, TSource4>( + object: TObject, + source1: TSource1, + source2: TSource2, + source3: TSource3, + source4: TSource4, + customizer: AssignCustomizer + ): TObject & TSource1 & TSource2 & TSource3 & TSource4; + + /** + * @see _.assignWith + */ + assignWith<TObject>(object: TObject): TObject; + + /** + * @see _.assignWith + */ + assignWith<TResult>( + object: any, + ...otherArgs: any[] + ): TResult; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.assignWith + */ + assignWith<TSource>( + source: TSource, + customizer: AssignCustomizer + ): LoDashImplicitObjectWrapper<T & TSource>; + + /** + * @see assignWith + */ + assignWith<TSource1, TSource2>( + source1: TSource1, + source2: TSource2, + customizer: AssignCustomizer + ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2>; + + /** + * @see assignWith + */ + assignWith<TSource1, TSource2, TSource3>( + source1: TSource1, + source2: TSource2, + source3: TSource3, + customizer: AssignCustomizer + ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>; + + /** + * @see assignWith + */ + assignWith<TSource1, TSource2, TSource3, TSource4>( + source1: TSource1, + source2: TSource2, + source3: TSource3, + source4: TSource4, + customizer: AssignCustomizer + ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>; + + /** + * @see _.assignWith + */ + assignWith(): LoDashImplicitObjectWrapper<T>; + + /** + * @see _.assignWith + */ + assignWith<TResult>(...otherArgs: any[]): LoDashImplicitObjectWrapper<TResult>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.assignWith + */ + assignWith<TSource>( + source: TSource, + customizer: AssignCustomizer + ): LoDashExplicitObjectWrapper<T & TSource>; + + /** + * @see assignWith + */ + assignWith<TSource1, TSource2>( + source1: TSource1, + source2: TSource2, + customizer: AssignCustomizer + ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2>; + + /** + * @see assignWith + */ + assignWith<TSource1, TSource2, TSource3>( + source1: TSource1, + source2: TSource2, + source3: TSource3, + customizer: AssignCustomizer + ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>; + + /** + * @see assignWith + */ + assignWith<TSource1, TSource2, TSource3, TSource4>( + source1: TSource1, + source2: TSource2, + source3: TSource3, + source4: TSource4, + customizer: AssignCustomizer + ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>; + + /** + * @see _.assignWith + */ + assignWith(): LoDashExplicitObjectWrapper<T>; + + /** + * @see _.assignWith + */ + assignWith<TResult>(...otherArgs: any[]): LoDashExplicitObjectWrapper<TResult>; + } + + //_.assignIn + interface LoDashStatic { + /** + * This method is like `_.assign` except that it iterates over own and + * inherited source properties. + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @alias extend + * @category Object + * @param {Object} object The destination object. + * @param {...Object} [sources] The source objects. + * @returns {Object} Returns `object`. + * @example + * + * function Foo() { + * this.b = 2; + * } + * + * function Bar() { + * this.d = 4; + * } + * + * Foo.prototype.c = 3; + * Bar.prototype.e = 5; + * + * _.assignIn({ 'a': 1 }, new Foo, new Bar); + * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5 } + */ + assignIn<TObject, TSource>( + object: TObject, + source: TSource + ): TObject & TSource; + + /** + * @see assignIn + */ + assignIn<TObject, TSource1, TSource2>( + object: TObject, + source1: TSource1, + source2: TSource2 + ): TObject & TSource1 & TSource2; + + /** + * @see assignIn + */ + assignIn<TObject, TSource1, TSource2, TSource3>( + object: TObject, + source1: TSource1, + source2: TSource2, + source3: TSource3 + ): TObject & TSource1 & TSource2 & TSource3; + + /** + * @see assignIn + */ + assignIn<TObject, TSource1, TSource2, TSource3, TSource4>( + object: TObject, + source1: TSource1, + source2: TSource2, + source3: TSource3, + source4: TSource4 + ): TObject & TSource1 & TSource2 & TSource3 & TSource4; + + /** + * @see _.assignIn + */ + assignIn<TObject>(object: TObject): TObject; + + /** + * @see _.assignIn + */ + assignIn<TResult>( + object: any, + ...otherArgs: any[] + ): TResult; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.assignIn + */ + assignIn<TSource>( + source: TSource + ): LoDashImplicitObjectWrapper<T & TSource>; + + /** + * @see assignIn + */ + assignIn<TSource1, TSource2>( + source1: TSource1, + source2: TSource2 + ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2>; + + /** + * @see assignIn + */ + assignIn<TSource1, TSource2, TSource3>( + source1: TSource1, + source2: TSource2, + source3: TSource3 + ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>; + + /** + * @see assignIn + */ + assignIn<TSource1, TSource2, TSource3, TSource4>( + source1: TSource1, + source2: TSource2, + source3: TSource3, + source4: TSource4 + ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>; + + /** + * @see _.assignIn + */ + assignIn(): LoDashImplicitObjectWrapper<T>; + + /** + * @see _.assignIn + */ + assignIn<TResult>(...otherArgs: any[]): LoDashImplicitObjectWrapper<TResult>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.assignIn + */ + assignIn<TSource>( + source: TSource + ): LoDashExplicitObjectWrapper<T & TSource>; + + /** + * @see assignIn + */ + assignIn<TSource1, TSource2>( + source1: TSource1, + source2: TSource2 + ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2>; + + /** + * @see assignIn + */ + assignIn<TSource1, TSource2, TSource3>( + source1: TSource1, + source2: TSource2, + source3: TSource3 + ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>; + + /** + * @see assignIn + */ + assignIn<TSource1, TSource2, TSource3, TSource4>( + source1: TSource1, + source2: TSource2, + source3: TSource3, + source4: TSource4 + ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>; + + /** + * @see _.assignIn + */ + assignIn(): LoDashExplicitObjectWrapper<T>; + + /** + * @see _.assignIn + */ + assignIn<TResult>(...otherArgs: any[]): LoDashExplicitObjectWrapper<TResult>; + } + + //_.assignInWith + interface AssignCustomizer { + (objectValue: any, sourceValue: any, key?: string, object?: {}, source?: {}): any; + } + + interface LoDashStatic { + /** + * This method is like `_.assignIn` except that it accepts `customizer` which + * is invoked to produce the assigned values. If `customizer` returns `undefined` + * assignment is handled by the method instead. The `customizer` is invoked + * with five arguments: (objValue, srcValue, key, object, source). + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @alias extendWith + * @category Object + * @param {Object} object The destination object. + * @param {...Object} sources The source objects. + * @param {Function} [customizer] The function to customize assigned values. + * @returns {Object} Returns `object`. + * @example + * + * function customizer(objValue, srcValue) { + * return _.isUndefined(objValue) ? srcValue : objValue; + * } + * + * var defaults = _.partialRight(_.assignInWith, customizer); + * + * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 }); + * // => { 'a': 1, 'b': 2 } + */ + assignInWith<TObject, TSource>( + object: TObject, + source: TSource, + customizer: AssignCustomizer + ): TObject & TSource; + + /** + * @see assignInWith + */ + assignInWith<TObject, TSource1, TSource2>( + object: TObject, + source1: TSource1, + source2: TSource2, + customizer: AssignCustomizer + ): TObject & TSource1 & TSource2; + + /** + * @see assignInWith + */ + assignInWith<TObject, TSource1, TSource2, TSource3>( + object: TObject, + source1: TSource1, + source2: TSource2, + source3: TSource3, + customizer: AssignCustomizer + ): TObject & TSource1 & TSource2 & TSource3; + + /** + * @see assignInWith + */ + assignInWith<TObject, TSource1, TSource2, TSource3, TSource4>( + object: TObject, + source1: TSource1, + source2: TSource2, + source3: TSource3, + source4: TSource4, + customizer: AssignCustomizer + ): TObject & TSource1 & TSource2 & TSource3 & TSource4; + + /** + * @see _.assignInWith + */ + assignInWith<TObject>(object: TObject): TObject; + + /** + * @see _.assignInWith + */ + assignInWith<TResult>( + object: any, + ...otherArgs: any[] + ): TResult; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.assignInWith + */ + assignInWith<TSource>( + source: TSource, + customizer: AssignCustomizer + ): LoDashImplicitObjectWrapper<T & TSource>; + + /** + * @see assignInWith + */ + assignInWith<TSource1, TSource2>( + source1: TSource1, + source2: TSource2, + customizer: AssignCustomizer + ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2>; + + /** + * @see assignInWith + */ + assignInWith<TSource1, TSource2, TSource3>( + source1: TSource1, + source2: TSource2, + source3: TSource3, + customizer: AssignCustomizer + ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>; + + /** + * @see assignInWith + */ + assignInWith<TSource1, TSource2, TSource3, TSource4>( + source1: TSource1, + source2: TSource2, + source3: TSource3, + source4: TSource4, + customizer: AssignCustomizer + ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>; + + /** + * @see _.assignInWith + */ + assignInWith(): LoDashImplicitObjectWrapper<T>; + + /** + * @see _.assignInWith + */ + assignInWith<TResult>(...otherArgs: any[]): LoDashImplicitObjectWrapper<TResult>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.assignInWith + */ + assignInWith<TSource>( + source: TSource, + customizer: AssignCustomizer + ): LoDashExplicitObjectWrapper<T & TSource>; + + /** + * @see assignInWith + */ + assignInWith<TSource1, TSource2>( + source1: TSource1, + source2: TSource2, + customizer: AssignCustomizer + ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2>; + + /** + * @see assignInWith + */ + assignInWith<TSource1, TSource2, TSource3>( + source1: TSource1, + source2: TSource2, + source3: TSource3, + customizer: AssignCustomizer + ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>; + + /** + * @see assignInWith + */ + assignInWith<TSource1, TSource2, TSource3, TSource4>( + source1: TSource1, + source2: TSource2, + source3: TSource3, + source4: TSource4, + customizer: AssignCustomizer + ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>; + + /** + * @see _.assignInWith + */ + assignInWith(): LoDashExplicitObjectWrapper<T>; + + /** + * @see _.assignInWith + */ + assignInWith<TResult>(...otherArgs: any[]): LoDashExplicitObjectWrapper<TResult>; + } + + //_.create + interface LoDashStatic { + /** + * Creates an object that inherits from the given prototype object. If a properties object is provided its own + * enumerable properties are assigned to the created object. + * + * @param prototype The object to inherit from. + * @param properties The properties to assign to the object. + * @return Returns the new object. + */ + create<T extends Object, U extends Object>( + prototype: T, + properties?: U + ): T & U; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.create + */ + create<U extends Object>(properties?: U): LoDashImplicitObjectWrapper<T & U>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.create + */ + create<U extends Object>(properties?: U): LoDashExplicitObjectWrapper<T & U>; + } + + + //_.defaults + interface LoDashStatic { + /** + * Assigns own enumerable properties of source object(s) to the destination object for all destination + * properties that resolve to undefined. Once a property is set, additional values of the same property are + * ignored. + * + * Note: This method mutates object. + * + * @param object The destination object. + * @param sources The source objects. + * @return The destination object. + */ + defaults<TObject, TSource>( + object: TObject, + source: TSource + ): TSource & TObject; + + /** + * @see _.defaults + */ + defaults<TObject, TSource1, TSource2>( + object: TObject, + source1: TSource1, + source2: TSource2 + ): TSource2 & TSource1 & TObject; + + /** + * @see _.defaults + */ + defaults<TObject, TSource1, TSource2, TSource3>( + object: TObject, + source1: TSource1, + source2: TSource2, + source3: TSource3 + ): TSource3 & TSource2 & TSource1 & TObject; + + /** + * @see _.defaults + */ + defaults<TObject, TSource1, TSource2, TSource3, TSource4>( + object: TObject, + source1: TSource1, + source2: TSource2, + source3: TSource3, + source4: TSource4 + ): TSource4 & TSource3 & TSource2 & TSource1 & TObject; + + /** + * @see _.defaults + */ + defaults<TObject>(object: TObject): TObject; + + /** + * @see _.defaults + */ + defaults<TResult>( + object: any, + ...sources: any[] + ): TResult; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.defaults + */ + defaults<TSource>( + source: TSource + ): LoDashImplicitObjectWrapper<TSource & T>; + + /** + * @see _.defaults + */ + defaults<TSource1, TSource2>( + source1: TSource1, + source2: TSource2 + ): LoDashImplicitObjectWrapper<TSource2 & TSource1 & T>; + + /** + * @see _.defaults + */ + defaults<TSource1, TSource2, TSource3>( + source1: TSource1, + source2: TSource2, + source3: TSource3 + ): LoDashImplicitObjectWrapper<TSource3 & TSource2 & TSource1 & T>; + + /** + * @see _.defaults + */ + defaults<TSource1, TSource2, TSource3, TSource4>( + source1: TSource1, + source2: TSource2, + source3: TSource3, + source4: TSource4 + ): LoDashImplicitObjectWrapper<TSource4 & TSource3 & TSource2 & TSource1 & T>; + + /** + * @see _.defaults + */ + defaults(): LoDashImplicitObjectWrapper<T>; + + /** + * @see _.defaults + */ + defaults<TResult>(...sources: any[]): LoDashImplicitObjectWrapper<TResult>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.defaults + */ + defaults<TSource>( + source: TSource + ): LoDashExplicitObjectWrapper<TSource & T>; + + /** + * @see _.defaults + */ + defaults<TSource1, TSource2>( + source1: TSource1, + source2: TSource2 + ): LoDashExplicitObjectWrapper<TSource2 & TSource1 & T>; + + /** + * @see _.defaults + */ + defaults<TSource1, TSource2, TSource3>( + source1: TSource1, + source2: TSource2, + source3: TSource3 + ): LoDashExplicitObjectWrapper<TSource3 & TSource2 & TSource1 & T>; + + /** + * @see _.defaults + */ + defaults<TSource1, TSource2, TSource3, TSource4>( + source1: TSource1, + source2: TSource2, + source3: TSource3, + source4: TSource4 + ): LoDashExplicitObjectWrapper<TSource4 & TSource3 & TSource2 & TSource1 & T>; + + /** + * @see _.defaults + */ + defaults(): LoDashExplicitObjectWrapper<T>; + + /** + * @see _.defaults + */ + defaults<TResult>(...sources: any[]): LoDashExplicitObjectWrapper<TResult>; + } + + //_.defaultsDeep + interface LoDashStatic { + /** + * This method is like _.defaults except that it recursively assigns default properties. + * @param object The destination object. + * @param sources The source objects. + * @return Returns object. + **/ + defaultsDeep<T, TResult>( + object: T, + ...sources: any[]): TResult; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.defaultsDeep + **/ + defaultsDeep<TResult>(...sources: any[]): LoDashImplicitObjectWrapper<TResult> + } + + // _.extend + interface LoDashStatic { + /** + * @see _.assignIn + */ + extend<TObject, TSource>( + object: TObject, + source: TSource + ): TObject & TSource; + + /** + * @see _.assignIn + */ + extend<TObject, TSource1, TSource2>( + object: TObject, + source1: TSource1, + source2: TSource2 + ): TObject & TSource1 & TSource2; + + /** + * @see _.assignIn + */ + extend<TObject, TSource1, TSource2, TSource3>( + object: TObject, + source1: TSource1, + source2: TSource2, + source3: TSource3 + ): TObject & TSource1 & TSource2 & TSource3; + + /** + * @see _.assignIn + */ + extend<TObject, TSource1, TSource2, TSource3, TSource4>( + object: TObject, + source1: TSource1, + source2: TSource2, + source3: TSource3, + source4: TSource4 + ): TObject & TSource1 & TSource2 & TSource3 & TSource4; + + /** + * @see _.assignIn + */ + extend<TObject>(object: TObject): TObject; + + /** + * @see _.assignIn + */ + extend<TResult>( + object: any, + ...otherArgs: any[] + ): TResult; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.assignIn + */ + extend<TSource>( + source: TSource + ): LoDashImplicitObjectWrapper<T & TSource>; + + /** + * @see _.assignIn + */ + extend<TSource1, TSource2>( + source1: TSource1, + source2: TSource2 + ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2>; + + /** + * @see _.assignIn + */ + extend<TSource1, TSource2, TSource3>( + source1: TSource1, + source2: TSource2, + source3: TSource3 + ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>; + + /** + * @see _.assignIn + */ + extend<TSource1, TSource2, TSource3, TSource4>( + source1: TSource1, + source2: TSource2, + source3: TSource3, + source4: TSource4 + ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>; + + /** + * @see _.assignIn + */ + extend(): LoDashImplicitObjectWrapper<T>; + + /** + * @see _.assignIn + */ + extend<TResult>(...otherArgs: any[]): LoDashImplicitObjectWrapper<TResult>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.assignIn + */ + extend<TSource>( + source: TSource + ): LoDashExplicitObjectWrapper<T & TSource>; + + /** + * @see _.assignIn + */ + extend<TSource1, TSource2>( + source1: TSource1, + source2: TSource2 + ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2>; + + /** + * @see _.assignIn + */ + extend<TSource1, TSource2, TSource3>( + source1: TSource1, + source2: TSource2, + source3: TSource3 + ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>; + + /** + * @see _.assignIn + */ + extend<TSource1, TSource2, TSource3, TSource4>( + source1: TSource1, + source2: TSource2, + source3: TSource3, + source4: TSource4 + ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>; + + /** + * @see _.assignIn + */ + extend(): LoDashExplicitObjectWrapper<T>; + + /** + * @see _.assignIn + */ + extend<TResult>(...otherArgs: any[]): LoDashExplicitObjectWrapper<TResult>; + } + + interface LoDashStatic { + /** + * @see _.assignInWith + */ + extendWith<TObject, TSource>( + object: TObject, + source: TSource, + customizer: AssignCustomizer + ): TObject & TSource; + + /** + * @see _.assignInWith + */ + extendWith<TObject, TSource1, TSource2>( + object: TObject, + source1: TSource1, + source2: TSource2, + customizer: AssignCustomizer + ): TObject & TSource1 & TSource2; + + /** + * @see _.assignInWith + */ + extendWith<TObject, TSource1, TSource2, TSource3>( + object: TObject, + source1: TSource1, + source2: TSource2, + source3: TSource3, + customizer: AssignCustomizer + ): TObject & TSource1 & TSource2 & TSource3; + + /** + * @see _.assignInWith + */ + extendWith<TObject, TSource1, TSource2, TSource3, TSource4>( + object: TObject, + source1: TSource1, + source2: TSource2, + source3: TSource3, + source4: TSource4, + customizer: AssignCustomizer + ): TObject & TSource1 & TSource2 & TSource3 & TSource4; + + /** + * @see _.assignInWith + */ + extendWith<TObject>(object: TObject): TObject; + + /** + * @see _.assignInWith + */ + extendWith<TResult>( + object: any, + ...otherArgs: any[] + ): TResult; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.assignInWith + */ + extendWith<TSource>( + source: TSource, + customizer: AssignCustomizer + ): LoDashImplicitObjectWrapper<T & TSource>; + + /** + * @see _.assignInWith + */ + extendWith<TSource1, TSource2>( + source1: TSource1, + source2: TSource2, + customizer: AssignCustomizer + ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2>; + + /** + * @see _.assignInWith + */ + extendWith<TSource1, TSource2, TSource3>( + source1: TSource1, + source2: TSource2, + source3: TSource3, + customizer: AssignCustomizer + ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>; + + /** + * @see _.assignInWith + */ + extendWith<TSource1, TSource2, TSource3, TSource4>( + source1: TSource1, + source2: TSource2, + source3: TSource3, + source4: TSource4, + customizer: AssignCustomizer + ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>; + + /** + * @see _.assignInWith + */ + extendWith(): LoDashImplicitObjectWrapper<T>; + + /** + * @see _.assignInWith + */ + extendWith<TResult>(...otherArgs: any[]): LoDashImplicitObjectWrapper<TResult>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.assignInWith + */ + extendWith<TSource>( + source: TSource, + customizer: AssignCustomizer + ): LoDashExplicitObjectWrapper<T & TSource>; + + /** + * @see _.assignInWith + */ + extendWith<TSource1, TSource2>( + source1: TSource1, + source2: TSource2, + customizer: AssignCustomizer + ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2>; + + /** + * @see _.assignInWith + */ + extendWith<TSource1, TSource2, TSource3>( + source1: TSource1, + source2: TSource2, + source3: TSource3, + customizer: AssignCustomizer + ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>; + + /** + * @see _.assignInWith + */ + extendWith<TSource1, TSource2, TSource3, TSource4>( + source1: TSource1, + source2: TSource2, + source3: TSource3, + source4: TSource4, + customizer: AssignCustomizer + ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>; + + /** + * @see _.assignInWith + */ + extendWith(): LoDashExplicitObjectWrapper<T>; + + /** + * @see _.assignInWith + */ + extendWith<TResult>(...otherArgs: any[]): LoDashExplicitObjectWrapper<TResult>; + } + + //_.findKey + interface LoDashStatic { + /** + * This method is like _.find except that it returns the key of the first element predicate returns truthy for + * instead of the element itself. + * + * If a property name is provided for predicate the created _.property style callback returns the property + * value of the given element. + * + * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for + * elements that have a matching property value, else false. + * + * If an object is provided for predicate the created _.matches style callback returns true for elements that + * have the properties of the given object, else false. + * + * @param object The object to search. + * @param predicate The function invoked per iteration. + * @param thisArg The this binding of predicate. + * @return Returns the key of the matched element, else undefined. + */ + findKey<TValues, TObject>( + object: TObject, + predicate?: DictionaryIterator<TValues, boolean> + ): string; + + /** + * @see _.findKey + */ + findKey<TObject>( + object: TObject, + predicate?: ObjectIterator<any, boolean> + ): string; + + /** + * @see _.findKey + */ + findKey<TObject>( + object: TObject, + predicate?: string + ): string; + + /** + * @see _.findKey + */ + findKey<TWhere extends Dictionary<any>, TObject>( + object: TObject, + predicate?: TWhere + ): string; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.findKey + */ + findKey<TValues>( + predicate?: DictionaryIterator<TValues, boolean> + ): string; + + /** + * @see _.findKey + */ + findKey( + predicate?: ObjectIterator<any, boolean> + ): string; + + /** + * @see _.findKey + */ + findKey( + predicate?: string + ): string; + + /** + * @see _.findKey + */ + findKey<TWhere extends Dictionary<any>>( + predicate?: TWhere + ): string; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.findKey + */ + findKey<TValues>( + predicate?: DictionaryIterator<TValues, boolean> + ): LoDashExplicitWrapper<string>; + + /** + * @see _.findKey + */ + findKey( + predicate?: ObjectIterator<any, boolean> + ): LoDashExplicitWrapper<string>; + + /** + * @see _.findKey + */ + findKey( + predicate?: string + ): LoDashExplicitWrapper<string>; + + /** + * @see _.findKey + */ + findKey<TWhere extends Dictionary<any>>( + predicate?: TWhere + ): LoDashExplicitWrapper<string>; + } + + //_.findLastKey + interface LoDashStatic { + /** + * This method is like _.findKey except that it iterates over elements of a collection in the opposite order. + * + * If a property name is provided for predicate the created _.property style callback returns the property + * value of the given element. + * + * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for + * elements that have a matching property value, else false. + * + * If an object is provided for predicate the created _.matches style callback returns true for elements that + * have the properties of the given object, else false. + * + * @param object The object to search. + * @param predicate The function invoked per iteration. + * @param thisArg The this binding of predicate. + * @return Returns the key of the matched element, else undefined. + */ + findLastKey<TValues, TObject>( + object: TObject, + predicate?: DictionaryIterator<TValues, boolean> + ): string; + + /** + * @see _.findLastKey + */ + findLastKey<TObject>( + object: TObject, + predicate?: ObjectIterator<any, boolean> + ): string; + + /** + * @see _.findLastKey + */ + findLastKey<TObject>( + object: TObject, + predicate?: string + ): string; + + /** + * @see _.findLastKey + */ + findLastKey<TWhere extends Dictionary<any>, TObject>( + object: TObject, + predicate?: TWhere + ): string; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.findLastKey + */ + findLastKey<TValues>( + predicate?: DictionaryIterator<TValues, boolean> + ): string; + + /** + * @see _.findLastKey + */ + findLastKey( + predicate?: ObjectIterator<any, boolean> + ): string; + + /** + * @see _.findLastKey + */ + findLastKey( + predicate?: string + ): string; + + /** + * @see _.findLastKey + */ + findLastKey<TWhere extends Dictionary<any>>( + predicate?: TWhere + ): string; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.findLastKey + */ + findLastKey<TValues>( + predicate?: DictionaryIterator<TValues, boolean> + ): LoDashExplicitWrapper<string>; + + /** + * @see _.findLastKey + */ + findLastKey( + predicate?: ObjectIterator<any, boolean> + ): LoDashExplicitWrapper<string>; + + /** + * @see _.findLastKey + */ + findLastKey( + predicate?: string + ): LoDashExplicitWrapper<string>; + + /** + * @see _.findLastKey + */ + findLastKey<TWhere extends Dictionary<any>>( + predicate?: TWhere + ): LoDashExplicitWrapper<string>; + } + + //_.forIn + interface LoDashStatic { + /** + * Iterates over own and inherited enumerable properties of an object invoking iteratee for each property. The + * iteratee is bound to thisArg and invoked with three arguments: (value, key, object). Iteratee functions may + * exit iteration early by explicitly returning false. + * + * @param object The object to iterate over. + * @param iteratee The function invoked per iteration. + * @param thisArg The this binding of iteratee. + * @return Returns object. + */ + forIn<T>( + object: Dictionary<T>, + iteratee?: DictionaryIterator<T, any> + ): Dictionary<T>; + + /** + * @see _.forIn + */ + forIn<T extends {}>( + object: T, + iteratee?: ObjectIterator<any, any> + ): T; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.forIn + */ + forIn<TValue>( + iteratee?: DictionaryIterator<TValue, any> + ): _.LoDashImplicitObjectWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.forIn + */ + forIn<TValue>( + iteratee?: DictionaryIterator<TValue, any> + ): _.LoDashExplicitObjectWrapper<T>; + } + + //_.forInRight + interface LoDashStatic { + /** + * This method is like _.forIn except that it iterates over properties of object in the opposite order. + * + * @param object The object to iterate over. + * @param iteratee The function invoked per iteration. + * @param thisArg The this binding of iteratee. + * @return Returns object. + */ + forInRight<T>( + object: Dictionary<T>, + iteratee?: DictionaryIterator<T, any> + ): Dictionary<T>; + + /** + * @see _.forInRight + */ + forInRight<T extends {}>( + object: T, + iteratee?: ObjectIterator<any, any> + ): T; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.forInRight + */ + forInRight<TValue>( + iteratee?: DictionaryIterator<TValue, any> + ): _.LoDashImplicitObjectWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.forInRight + */ + forInRight<TValue>( + iteratee?: DictionaryIterator<TValue, any> + ): _.LoDashExplicitObjectWrapper<T>; + } + + //_.forOwn + interface LoDashStatic { + /** + * Iterates over own enumerable properties of an object invoking iteratee for each property. The iteratee is + * bound to thisArg and invoked with three arguments: (value, key, object). Iteratee functions may exit + * iteration early by explicitly returning false. + * + * @param object The object to iterate over. + * @param iteratee The function invoked per iteration. + * @param thisArg The this binding of iteratee. + * @return Returns object. + */ + forOwn<T>( + object: Dictionary<T>, + iteratee?: DictionaryIterator<T, any> + ): Dictionary<T>; + + /** + * @see _.forOwn + */ + forOwn<T extends {}>( + object: T, + iteratee?: ObjectIterator<any, any> + ): T; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.forOwn + */ + forOwn<TValue>( + iteratee?: DictionaryIterator<TValue, any> + ): _.LoDashImplicitObjectWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.forOwn + */ + forOwn<TValue>( + iteratee?: DictionaryIterator<TValue, any> + ): _.LoDashExplicitObjectWrapper<T>; + } + + //_.forOwnRight + interface LoDashStatic { + /** + * This method is like _.forOwn except that it iterates over properties of object in the opposite order. + * + * @param object The object to iterate over. + * @param iteratee The function invoked per iteration. + * @param thisArg The this binding of iteratee. + * @return Returns object. + */ + forOwnRight<T>( + object: Dictionary<T>, + iteratee?: DictionaryIterator<T, any> + ): Dictionary<T>; + + /** + * @see _.forOwnRight + */ + forOwnRight<T extends {}>( + object: T, + iteratee?: ObjectIterator<any, any> + ): T; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.forOwnRight + */ + forOwnRight<TValue>( + iteratee?: DictionaryIterator<TValue, any> + ): _.LoDashImplicitObjectWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.forOwnRight + */ + forOwnRight<TValue>( + iteratee?: DictionaryIterator<TValue, any> + ): _.LoDashExplicitObjectWrapper<T>; + } + + //_.functions + interface LoDashStatic { + /** + * Creates an array of function property names from own enumerable properties + * of `object`. + * + * @static + * @memberOf _ + * @category Object + * @param {Object} object The object to inspect. + * @returns {Array} Returns the new array of property names. + * @example + * + * function Foo() { + * this.a = _.constant('a'); + * this.b = _.constant('b'); + * } + * + * Foo.prototype.c = _.constant('c'); + * + * _.functions(new Foo); + * // => ['a', 'b'] + */ + functions<T extends {}>(object: any): string[]; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.functions + */ + functions(): _.LoDashImplicitArrayWrapper<string>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.functions + */ + functions(): _.LoDashExplicitArrayWrapper<string>; + } + + //_.functionsIn + interface LoDashStatic { + /** + * Creates an array of function property names from own and inherited + * enumerable properties of `object`. + * + * @static + * @memberOf _ + * @category Object + * @param {Object} object The object to inspect. + * @returns {Array} Returns the new array of property names. + * @example + * + * function Foo() { + * this.a = _.constant('a'); + * this.b = _.constant('b'); + * } + * + * Foo.prototype.c = _.constant('c'); + * + * _.functionsIn(new Foo); + * // => ['a', 'b', 'c'] + */ + functionsIn<T extends {}>(object: any): string[]; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.functionsIn + */ + functionsIn(): _.LoDashImplicitArrayWrapper<string>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.functionsIn + */ + functionsIn(): _.LoDashExplicitArrayWrapper<string>; + } + + //_.get + interface LoDashStatic { + /** + * Gets the property value at path of object. If the resolved value is undefined the defaultValue is used + * in its place. + * + * @param object The object to query. + * @param path The path of the property to get. + * @param defaultValue The value returned if the resolved value is undefined. + * @return Returns the resolved value. + */ + get<TObject, TResult>( + object: TObject, + path: StringRepresentable|StringRepresentable[], + defaultValue?: TResult + ): TResult; + + /** + * @see _.get + */ + get<TResult>( + object: any, + path: StringRepresentable|StringRepresentable[], + defaultValue?: TResult + ): TResult; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.get + */ + get<TResult>( + path: StringRepresentable|StringRepresentable[], + defaultValue?: TResult + ): TResult; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.get + */ + get<TResult>( + path: StringRepresentable|StringRepresentable[], + defaultValue?: TResult + ): TResult; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.get + */ + get<TResult>( + path: StringRepresentable|StringRepresentable[], + defaultValue?: TResult + ): TResult; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.get + */ + get<TResultWrapper>( + path: StringRepresentable|StringRepresentable[], + defaultValue?: any + ): TResultWrapper; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.get + */ + get<TResultWrapper>( + path: StringRepresentable|StringRepresentable[], + defaultValue?: any + ): TResultWrapper; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.get + */ + get<TResultWrapper>( + path: StringRepresentable|StringRepresentable[], + defaultValue?: any + ): TResultWrapper; + } + + //_.has + interface LoDashStatic { + /** + * Checks if `path` is a direct property of `object`. + * + * @static + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @param {Array|string} path The path to check. + * @returns {boolean} Returns `true` if `path` exists, else `false`. + * @example + * + * var object = { 'a': { 'b': { 'c': 3 } } }; + * var other = _.create({ 'a': _.create({ 'b': _.create({ 'c': 3 }) }) }); + * + * _.has(object, 'a'); + * // => true + * + * _.has(object, 'a.b.c'); + * // => true + * + * _.has(object, ['a', 'b', 'c']); + * // => true + * + * _.has(other, 'a'); + * // => false + */ + has<T extends {}>( + object: T, + path: StringRepresentable|StringRepresentable[] + ): boolean; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.has + */ + has(path: StringRepresentable|StringRepresentable[]): boolean; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.has + */ + has(path: StringRepresentable|StringRepresentable[]): LoDashExplicitWrapper<boolean>; + } + + //_.hasIn + interface LoDashStatic { + /** + * Checks if `path` is a direct or inherited property of `object`. + * + * @static + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @param {Array|string} path The path to check. + * @returns {boolean} Returns `true` if `path` exists, else `false`. + * @example + * + * var object = _.create({ 'a': _.create({ 'b': _.create({ 'c': 3 }) }) }); + * + * _.hasIn(object, 'a'); + * // => true + * + * _.hasIn(object, 'a.b.c'); + * // => true + * + * _.hasIn(object, ['a', 'b', 'c']); + * // => true + * + * _.hasIn(object, 'b'); + * // => false + */ + hasIn<T extends {}>( + object: T, + path: StringRepresentable|StringRepresentable[] + ): boolean; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.hasIn + */ + hasIn(path: StringRepresentable|StringRepresentable[]): boolean; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.hasIn + */ + hasIn(path: StringRepresentable|StringRepresentable[]): LoDashExplicitWrapper<boolean>; + } + + //_.invert + interface LoDashStatic { + /** + * Creates an object composed of the inverted keys and values of object. If object contains duplicate values, + * subsequent values overwrite property assignments of previous values unless multiValue is true. + * + * @param object The object to invert. + * @param multiValue Allow multiple values per key. + * @return Returns the new inverted object. + */ + invert<T extends {}, TResult extends {}>( + object: T, + multiValue?: boolean + ): TResult; + + /** + * @see _.invert + */ + invert<TResult extends {}>( + object: Object, + multiValue?: boolean + ): TResult; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.invert + */ + invert<TResult extends {}>(multiValue?: boolean): LoDashImplicitObjectWrapper<TResult>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.invert + */ + invert<TResult extends {}>(multiValue?: boolean): LoDashExplicitObjectWrapper<TResult>; + } + + //_.inverBy + interface InvertByIterator<T> { + (value: T): any; + } + + interface LoDashStatic { + /** + * This method is like _.invert except that the inverted object is generated from the results of running each + * element of object through iteratee. The corresponding inverted value of each inverted key is an array of + * keys responsible for generating the inverted value. The iteratee is invoked with one argument: (value). + * + * @param object The object to invert. + * @param interatee The iteratee invoked per element. + * @return Returns the new inverted object. + */ + invertBy( + object: Object, + interatee?: InvertByIterator<any>|string + ): Dictionary<string[]>; + + /** + * @see _.invertBy + */ + invertBy<T>( + object: _.Dictionary<T>|_.NumericDictionary<T>, + interatee?: InvertByIterator<T>|string + ): Dictionary<string[]>; + + /** + * @see _.invertBy + */ + invertBy<W>( + object: Object, + interatee?: W + ): Dictionary<string[]>; + + /** + * @see _.invertBy + */ + invertBy<T, W>( + object: _.Dictionary<T>, + interatee?: W + ): Dictionary<string[]>; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.invertBy + */ + invertBy( + interatee?: InvertByIterator<any> + ): LoDashImplicitObjectWrapper<Dictionary<string[]>>; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.invertBy + */ + invertBy( + interatee?: InvertByIterator<T>|string + ): LoDashImplicitObjectWrapper<Dictionary<string[]>>; + + /** + * @see _.invertBy + */ + invertBy<W>( + interatee?: W + ): LoDashImplicitObjectWrapper<Dictionary<string[]>>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.invertBy + */ + invertBy( + interatee?: InvertByIterator<any>|string + ): LoDashImplicitObjectWrapper<Dictionary<string[]>>; + + /** + * @see _.invertBy + */ + invertBy<W>( + interatee?: W + ): LoDashImplicitObjectWrapper<Dictionary<string[]>>; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.invertBy + */ + invertBy( + interatee?: InvertByIterator<any> + ): LoDashExplicitObjectWrapper<Dictionary<string[]>>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.invertBy + */ + invertBy( + interatee?: InvertByIterator<T>|string + ): LoDashExplicitObjectWrapper<Dictionary<string[]>>; + + /** + * @see _.invertBy + */ + invertBy<W>( + interatee?: W + ): LoDashExplicitObjectWrapper<Dictionary<string[]>>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.invertBy + */ + invertBy( + interatee?: InvertByIterator<any>|string + ): LoDashExplicitObjectWrapper<Dictionary<string[]>>; + + /** + * @see _.invertBy + */ + invertBy<W>( + interatee?: W + ): LoDashExplicitObjectWrapper<Dictionary<string[]>>; + } + + //_.keys + interface LoDashStatic { + /** + * Creates an array of the own enumerable property names of object. + * + * Note: Non-object values are coerced to objects. See the ES spec for more details. + * + * @param object The object to query. + * @return Returns the array of property names. + */ + keys(object?: any): string[]; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.keys + */ + keys(): LoDashImplicitArrayWrapper<string>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.keys + */ + keys(): LoDashExplicitArrayWrapper<string>; + } + + //_.keysIn + interface LoDashStatic { + /** + * Creates an array of the own and inherited enumerable property names of object. + * + * Note: Non-object values are coerced to objects. + * + * @param object The object to query. + * @return An array of property names. + */ + keysIn(object?: any): string[]; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.keysIn + */ + keysIn(): LoDashImplicitArrayWrapper<string>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.keysIn + */ + keysIn(): LoDashExplicitArrayWrapper<string>; + } + + //_.mapKeys + interface LoDashStatic { + /** + * The opposite of _.mapValues; this method creates an object with the same values as object and keys generated + * by running each own enumerable property of object through iteratee. + * + * @param object The object to iterate over. + * @param iteratee The function invoked per iteration. + * @param thisArg The this binding of iteratee. + * @return Returns the new mapped object. + */ + mapKeys<T, TKey>( + object: List<T>, + iteratee?: ListIterator<T, TKey> + ): Dictionary<T>; + + /** + * @see _.mapKeys + */ + mapKeys<T, TKey>( + object: Dictionary<T>, + iteratee?: DictionaryIterator<T, TKey> + ): Dictionary<T>; + + /** + * @see _.mapKeys + */ + mapKeys<T, TObject extends {}>( + object: List<T>|Dictionary<T>, + iteratee?: TObject + ): Dictionary<T>; + + /** + * @see _.mapKeys + */ + mapKeys<T>( + object: List<T>|Dictionary<T>, + iteratee?: string + ): Dictionary<T>; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.mapKeys + */ + mapKeys<TKey>( + iteratee?: ListIterator<T, TKey> + ): LoDashImplicitObjectWrapper<Dictionary<T>>; + + /** + * @see _.mapKeys + */ + mapKeys<TObject extends {}>( + iteratee?: TObject + ): LoDashImplicitObjectWrapper<Dictionary<T>>; + + /** + * @see _.mapKeys + */ + mapKeys( + iteratee?: string + ): LoDashImplicitObjectWrapper<Dictionary<T>>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.mapKeys + */ + mapKeys<TResult, TKey>( + iteratee?: ListIterator<TResult, TKey>|DictionaryIterator<TResult, TKey> + ): LoDashImplicitObjectWrapper<Dictionary<TResult>>; + + /** + * @see _.mapKeys + */ + mapKeys<TResult, TObject extends {}>( + iteratee?: TObject + ): LoDashImplicitObjectWrapper<Dictionary<TResult>>; + + /** + * @see _.mapKeys + */ + mapKeys<TResult>( + iteratee?: string + ): LoDashImplicitObjectWrapper<Dictionary<TResult>>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.mapKeys + */ + mapKeys<TKey>( + iteratee?: ListIterator<T, TKey> + ): LoDashExplicitObjectWrapper<Dictionary<T>>; + + /** + * @see _.mapKeys + */ + mapKeys<TObject extends {}>( + iteratee?: TObject + ): LoDashExplicitObjectWrapper<Dictionary<T>>; + + /** + * @see _.mapKeys + */ + mapKeys( + iteratee?: string + ): LoDashExplicitObjectWrapper<Dictionary<T>>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.mapKeys + */ + mapKeys<TResult, TKey>( + iteratee?: ListIterator<TResult, TKey>|DictionaryIterator<TResult, TKey> + ): LoDashExplicitObjectWrapper<Dictionary<TResult>>; + + /** + * @see _.mapKeys + */ + mapKeys<TResult, TObject extends {}>( + iteratee?: TObject + ): LoDashExplicitObjectWrapper<Dictionary<TResult>>; + + /** + * @see _.mapKeys + */ + mapKeys<TResult>( + iteratee?: string + ): LoDashExplicitObjectWrapper<Dictionary<TResult>>; + } + + //_.mapValues + interface LoDashStatic { + /** + * Creates an object with the same keys as object and values generated by running each own + * enumerable property of object through iteratee. The iteratee function is bound to thisArg + * and invoked with three arguments: (value, key, object). + * + * If a property name is provided iteratee the created "_.property" style callback returns + * the property value of the given element. + * + * If a value is also provided for thisArg the creted "_.matchesProperty" style callback returns + * true for elements that have a matching property value, else false;. + * + * If an object is provided for iteratee the created "_.matches" style callback returns true + * for elements that have the properties of the given object, else false. + * + * @param {Object} object The object to iterate over. + * @param {Function|Object|string} [iteratee=_.identity] The function invoked per iteration. + * @param {Object} [thisArg] The `this` binding of `iteratee`. + * @return {Object} Returns the new mapped object. + */ + mapValues<T, TResult>(obj: Dictionary<T>, callback: ObjectIterator<T, TResult>): Dictionary<TResult>; + mapValues<T>(obj: Dictionary<T>, where: Dictionary<T>): Dictionary<boolean>; + mapValues<T, TMapped>(obj: T, pluck: string): TMapped; + mapValues<T>(obj: T, callback: ObjectIterator<any, any>): T; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.mapValues + * TValue is the type of the property values of T. + * TResult is the type output by the ObjectIterator function + */ + mapValues<TValue, TResult>(callback: ObjectIterator<TValue, TResult>): LoDashImplicitObjectWrapper<Dictionary<TResult>>; + + /** + * @see _.mapValues + * TResult is the type of the property specified by pluck. + * T should be a Dictionary<Dictionary<TResult>> + */ + mapValues<TResult>(pluck: string): LoDashImplicitObjectWrapper<Dictionary<TResult>>; + + /** + * @see _.mapValues + * TResult is the type of the properties of each object in the values of T + * T should be a Dictionary<Dictionary<TResult>> + */ + mapValues<TResult>(where: Dictionary<TResult>): LoDashImplicitArrayWrapper<boolean>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.mapValues + * TValue is the type of the property values of T. + * TResult is the type output by the ObjectIterator function + */ + mapValues<TValue, TResult>(callback: ObjectIterator<TValue, TResult>): LoDashExplicitObjectWrapper<Dictionary<TResult>>; + + /** + * @see _.mapValues + * TResult is the type of the property specified by pluck. + * T should be a Dictionary<Dictionary<TResult>> + */ + mapValues<TResult>(pluck: string): LoDashExplicitObjectWrapper<Dictionary<TResult>>; + + /** + * @see _.mapValues + * TResult is the type of the properties of each object in the values of T + * T should be a Dictionary<Dictionary<TResult>> + */ + mapValues<TResult>(where: Dictionary<TResult>): LoDashExplicitObjectWrapper<boolean>; + } + + //_.merge + interface LoDashStatic { + /** + * Recursively merges own and inherited enumerable properties of source + * objects into the destination object, skipping source properties that resolve + * to `undefined`. Array and plain object properties are merged recursively. + * Other objects and value types are overridden by assignment. Source objects + * are applied from left to right. Subsequent sources overwrite property + * assignments of previous sources. + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @category Object + * @param {Object} object The destination object. + * @param {...Object} [sources] The source objects. + * @returns {Object} Returns `object`. + * @example + * + * var users = { + * 'data': [{ 'user': 'barney' }, { 'user': 'fred' }] + * }; + * + * var ages = { + * 'data': [{ 'age': 36 }, { 'age': 40 }] + * }; + * + * _.merge(users, ages); + * // => { 'data': [{ 'user': 'barney', 'age': 36 }, { 'user': 'fred', 'age': 40 }] } + */ + merge<TObject, TSource>( + object: TObject, + source: TSource + ): TObject & TSource; + + /** + * @see _.merge + */ + merge<TObject, TSource1, TSource2>( + object: TObject, + source1: TSource1, + source2: TSource2 + ): TObject & TSource1 & TSource2; + + /** + * @see _.merge + */ + merge<TObject, TSource1, TSource2, TSource3>( + object: TObject, + source1: TSource1, + source2: TSource2, + source3: TSource3 + ): TObject & TSource1 & TSource2 & TSource3; + + /** + * @see _.merge + */ + merge<TObject, TSource1, TSource2, TSource3, TSource4>( + object: TObject, + source1: TSource1, + source2: TSource2, + source3: TSource3, + source4: TSource4 + ): TObject & TSource1 & TSource2 & TSource3 & TSource4; + + /** + * @see _.merge + */ + merge<TResult>( + object: any, + ...otherArgs: any[] + ): TResult; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.merge + */ + merge<TSource>( + source: TSource + ): LoDashImplicitObjectWrapper<T & TSource>; + + /** + * @see _.merge + */ + merge<TSource1, TSource2>( + source1: TSource1, + source2: TSource2 + ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2>; + + /** + * @see _.merge + */ + merge<TSource1, TSource2, TSource3>( + source1: TSource1, + source2: TSource2, + source3: TSource3 + ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>; + + /** + * @see _.merge + */ + merge<TSource1, TSource2, TSource3, TSource4>( + source1: TSource1, + source2: TSource2, + source3: TSource3, + source4: TSource4 + ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>; + + /** + * @see _.merge + */ + merge<TResult>( + ...otherArgs: any[] + ): LoDashImplicitObjectWrapper<TResult>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.merge + */ + merge<TSource>( + source: TSource + ): LoDashExplicitObjectWrapper<T & TSource>; + + /** + * @see _.merge + */ + merge<TSource1, TSource2>( + source1: TSource1, + source2: TSource2 + ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2>; + + /** + * @see _.merge + */ + merge<TSource1, TSource2, TSource3>( + source1: TSource1, + source2: TSource2, + source3: TSource3 + ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>; + + /** + * @see _.merge + */ + merge<TSource1, TSource2, TSource3, TSource4>( + ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>; + + /** + * @see _.merge + */ + merge<TResult>( + ...otherArgs: any[] + ): LoDashExplicitObjectWrapper<TResult>; + } + + //_.mergeWith + interface MergeWithCustomizer { + (value: any, srcValue: any, key?: string, object?: Object, source?: Object): any; + } + + interface LoDashStatic { + /** + * This method is like `_.merge` except that it accepts `customizer` which + * is invoked to produce the merged values of the destination and source + * properties. If `customizer` returns `undefined` merging is handled by the + * method instead. The `customizer` is invoked with seven arguments: + * (objValue, srcValue, key, object, source, stack). + * + * @static + * @memberOf _ + * @category Object + * @param {Object} object The destination object. + * @param {...Object} sources The source objects. + * @param {Function} customizer The function to customize assigned values. + * @returns {Object} Returns `object`. + * @example + * + * function customizer(objValue, srcValue) { + * if (_.isArray(objValue)) { + * return objValue.concat(srcValue); + * } + * } + * + * var object = { + * 'fruits': ['apple'], + * 'vegetables': ['beet'] + * }; + * + * var other = { + * 'fruits': ['banana'], + * 'vegetables': ['carrot'] + * }; + * + * _.merge(object, other, customizer); + * // => { 'fruits': ['apple', 'banana'], 'vegetables': ['beet', 'carrot'] } + */ + mergeWith<TObject, TSource>( + object: TObject, + source: TSource, + customizer: MergeWithCustomizer + ): TObject & TSource; + + /** + * @see _.mergeWith + */ + mergeWith<TObject, TSource1, TSource2>( + object: TObject, + source1: TSource1, + source2: TSource2, + customizer: MergeWithCustomizer + ): TObject & TSource1 & TSource2; + + /** + * @see _.mergeWith + */ + mergeWith<TObject, TSource1, TSource2, TSource3>( + object: TObject, + source1: TSource1, + source2: TSource2, + source3: TSource3, + customizer: MergeWithCustomizer + ): TObject & TSource1 & TSource2 & TSource3; + + /** + * @see _.mergeWith + */ + mergeWith<TObject, TSource1, TSource2, TSource3, TSource4>( + object: TObject, + source1: TSource1, + source2: TSource2, + source3: TSource3, + source4: TSource4, + customizer: MergeWithCustomizer + ): TObject & TSource1 & TSource2 & TSource3 & TSource4; + + /** + * @see _.mergeWith + */ + mergeWith<TResult>( + object: any, + ...otherArgs: any[] + ): TResult; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.mergeWith + */ + mergeWith<TSource>( + source: TSource, + customizer: MergeWithCustomizer + ): LoDashImplicitObjectWrapper<T & TSource>; + + /** + * @see _.mergeWith + */ + mergeWith<TSource1, TSource2>( + source1: TSource1, + source2: TSource2, + customizer: MergeWithCustomizer + ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2>; + + /** + * @see _.mergeWith + */ + mergeWith<TSource1, TSource2, TSource3>( + source1: TSource1, + source2: TSource2, + source3: TSource3, + customizer: MergeWithCustomizer + ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>; + + /** + * @see _.mergeWith + */ + mergeWith<TSource1, TSource2, TSource3, TSource4>( + source1: TSource1, + source2: TSource2, + source3: TSource3, + source4: TSource4, + customizer: MergeWithCustomizer + ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>; + + /** + * @see _.mergeWith + */ + mergeWith<TResult>( + ...otherArgs: any[] + ): LoDashImplicitObjectWrapper<TResult>; + } + + //_.omit + interface LoDashStatic { + /** + * The opposite of `_.pick`; this method creates an object composed of the + * own and inherited enumerable properties of `object` that are not omitted. + * + * @static + * @memberOf _ + * @category Object + * @param {Object} object The source object. + * @param {...(string|string[])} [props] The property names to omit, specified + * individually or in arrays.. + * @returns {Object} Returns the new object. + * @example + * + * var object = { 'a': 1, 'b': '2', 'c': 3 }; + * + * _.omit(object, ['a', 'c']); + * // => { 'b': '2' } + */ + + omit<TResult extends {}, T extends {}>( + object: T, + ...predicate: (StringRepresentable|StringRepresentable[])[] + ): TResult; + } + + interface LoDashImplicitObjectWrapper<T> { + + /** + * @see _.omit + */ + omit<TResult extends {}>( + ...predicate: (StringRepresentable|StringRepresentable[])[] + ): LoDashImplicitObjectWrapper<TResult>; + } + + interface LoDashExplicitObjectWrapper<T> { + + /** + * @see _.omit + */ + omit<TResult extends {}>( + ...predicate: (StringRepresentable|StringRepresentable[])[] + ): LoDashExplicitObjectWrapper<TResult>; + } + + //_.omitBy + interface LoDashStatic { + /** + * The opposite of `_.pickBy`; this method creates an object composed of the + * own and inherited enumerable properties of `object` that `predicate` + * doesn't return truthy for. + * + * @static + * @memberOf _ + * @category Object + * @param {Object} object The source object. + * @param {Function|Object|string} [predicate=_.identity] The function invoked per property. + * @returns {Object} Returns the new object. + * @example + * + * var object = { 'a': 1, 'b': '2', 'c': 3 }; + * + * _.omitBy(object, _.isNumber); + * // => { 'b': '2' } + */ + omitBy<TResult extends {}, T extends {}>( + object: T, + predicate: ObjectIterator<any, boolean> + ): TResult; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.omitBy + */ + omitBy<TResult extends {}>( + predicate: ObjectIterator<any, boolean> + ): LoDashImplicitObjectWrapper<TResult>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.omitBy + */ + omitBy<TResult extends {}>( + predicate: ObjectIterator<any, boolean> + ): LoDashExplicitObjectWrapper<TResult>; + } + + //_.pick + interface LoDashStatic { + /** + * Creates an object composed of the picked `object` properties. + * + * @static + * @memberOf _ + * @category Object + * @param {Object} object The source object. + * @param {...(string|string[])} [props] The property names to pick, specified + * individually or in arrays. + * @returns {Object} Returns the new object. + * @example + * + * var object = { 'a': 1, 'b': '2', 'c': 3 }; + * + * _.pick(object, ['a', 'c']); + * // => { 'a': 1, 'c': 3 } + */ + pick<TResult extends {}, T extends {}>( + object: T, + ...predicate: (StringRepresentable|StringRepresentable[])[] + ): TResult; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.pick + */ + pick<TResult extends {}>( + ...predicate: (StringRepresentable|StringRepresentable[])[] + ): LoDashImplicitObjectWrapper<TResult>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.pick + */ + pick<TResult extends {}>( + ...predicate: (StringRepresentable|StringRepresentable[])[] + ): LoDashExplicitObjectWrapper<TResult>; + } + + //_.pickBy + interface LoDashStatic { + /** + * Creates an object composed of the `object` properties `predicate` returns + * truthy for. The predicate is invoked with one argument: (value). + * + * @static + * @memberOf _ + * @category Object + * @param {Object} object The source object. + * @param {Function|Object|string} [predicate=_.identity] The function invoked per property. + * @returns {Object} Returns the new object. + * @example + * + * var object = { 'a': 1, 'b': '2', 'c': 3 }; + * + * _.pickBy(object, _.isNumber); + * // => { 'a': 1, 'c': 3 } + */ + pickBy<TResult extends {}, T extends {}>( + object: T, + predicate?: ObjectIterator<any, boolean> + ): TResult; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.pickBy + */ + pickBy<TResult extends {}>( + predicate?: ObjectIterator<any, boolean> + ): LoDashImplicitObjectWrapper<TResult>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.pickBy + */ + pickBy<TResult extends {}>( + predicate?: ObjectIterator<any, boolean> + ): LoDashExplicitObjectWrapper<TResult>; + } + + //_.result + interface LoDashStatic { + /** + * This method is like _.get except that if the resolved value is a function it’s invoked with the this binding + * of its parent object and its result is returned. + * + * @param object The object to query. + * @param path The path of the property to resolve. + * @param defaultValue The value returned if the resolved value is undefined. + * @return Returns the resolved value. + */ + result<TObject, TResult>( + object: TObject, + path: StringRepresentable|StringRepresentable[], + defaultValue?: TResult|((...args: any[]) => TResult) + ): TResult; + + /** + * @see _.result + */ + result<TResult>( + object: any, + path: StringRepresentable|StringRepresentable[], + defaultValue?: TResult|((...args: any[]) => TResult) + ): TResult; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.result + */ + result<TResult>( + path: StringRepresentable|StringRepresentable[], + defaultValue?: TResult|((...args: any[]) => TResult) + ): TResult; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.result + */ + result<TResult>( + path: StringRepresentable|StringRepresentable[], + defaultValue?: TResult|((...args: any[]) => TResult) + ): TResult; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.result + */ + result<TResult>( + path: StringRepresentable|StringRepresentable[], + defaultValue?: TResult|((...args: any[]) => TResult) + ): TResult; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.result + */ + result<TResultWrapper>( + path: StringRepresentable|StringRepresentable[], + defaultValue?: any + ): TResultWrapper; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.result + */ + result<TResultWrapper>( + path: StringRepresentable|StringRepresentable[], + defaultValue?: any + ): TResultWrapper; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.result + */ + result<TResultWrapper>( + path: StringRepresentable|StringRepresentable[], + defaultValue?: any + ): TResultWrapper; + } + + //_.set + interface LoDashStatic { + /** + * Sets the value at path of object. If a portion of path doesn’t exist it’s created. Arrays are created for + * missing index properties while objects are created for all other missing properties. Use _.setWith to + * customize path creation. + * + * @param object The object to modify. + * @param path The path of the property to set. + * @param value The value to set. + * @return Returns object. + */ + set<TResult>( + object: Object, + path: StringRepresentable|StringRepresentable[], + value: any + ): TResult; + + /** + * @see _.set + */ + set<V, TResult>( + object: Object, + path: StringRepresentable|StringRepresentable[], + value: V + ): TResult; + + /** + * @see _.set + */ + set<O, V, TResult>( + object: O, + path: StringRepresentable|StringRepresentable[], + value: V + ): TResult; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.set + */ + set<TResult>( + path: StringRepresentable|StringRepresentable[], + value: any + ): LoDashImplicitObjectWrapper<TResult>; + + /** + * @see _.set + */ + set<V, TResult>( + path: StringRepresentable|StringRepresentable[], + value: V + ): LoDashImplicitObjectWrapper<TResult>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.set + */ + set<TResult>( + path: StringRepresentable|StringRepresentable[], + value: any + ): LoDashExplicitObjectWrapper<TResult>; + + /** + * @see _.set + */ + set<V, TResult>( + path: StringRepresentable|StringRepresentable[], + value: V + ): LoDashExplicitObjectWrapper<TResult>; + } + + //_.setWith + interface SetWithCustomizer<T> { + (nsValue: any, key: string, nsObject: T): any; + } + + interface LoDashStatic { + /** + * This method is like _.set except that it accepts customizer which is invoked to produce the objects of + * path. If customizer returns undefined path creation is handled by the method instead. The customizer is + * invoked with three arguments: (nsValue, key, nsObject). + * + * @param object The object to modify. + * @param path The path of the property to set. + * @param value The value to set. + * @parem customizer The function to customize assigned values. + * @return Returns object. + */ + setWith<TResult>( + object: Object, + path: StringRepresentable|StringRepresentable[], + value: any, + customizer?: SetWithCustomizer<Object> + ): TResult; + + /** + * @see _.setWith + */ + setWith<V, TResult>( + object: Object, + path: StringRepresentable|StringRepresentable[], + value: V, + customizer?: SetWithCustomizer<Object> + ): TResult; + + /** + * @see _.setWith + */ + setWith<O, V, TResult>( + object: O, + path: StringRepresentable|StringRepresentable[], + value: V, + customizer?: SetWithCustomizer<O> + ): TResult; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.setWith + */ + setWith<TResult>( + path: StringRepresentable|StringRepresentable[], + value: any, + customizer?: SetWithCustomizer<T> + ): LoDashImplicitObjectWrapper<TResult>; + + /** + * @see _.setWith + */ + setWith<V, TResult>( + path: StringRepresentable|StringRepresentable[], + value: V, + customizer?: SetWithCustomizer<T> + ): LoDashImplicitObjectWrapper<TResult>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.setWith + */ + setWith<TResult>( + path: StringRepresentable|StringRepresentable[], + value: any, + customizer?: SetWithCustomizer<T> + ): LoDashExplicitObjectWrapper<TResult>; + + /** + * @see _.setWith + */ + setWith<V, TResult>( + path: StringRepresentable|StringRepresentable[], + value: V, + customizer?: SetWithCustomizer<T> + ): LoDashExplicitObjectWrapper<TResult>; + } + + //_.toPairs + interface LoDashStatic { + /** + * Creates an array of own enumerable key-value pairs for object. + * + * @param object The object to query. + * @return Returns the new array of key-value pairs. + */ + toPairs<T extends {}>(object?: T): any[][]; + + toPairs<T extends {}, TResult>(object?: T): TResult[][]; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.toPairs + */ + toPairs<TResult>(): LoDashImplicitArrayWrapper<TResult[]>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.toPairs + */ + toPairs<TResult>(): LoDashExplicitArrayWrapper<TResult[]>; + } + + //_.toPairsIn + interface LoDashStatic { + /** + * Creates an array of own and inherited enumerable key-value pairs for object. + * + * @param object The object to query. + * @return Returns the new array of key-value pairs. + */ + toPairsIn<T extends {}>(object?: T): any[][]; + + toPairsIn<T extends {}, TResult>(object?: T): TResult[][]; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.toPairsIn + */ + toPairsIn<TResult>(): LoDashImplicitArrayWrapper<TResult[]>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.toPairsIn + */ + toPairsIn<TResult>(): LoDashExplicitArrayWrapper<TResult[]>; + } + + //_.transform + interface LoDashStatic { + /** + * An alternative to _.reduce; this method transforms object to a new accumulator object which is the result of + * running each of its own enumerable properties through iteratee, with each invocation potentially mutating + * the accumulator object. The iteratee is bound to thisArg and invoked with four arguments: (accumulator, + * value, key, object). Iteratee functions may exit iteration early by explicitly returning false. + * + * @param object The object to iterate over. + * @param iteratee The function invoked per iteration. + * @param accumulator The custom accumulator value. + * @param thisArg The this binding of iteratee. + * @return Returns the accumulated value. + */ + transform<T, TResult>( + object: T[], + iteratee?: MemoVoidArrayIterator<T, TResult[]>, + accumulator?: TResult[] + ): TResult[]; + + /** + * @see _.transform + */ + transform<T, TResult>( + object: T[], + iteratee?: MemoVoidArrayIterator<T, Dictionary<TResult>>, + accumulator?: Dictionary<TResult> + ): Dictionary<TResult>; + + /** + * @see _.transform + */ + transform<T, TResult>( + object: Dictionary<T>, + iteratee?: MemoVoidDictionaryIterator<T, Dictionary<TResult>>, + accumulator?: Dictionary<TResult> + ): Dictionary<TResult>; + + /** + * @see _.transform + */ + transform<T, TResult>( + object: Dictionary<T>, + iteratee?: MemoVoidDictionaryIterator<T, TResult[]>, + accumulator?: TResult[] + ): TResult[]; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.transform + */ + transform<TResult>( + iteratee?: MemoVoidArrayIterator<T, TResult[]>, + accumulator?: TResult[] + ): LoDashImplicitArrayWrapper<TResult>; + + /** + * @see _.transform + */ + transform<TResult>( + iteratee?: MemoVoidArrayIterator<T, Dictionary<TResult>>, + accumulator?: Dictionary<TResult> + ): LoDashImplicitObjectWrapper<Dictionary<TResult>>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.transform + */ + transform<T, TResult>( + iteratee?: MemoVoidDictionaryIterator<T, Dictionary<TResult>>, + accumulator?: Dictionary<TResult> + ): LoDashImplicitObjectWrapper<Dictionary<TResult>>; + + /** + * @see _.transform + */ + transform<T, TResult>( + iteratee?: MemoVoidDictionaryIterator<T, TResult[]>, + accumulator?: TResult[] + ): LoDashImplicitArrayWrapper<TResult>; + } + + //_.unset + interface LoDashStatic { + /** + * Removes the property at path of object. + * + * Note: This method mutates object. + * + * @param object The object to modify. + * @param path The path of the property to unset. + * @return Returns true if the property is deleted, else false. + */ + unset<T>( + object: T, + path: StringRepresentable|StringRepresentable[] + ): boolean; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.unset + */ + unset(path: StringRepresentable|StringRepresentable[]): LoDashImplicitWrapper<boolean>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.unset + */ + unset(path: StringRepresentable|StringRepresentable[]): LoDashExplicitWrapper<boolean>; + } + + //_.update + interface LoDashStatic { + /** + * This method is like _.set except that accepts updater to produce the value to set. Use _.updateWith to + * customize path creation. The updater is invoked with one argument: (value). + * + * @param object The object to modify. + * @param path The path of the property to set. + * @param updater The function to produce the updated value. + * @return Returns object. + */ + update<TResult>( + object: Object, + path: StringRepresentable|StringRepresentable[], + updater: Function + ): TResult; + + /** + * @see _.update + */ + update<U extends Function, TResult>( + object: Object, + path: StringRepresentable|StringRepresentable[], + updater: U + ): TResult; + + /** + * @see _.update + */ + update<O extends {}, TResult>( + object: O, + path: StringRepresentable|StringRepresentable[], + updater: Function + ): TResult; + + /** + * @see _.update + */ + update<O, U extends Function, TResult>( + object: O, + path: StringRepresentable|StringRepresentable[], + updater: U + ): TResult; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.update + */ + update<TResult>( + path: StringRepresentable|StringRepresentable[], + updater: any + ): LoDashImplicitObjectWrapper<TResult>; + + /** + * @see _.update + */ + update<U extends Function, TResult>( + path: StringRepresentable|StringRepresentable[], + updater: U + ): LoDashImplicitObjectWrapper<TResult>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.update + */ + update<TResult>( + path: StringRepresentable|StringRepresentable[], + updater: any + ): LoDashExplicitObjectWrapper<TResult>; + + /** + * @see _.update + */ + update<U extends Function, TResult>( + path: StringRepresentable|StringRepresentable[], + updater: U + ): LoDashExplicitObjectWrapper<TResult>; + } + + //_.values + interface LoDashStatic { + /** + * Creates an array of the own enumerable property values of object. + * + * @param object The object to query. + * @return Returns an array of property values. + */ + values<T>(object?: Dictionary<T>): T[]; + + /** + * @see _.values + */ + values<T>(object?: any): T[]; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.values + */ + values<T>(): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.values + */ + values<T>(): LoDashExplicitArrayWrapper<T>; + } + + //_.valuesIn + interface LoDashStatic { + /** + * Creates an array of the own and inherited enumerable property values of object. + * + * @param object The object to query. + * @return Returns the array of property values. + */ + valuesIn<T>(object?: Dictionary<T>): T[]; + + /** + * @see _.valuesIn + */ + valuesIn<T>(object?: any): T[]; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.valuesIn + */ + valuesIn<T>(): LoDashImplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.valuesIn + */ + valuesIn<T>(): LoDashExplicitArrayWrapper<T>; + } + + /********** + * String * + **********/ + + //_.camelCase + interface LoDashStatic { + /** + * Converts string to camel case. + * + * @param string The string to convert. + * @return Returns the camel cased string. + */ + camelCase(string?: string): string; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.camelCase + */ + camelCase(): string; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.camelCase + */ + camelCase(): LoDashExplicitWrapper<string>; + } + + //_.capitalize + interface LoDashStatic { + /** + * Converts the first character of string to upper case and the remaining to lower case. + * + * @param string The string to capitalize. + * @return Returns the capitalized string. + */ + capitalize(string?: string): string; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.capitalize + */ + capitalize(): string; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.capitalize + */ + capitalize(): LoDashExplicitWrapper<string>; + } + + //_.deburr + interface LoDashStatic { + /** + * Deburrs string by converting latin-1 supplementary letters to basic latin letters and removing combining + * diacritical marks. + * + * @param string The string to deburr. + * @return Returns the deburred string. + */ + deburr(string?: string): string; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.deburr + */ + deburr(): string; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.deburr + */ + deburr(): LoDashExplicitWrapper<string>; + } + + //_.endsWith + interface LoDashStatic { + /** + * Checks if string ends with the given target string. + * + * @param string The string to search. + * @param target The string to search for. + * @param position The position to search from. + * @return Returns true if string ends with target, else false. + */ + endsWith( + string?: string, + target?: string, + position?: number + ): boolean; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.endsWith + */ + endsWith( + target?: string, + position?: number + ): boolean; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.endsWith + */ + endsWith( + target?: string, + position?: number + ): LoDashExplicitWrapper<boolean>; + } + + // _.escape + interface LoDashStatic { + /** + * Converts the characters "&", "<", ">", '"', "'", and "`" in string to their corresponding HTML entities. + * + * Note: No other characters are escaped. To escape additional characters use a third-party library like he. + * + * hough the ">" character is escaped for symmetry, characters like ">" and "/" don’t need escaping in HTML + * and have no special meaning unless they're part of a tag or unquoted attribute value. See Mathias Bynens’s + * article (under "semi-related fun fact") for more details. + * + * Backticks are escaped because in IE < 9, they can break out of attribute values or HTML comments. See #59, + * #102, #108, and #133 of the HTML5 Security Cheatsheet for more details. + * + * When working with HTML you should always quote attribute values to reduce XSS vectors. + * + * @param string The string to escape. + * @return Returns the escaped string. + */ + escape(string?: string): string; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.escape + */ + escape(): string; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.escape + */ + escape(): LoDashExplicitWrapper<string>; + } + + // _.escapeRegExp + interface LoDashStatic { + /** + * Escapes the RegExp special characters "^", "$", "\", ".", "*", "+", "?", "(", ")", "[", "]", + * "{", "}", and "|" in string. + * + * @param string The string to escape. + * @return Returns the escaped string. + */ + escapeRegExp(string?: string): string; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.escapeRegExp + */ + escapeRegExp(): string; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.escapeRegExp + */ + escapeRegExp(): LoDashExplicitWrapper<string>; + } + + //_.kebabCase + interface LoDashStatic { + /** + * Converts string to kebab case. + * + * @param string The string to convert. + * @return Returns the kebab cased string. + */ + kebabCase(string?: string): string; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.kebabCase + */ + kebabCase(): string; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.kebabCase + */ + kebabCase(): LoDashExplicitWrapper<string>; + } + + //_.lowerCase + interface LoDashStatic { + /** + * Converts `string`, as space separated words, to lower case. + * + * @param string The string to convert. + * @return Returns the lower cased string. + */ + lowerCase(string?: string): string; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.lowerCase + */ + lowerCase(): string; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.lowerCase + */ + lowerCase(): LoDashExplicitWrapper<string>; + } + + //_.lowerFirst + interface LoDashStatic { + /** + * Converts the first character of `string` to lower case. + * + * @param string The string to convert. + * @return Returns the converted string. + */ + lowerFirst(string?: string): string; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.lowerFirst + */ + lowerFirst(): string; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.lowerFirst + */ + lowerFirst(): LoDashExplicitWrapper<string>; + } + + //_.pad + interface LoDashStatic { + /** + * Pads string on the left and right sides if it’s shorter than length. Padding characters are truncated if + * they can’t be evenly divided by length. + * + * @param string The string to pad. + * @param length The padding length. + * @param chars The string used as padding. + * @return Returns the padded string. + */ + pad( + string?: string, + length?: number, + chars?: string + ): string; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.pad + */ + pad( + length?: number, + chars?: string + ): string; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.pad + */ + pad( + length?: number, + chars?: string + ): LoDashExplicitWrapper<string>; + } + + //_.padEnd + interface LoDashStatic { + /** + * Pads string on the right side if it’s shorter than length. Padding characters are truncated if they exceed + * length. + * + * @param string The string to pad. + * @param length The padding length. + * @param chars The string used as padding. + * @return Returns the padded string. + */ + padEnd( + string?: string, + length?: number, + chars?: string + ): string; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.padEnd + */ + padEnd( + length?: number, + chars?: string + ): string; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.padEnd + */ + padEnd( + length?: number, + chars?: string + ): LoDashExplicitWrapper<string>; + } + + //_.padStart + interface LoDashStatic { + /** + * Pads string on the left side if it’s shorter than length. Padding characters are truncated if they exceed + * length. + * + * @param string The string to pad. + * @param length The padding length. + * @param chars The string used as padding. + * @return Returns the padded string. + */ + padStart( + string?: string, + length?: number, + chars?: string + ): string; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.padStart + */ + padStart( + length?: number, + chars?: string + ): string; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.padStart + */ + padStart( + length?: number, + chars?: string + ): LoDashExplicitWrapper<string>; + } + + //_.parseInt + interface LoDashStatic { + /** + * Converts string to an integer of the specified radix. If radix is undefined or 0, a radix of 10 is used + * unless value is a hexadecimal, in which case a radix of 16 is used. + * + * Note: This method aligns with the ES5 implementation of parseInt. + * + * @param string The string to convert. + * @param radix The radix to interpret value by. + * @return Returns the converted integer. + */ + parseInt( + string: string, + radix?: number + ): number; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.parseInt + */ + parseInt(radix?: number): number; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.parseInt + */ + parseInt(radix?: number): LoDashExplicitWrapper<number>; + } + + //_.repeat + interface LoDashStatic { + /** + * Repeats the given string n times. + * + * @param string The string to repeat. + * @param n The number of times to repeat the string. + * @return Returns the repeated string. + */ + repeat( + string?: string, + n?: number + ): string; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.repeat + */ + repeat(n?: number): string; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.repeat + */ + repeat(n?: number): LoDashExplicitWrapper<string>; + } + + //_.replace + interface LoDashStatic { + /** + * Replaces matches for pattern in string with replacement. + * + * Note: This method is based on String#replace. + * + * @param string + * @param pattern + * @param replacement + * @return Returns the modified string. + */ + replace( + string: string, + pattern: RegExp|string, + replacement: Function|string + ): string; + + /** + * @see _.replace + */ + replace( + pattern?: RegExp|string, + replacement?: Function|string + ): string; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.replace + */ + replace( + pattern?: RegExp|string, + replacement?: Function|string + ): string; + + /** + * @see _.replace + */ + replace( + replacement?: Function|string + ): string; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.replace + */ + replace( + pattern?: RegExp|string, + replacement?: Function|string + ): string; + + /** + * @see _.replace + */ + replace( + replacement?: Function|string + ): string; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.replace + */ + replace( + pattern?: RegExp|string, + replacement?: Function|string + ): LoDashExplicitWrapper<string>; + + /** + * @see _.replace + */ + replace( + replacement?: Function|string + ): LoDashExplicitWrapper<string>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.replace + */ + replace( + pattern?: RegExp|string, + replacement?: Function|string + ): LoDashExplicitWrapper<string>; + + /** + * @see _.replace + */ + replace( + replacement?: Function|string + ): LoDashExplicitWrapper<string>; + } + + //_.snakeCase + interface LoDashStatic { + /** + * Converts string to snake case. + * + * @param string The string to convert. + * @return Returns the snake cased string. + */ + snakeCase(string?: string): string; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.snakeCase + */ + snakeCase(): string; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.snakeCase + */ + snakeCase(): LoDashExplicitWrapper<string>; + } + + //_.split + interface LoDashStatic { + /** + * Splits string by separator. + * + * Note: This method is based on String#split. + * + * @param string + * @param separator + * @param limit + * @return Returns the new array of string segments. + */ + split( + string: string, + separator?: RegExp|string, + limit?: number + ): string[]; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.split + */ + split( + separator?: RegExp|string, + limit?: number + ): LoDashImplicitArrayWrapper<string>; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.split + */ + split( + separator?: RegExp|string, + limit?: number + ): LoDashExplicitArrayWrapper<string>; + } + + //_.startCase + interface LoDashStatic { + /** + * Converts string to start case. + * + * @param string The string to convert. + * @return Returns the start cased string. + */ + startCase(string?: string): string; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.startCase + */ + startCase(): string; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.startCase + */ + startCase(): LoDashExplicitWrapper<string>; + } + + //_.startsWith + interface LoDashStatic { + /** + * Checks if string starts with the given target string. + * + * @param string The string to search. + * @param target The string to search for. + * @param position The position to search from. + * @return Returns true if string starts with target, else false. + */ + startsWith( + string?: string, + target?: string, + position?: number + ): boolean; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.startsWith + */ + startsWith( + target?: string, + position?: number + ): boolean; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.startsWith + */ + startsWith( + target?: string, + position?: number + ): LoDashExplicitWrapper<boolean>; + } + + //_.template + interface TemplateOptions extends TemplateSettings { + /** + * The sourceURL of the template's compiled source. + */ + sourceURL?: string; + } + + interface TemplateExecutor { + (data?: Object): string; + source: string; + } + + interface LoDashStatic { + /** + * Creates a compiled template function that can interpolate data properties in "interpolate" delimiters, + * HTML-escape interpolated data properties in "escape" delimiters, and execute JavaScript in "evaluate" + * delimiters. Data properties may be accessed as free variables in the template. If a setting object is + * provided it takes precedence over _.templateSettings values. + * + * Note: In the development build _.template utilizes + * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl) for easier + * debugging. + * + * For more information on precompiling templates see + * [lodash's custom builds documentation](https://lodash.com/custom-builds). + * + * For more information on Chrome extension sandboxes see + * [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval). + * + * @param string The template string. + * @param options The options object. + * @param options.escape The HTML "escape" delimiter. + * @param options.evaluate The "evaluate" delimiter. + * @param options.imports An object to import into the template as free variables. + * @param options.interpolate The "interpolate" delimiter. + * @param options.sourceURL The sourceURL of the template's compiled source. + * @param options.variable The data object variable name. + * @return Returns the compiled template function. + */ + template( + string: string, + options?: TemplateOptions + ): TemplateExecutor; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.template + */ + template(options?: TemplateOptions): TemplateExecutor; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.template + */ + template(options?: TemplateOptions): LoDashExplicitObjectWrapper<TemplateExecutor>; + } + + //_.toLower + interface LoDashStatic { + /** + * Converts `string`, as a whole, to lower case. + * + * @param string The string to convert. + * @return Returns the lower cased string. + */ + toLower(string?: string): string; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.toLower + */ + toLower(): string; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.toLower + */ + toLower(): LoDashExplicitWrapper<string>; + } + + //_.toUpper + interface LoDashStatic { + /** + * Converts `string`, as a whole, to upper case. + * + * @param string The string to convert. + * @return Returns the upper cased string. + */ + toUpper(string?: string): string; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.toUpper + */ + toUpper(): string; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.toUpper + */ + toUpper(): LoDashExplicitWrapper<string>; + } + + //_.trim + interface LoDashStatic { + /** + * Removes leading and trailing whitespace or specified characters from string. + * + * @param string The string to trim. + * @param chars The characters to trim. + * @return Returns the trimmed string. + */ + trim( + string?: string, + chars?: string + ): string; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.trim + */ + trim(chars?: string): string; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.trim + */ + trim(chars?: string): LoDashExplicitWrapper<string>; + } + + //_.trimEnd + interface LoDashStatic { + /** + * Removes trailing whitespace or specified characters from string. + * + * @param string The string to trim. + * @param chars The characters to trim. + * @return Returns the trimmed string. + */ + trimEnd( + string?: string, + chars?: string + ): string; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.trimEnd + */ + trimEnd(chars?: string): string; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.trimEnd + */ + trimEnd(chars?: string): LoDashExplicitWrapper<string>; + } + + //_.trimStart + interface LoDashStatic { + /** + * Removes leading whitespace or specified characters from string. + * + * @param string The string to trim. + * @param chars The characters to trim. + * @return Returns the trimmed string. + */ + trimStart( + string?: string, + chars?: string + ): string; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.trimStart + */ + trimStart(chars?: string): string; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.trimStart + */ + trimStart(chars?: string): LoDashExplicitWrapper<string>; + } + + //_.truncate + interface TruncateOptions { + /** The maximum string length. */ + length?: number; + /** The string to indicate text is omitted. */ + omission?: string; + /** The separator pattern to truncate to. */ + separator?: string|RegExp; + } + + interface LoDashStatic { + /** + * Truncates string if it’s longer than the given maximum string length. The last characters of the truncated + * string are replaced with the omission string which defaults to "…". + * + * @param string The string to truncate. + * @param options The options object or maximum string length. + * @return Returns the truncated string. + */ + truncate( + string?: string, + options?: TruncateOptions + ): string; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.truncate + */ + truncate(options?: TruncateOptions): string; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.truncate + */ + truncate(options?: TruncateOptions): LoDashExplicitWrapper<string>; + } + + //_.unescape + interface LoDashStatic { + /** + * The inverse of _.escape; this method converts the HTML entities &, <, >, ", ', and ` + * in string to their corresponding characters. + * + * Note: No other HTML entities are unescaped. To unescape additional HTML entities use a third-party library + * like he. + * + * @param string The string to unescape. + * @return Returns the unescaped string. + */ + unescape(string?: string): string; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.unescape + */ + unescape(): string; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.unescape + */ + unescape(): LoDashExplicitWrapper<string>; + } + + //_.upperCase + interface LoDashStatic { + /** + * Converts `string`, as space separated words, to upper case. + * + * @param string The string to convert. + * @return Returns the upper cased string. + */ + upperCase(string?: string): string; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.upperCase + */ + upperCase(): string; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.upperCase + */ + upperCase(): LoDashExplicitWrapper<string>; + } + + //_.upperFirst + interface LoDashStatic { + /** + * Converts the first character of `string` to upper case. + * + * @param string The string to convert. + * @return Returns the converted string. + */ + upperFirst(string?: string): string; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.upperFirst + */ + upperFirst(): string; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.upperFirst + */ + upperFirst(): LoDashExplicitWrapper<string>; + } + + //_.words + interface LoDashStatic { + /** + * Splits `string` into an array of its words. + * + * @param string The string to inspect. + * @param pattern The pattern to match words. + * @return Returns the words of `string`. + */ + words( + string?: string, + pattern?: string|RegExp + ): string[]; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.words + */ + words(pattern?: string|RegExp): string[]; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.words + */ + words(pattern?: string|RegExp): LoDashExplicitArrayWrapper<string>; + } + + /*********** + * Utility * + ***********/ + + //_.attempt + interface LoDashStatic { + /** + * Attempts to invoke func, returning either the result or the caught error object. Any additional arguments + * are provided to func when it’s invoked. + * + * @param func The function to attempt. + * @return Returns the func result or error object. + */ + attempt<TResult>(func: (...args: any[]) => TResult, ...args: any[]): TResult|Error; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.attempt + */ + attempt<TResult>(...args: any[]): TResult|Error; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.attempt + */ + attempt<TResult>(...args: any[]): LoDashExplicitObjectWrapper<TResult|Error>; + } + + //_.constant + interface LoDashStatic { + /** + * Creates a function that returns value. + * + * @param value The value to return from the new function. + * @return Returns the new function. + */ + constant<T>(value: T): () => T; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.constant + */ + constant<TResult>(): LoDashImplicitObjectWrapper<() => TResult>; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.constant + */ + constant<TResult>(): LoDashExplicitObjectWrapper<() => TResult>; + } + + //_.defaultTo + interface LoDashStatic { + /** + * Checks `value` to determine whether a default value should be returned in + * its place. The `defaultValue` is returned if `value` is `NaN`, `null`, + * or `undefined`. + * + * @param value The value to check. + * @param defaultValue The default value. + * @returns Returns the resolved value. + */ + defaultTo<T>(value: T, defaultValue: T): T; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.defaultTo + */ + defaultTo<TResult>(value: TResult): LoDashImplicitObjectWrapper<TResult>; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.defaultTo + */ + defaultTo<TResult>(value: TResult): LoDashExplicitObjectWrapper<TResult>; + } + + //_.identity + interface LoDashStatic { + /** + * This method returns the first argument provided to it. + * + * @param value Any value. + * @return Returns value. + */ + identity<T>(value?: T): T; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.identity + */ + identity(): T; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.identity + */ + identity(): T[]; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.identity + */ + identity(): T; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.identity + */ + identity(): LoDashExplicitWrapper<T>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.identity + */ + identity(): LoDashExplicitArrayWrapper<T>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.identity + */ + identity(): LoDashExplicitObjectWrapper<T>; + } + + //_.iteratee + interface LoDashStatic { + /** + * Creates a function that invokes `func` with the arguments of the created + * function. If `func` is a property name the created callback returns the + * property value for a given element. If `func` is an object the created + * callback returns `true` for elements that contain the equivalent object properties, otherwise it returns `false`. + * + * @static + * @memberOf _ + * @category Util + * @param {*} [func=_.identity] The value to convert to a callback. + * @returns {Function} Returns the callback. + * @example + * + * var users = [ + * { 'user': 'barney', 'age': 36 }, + * { 'user': 'fred', 'age': 40 } + * ]; + * + * // create custom iteratee shorthands + * _.iteratee = _.wrap(_.iteratee, function(callback, func) { + * var p = /^(\S+)\s*([<>])\s*(\S+)$/.exec(func); + * return !p ? callback(func) : function(object) { + * return (p[2] == '>' ? object[p[1]] > p[3] : object[p[1]] < p[3]); + * }; + * }); + * + * _.filter(users, 'age > 36'); + * // => [{ 'user': 'fred', 'age': 40 }] + */ + iteratee<TResult>( + func: Function + ): (...args: any[]) => TResult; + + /** + * @see _.iteratee + */ + iteratee<TResult>( + func: string + ): (object: any) => TResult; + + /** + * @see _.iteratee + */ + iteratee( + func: Object + ): (object: any) => boolean; + + /** + * @see _.iteratee + */ + iteratee<TResult>(): (value: TResult) => TResult; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.iteratee + */ + iteratee<TResult>(): LoDashImplicitObjectWrapper<(object: any) => TResult>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.iteratee + */ + iteratee(): LoDashImplicitObjectWrapper<(object: any) => boolean>; + + /** + * @see _.iteratee + */ + iteratee<TResult>(): LoDashImplicitObjectWrapper<(...args: any[]) => TResult>; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.iteratee + */ + iteratee<TResult>(): LoDashExplicitObjectWrapper<(object: any) => TResult>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.iteratee + */ + iteratee(): LoDashExplicitObjectWrapper<(object: any) => boolean>; + + /** + * @see _.iteratee + */ + iteratee<TResult>(): LoDashExplicitObjectWrapper<(...args: any[]) => TResult>; + } + + //_.matches + interface LoDashStatic { + /** + * Creates a function that performs a deep comparison between a given object and source, returning true if the + * given object has equivalent property values, else false. + * + * Note: This method supports comparing arrays, booleans, Date objects, numbers, Object objects, regexes, and + * strings. Objects are compared by their own, not inherited, enumerable properties. For comparing a single own + * or inherited property value see _.matchesProperty. + * + * @param source The object of property values to match. + * @return Returns the new function. + */ + matches<T>(source: T): (value: any) => boolean; + + /** + * @see _.matches + */ + matches<T, V>(source: T): (value: V) => boolean; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.matches + */ + matches<V>(): LoDashImplicitObjectWrapper<(value: V) => boolean>; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.matches + */ + matches<V>(): LoDashExplicitObjectWrapper<(value: V) => boolean>; + } + + //_.matchesProperty + interface LoDashStatic { + /** + * Creates a function that compares the property value of path on a given object to value. + * + * Note: This method supports comparing arrays, booleans, Date objects, numbers, Object objects, regexes, and + * strings. Objects are compared by their own, not inherited, enumerable properties. + * + * @param path The path of the property to get. + * @param srcValue The value to match. + * @return Returns the new function. + */ + matchesProperty<T>( + path: StringRepresentable|StringRepresentable[], + srcValue: T + ): (value: any) => boolean; + + /** + * @see _.matchesProperty + */ + matchesProperty<T, V>( + path: StringRepresentable|StringRepresentable[], + srcValue: T + ): (value: V) => boolean; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.matchesProperty + */ + matchesProperty<SrcValue>( + srcValue: SrcValue + ): LoDashImplicitObjectWrapper<(value: any) => boolean>; + + /** + * @see _.matchesProperty + */ + matchesProperty<SrcValue, Value>( + srcValue: SrcValue + ): LoDashImplicitObjectWrapper<(value: Value) => boolean>; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.matchesProperty + */ + matchesProperty<SrcValue>( + srcValue: SrcValue + ): LoDashExplicitObjectWrapper<(value: any) => boolean>; + + /** + * @see _.matchesProperty + */ + matchesProperty<SrcValue, Value>( + srcValue: SrcValue + ): LoDashExplicitObjectWrapper<(value: Value) => boolean>; + } + + //_.method + interface LoDashStatic { + /** + * Creates a function that invokes the method at path on a given object. Any additional arguments are provided + * to the invoked method. + * + * @param path The path of the method to invoke. + * @param args The arguments to invoke the method with. + * @return Returns the new function. + */ + method<TObject, TResult>( + path: string|StringRepresentable[], + ...args: any[] + ): (object: TObject) => TResult; + + /** + * @see _.method + */ + method<TResult>( + path: string|StringRepresentable[], + ...args: any[] + ): (object: any) => TResult; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.method + */ + method<TObject, TResult>(...args: any[]): LoDashImplicitObjectWrapper<(object: TObject) => TResult>; + + /** + * @see _.method + */ + method<TResult>(...args: any[]): LoDashImplicitObjectWrapper<(object: any) => TResult>; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.method + */ + method<TObject, TResult>(...args: any[]): LoDashImplicitObjectWrapper<(object: TObject) => TResult>; + + /** + * @see _.method + */ + method<TResult>(...args: any[]): LoDashImplicitObjectWrapper<(object: any) => TResult>; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.method + */ + method<TObject, TResult>(...args: any[]): LoDashExplicitObjectWrapper<(object: TObject) => TResult>; + + /** + * @see _.method + */ + method<TResult>(...args: any[]): LoDashExplicitObjectWrapper<(object: any) => TResult>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.method + */ + method<TObject, TResult>(...args: any[]): LoDashExplicitObjectWrapper<(object: TObject) => TResult>; + + /** + * @see _.method + */ + method<TResult>(...args: any[]): LoDashExplicitObjectWrapper<(object: any) => TResult>; + } + + //_.methodOf + interface LoDashStatic { + /** + * The opposite of _.method; this method creates a function that invokes the method at a given path on object. + * Any additional arguments are provided to the invoked method. + * + * @param object The object to query. + * @param args The arguments to invoke the method with. + * @return Returns the new function. + */ + methodOf<TObject extends {}, TResult>( + object: TObject, + ...args: any[] + ): (path: StringRepresentable|StringRepresentable[]) => TResult; + + /** + * @see _.methodOf + */ + methodOf<TResult>( + object: {}, + ...args: any[] + ): (path: StringRepresentable|StringRepresentable[]) => TResult; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.methodOf + */ + methodOf<TResult>( + ...args: any[] + ): LoDashImplicitObjectWrapper<(path: StringRepresentable|StringRepresentable[]) => TResult>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.methodOf + */ + methodOf<TResult>( + ...args: any[] + ): LoDashExplicitObjectWrapper<(path: StringRepresentable|StringRepresentable[]) => TResult>; + } + + //_.mixin + interface MixinOptions { + chain?: boolean; + } + + interface LoDashStatic { + /** + * Adds all own enumerable function properties of a source object to the destination object. If object is a + * function then methods are added to its prototype as well. + * + * Note: Use _.runInContext to create a pristine lodash function to avoid conflicts caused by modifying + * the original. + * + * @param object The destination object. + * @param source The object of functions to add. + * @param options The options object. + * @param options.chain Specify whether the functions added are chainable. + * @return Returns object. + */ + mixin<TResult, TObject>( + object: TObject, + source: Dictionary<Function>, + options?: MixinOptions + ): TResult; + + /** + * @see _.mixin + */ + mixin<TResult>( + source: Dictionary<Function>, + options?: MixinOptions + ): TResult; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.mixin + */ + mixin<TResult>( + source: Dictionary<Function>, + options?: MixinOptions + ): LoDashImplicitObjectWrapper<TResult>; + + /** + * @see _.mixin + */ + mixin<TResult>( + options?: MixinOptions + ): LoDashImplicitObjectWrapper<TResult>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.mixin + */ + mixin<TResult>( + source: Dictionary<Function>, + options?: MixinOptions + ): LoDashExplicitObjectWrapper<TResult>; + + /** + * @see _.mixin + */ + mixin<TResult>( + options?: MixinOptions + ): LoDashExplicitObjectWrapper<TResult>; + } + + //_.noConflict + interface LoDashStatic { + /** + * Reverts the _ variable to its previous value and returns a reference to the lodash function. + * + * @return Returns the lodash function. + */ + noConflict(): typeof _; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.noConflict + */ + noConflict(): typeof _; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.noConflict + */ + noConflict(): LoDashExplicitObjectWrapper<typeof _>; + } + + //_.noop + interface LoDashStatic { + /** + * A no-operation function that returns undefined regardless of the arguments it receives. + * + * @return undefined + */ + noop(...args: any[]): void; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.noop + */ + noop(...args: any[]): void; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.noop + */ + noop(...args: any[]): _.LoDashExplicitWrapper<void>; + } + + //_.nthArg + interface LoDashStatic { + /** + * Creates a function that returns its nth argument. + * + * @param n The index of the argument to return. + * @return Returns the new function. + */ + nthArg<TResult extends Function>(n?: number): TResult; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.nthArg + */ + nthArg<TResult extends Function>(): LoDashImplicitObjectWrapper<TResult>; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.nthArg + */ + nthArg<TResult extends Function>(): LoDashExplicitObjectWrapper<TResult>; + } + + //_.over + interface LoDashStatic { + /** + * Creates a function that invokes iteratees with the arguments provided to the created function and returns + * their results. + * + * @param iteratees The iteratees to invoke. + * @return Returns the new function. + */ + over<TResult>(...iteratees: (Function|Function[])[]): (...args: any[]) => TResult[]; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.over + */ + over<TResult>(...iteratees: (Function|Function[])[]): LoDashImplicitObjectWrapper<(...args: any[]) => TResult[]>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.over + */ + over<TResult>(...iteratees: (Function|Function[])[]): LoDashImplicitObjectWrapper<(...args: any[]) => TResult[]>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.over + */ + over<TResult>(...iteratees: (Function|Function[])[]): LoDashExplicitObjectWrapper<(...args: any[]) => TResult[]>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.over + */ + over<TResult>(...iteratees: (Function|Function[])[]): LoDashExplicitObjectWrapper<(...args: any[]) => TResult[]>; + } + + //_.overEvery + interface LoDashStatic { + /** + * Creates a function that checks if all of the predicates return truthy when invoked with the arguments + * provided to the created function. + * + * @param predicates The predicates to check. + * @return Returns the new function. + */ + overEvery(...predicates: (Function|Function[])[]): (...args: any[]) => boolean; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.overEvery + */ + overEvery(...predicates: (Function|Function[])[]): LoDashImplicitObjectWrapper<(...args: any[]) => boolean>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.overEvery + */ + overEvery(...predicates: (Function|Function[])[]): LoDashImplicitObjectWrapper<(...args: any[]) => boolean>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.overEvery + */ + overEvery(...predicates: (Function|Function[])[]): LoDashExplicitObjectWrapper<(...args: any[]) => boolean>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.overEvery + */ + overEvery(...predicates: (Function|Function[])[]): LoDashExplicitObjectWrapper<(...args: any[]) => boolean>; + } + + //_.overSome + interface LoDashStatic { + /** + * Creates a function that checks if any of the predicates return truthy when invoked with the arguments + * provided to the created function. + * + * @param predicates The predicates to check. + * @return Returns the new function. + */ + overSome(...predicates: (Function|Function[])[]): (...args: any[]) => boolean; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.overSome + */ + overSome(...predicates: (Function|Function[])[]): LoDashImplicitObjectWrapper<(...args: any[]) => boolean>; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.overSome + */ + overSome(...predicates: (Function|Function[])[]): LoDashImplicitObjectWrapper<(...args: any[]) => boolean>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.overSome + */ + overSome(...predicates: (Function|Function[])[]): LoDashExplicitObjectWrapper<(...args: any[]) => boolean>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.overSome + */ + overSome(...predicates: (Function|Function[])[]): LoDashExplicitObjectWrapper<(...args: any[]) => boolean>; + } + + //_.property + interface LoDashStatic { + /** + * Creates a function that returns the property value at path on a given object. + * + * @param path The path of the property to get. + * @return Returns the new function. + */ + property<TObj, TResult>(path: StringRepresentable|StringRepresentable[]): (obj: TObj) => TResult; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.property + */ + property<TObj, TResult>(): LoDashImplicitObjectWrapper<(obj: TObj) => TResult>; + } + + interface LoDashImplicitArrayWrapper<T> { + /** + * @see _.property + */ + property<TObj, TResult>(): LoDashImplicitObjectWrapper<(obj: TObj) => TResult>; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.property + */ + property<TObj, TResult>(): LoDashExplicitObjectWrapper<(obj: TObj) => TResult>; + } + + interface LoDashExplicitArrayWrapper<T> { + /** + * @see _.property + */ + property<TObj, TResult>(): LoDashExplicitObjectWrapper<(obj: TObj) => TResult>; + } + + //_.propertyOf + interface LoDashStatic { + /** + * The opposite of _.property; this method creates a function that returns the property value at a given path + * on object. + * + * @param object The object to query. + * @return Returns the new function. + */ + propertyOf<T extends {}>(object: T): (path: string|string[]) => any; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.propertyOf + */ + propertyOf(): LoDashImplicitObjectWrapper<(path: string|string[]) => any>; + } + + interface LoDashExplicitObjectWrapper<T> { + /** + * @see _.propertyOf + */ + propertyOf(): LoDashExplicitObjectWrapper<(path: string|string[]) => any>; + } + + //_.range + interface LoDashStatic { + /** + * Creates an array of numbers (positive and/or negative) progressing from start up to, but not including, end. + * If end is not specified it’s set to start with start then set to 0. If end is less than start a zero-length + * range is created unless a negative step is specified. + * + * @param start The start of the range. + * @param end The end of the range. + * @param step The value to increment or decrement by. + * @return Returns a new range array. + */ + range( + start: number, + end: number, + step?: number + ): number[]; + + /** + * @see _.range + */ + range( + end: number, + step?: number + ): number[]; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.range + */ + range( + end?: number, + step?: number + ): LoDashImplicitArrayWrapper<number>; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.range + */ + range( + end?: number, + step?: number + ): LoDashExplicitArrayWrapper<number>; + } + + //_.rangeRight + interface LoDashStatic { + /** + * This method is like `_.range` except that it populates values in + * descending order. + * + * @static + * @memberOf _ + * @category Util + * @param {number} [start=0] The start of the range. + * @param {number} end The end of the range. + * @param {number} [step=1] The value to increment or decrement by. + * @returns {Array} Returns the new array of numbers. + * @example + * + * _.rangeRight(4); + * // => [3, 2, 1, 0] + * + * _.rangeRight(-4); + * // => [-3, -2, -1, 0] + * + * _.rangeRight(1, 5); + * // => [4, 3, 2, 1] + * + * _.rangeRight(0, 20, 5); + * // => [15, 10, 5, 0] + * + * _.rangeRight(0, -4, -1); + * // => [-3, -2, -1, 0] + * + * _.rangeRight(1, 4, 0); + * // => [1, 1, 1] + * + * _.rangeRight(0); + * // => [] + */ + rangeRight( + start: number, + end: number, + step?: number + ): number[]; + + /** + * @see _.rangeRight + */ + rangeRight( + end: number, + step?: number + ): number[]; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.rangeRight + */ + rangeRight( + end?: number, + step?: number + ): LoDashImplicitArrayWrapper<number>; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.rangeRight + */ + rangeRight( + end?: number, + step?: number + ): LoDashExplicitArrayWrapper<number>; + } + + //_.runInContext + interface LoDashStatic { + /** + * Create a new pristine lodash function using the given context object. + * + * @param context The context object. + * @return Returns a new lodash function. + */ + runInContext(context?: Object): typeof _; + } + + interface LoDashImplicitObjectWrapper<T> { + /** + * @see _.runInContext + */ + runInContext(): typeof _; + } + + //_.times + interface LoDashStatic { + /** + * Invokes the iteratee function n times, returning an array of the results of each invocation. The iteratee + * is invoked with one argument; (index). + * + * @param n The number of times to invoke iteratee. + * @param iteratee The function invoked per iteration. + * @return Returns the array of results. + */ + times<TResult>( + n: number, + iteratee: (num: number) => TResult + ): TResult[]; + + /** + * @see _.times + */ + times(n: number): number[]; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.times + */ + times<TResult>( + iteratee: (num: number) => TResult + ): TResult[]; + + /** + * @see _.times + */ + times(): number[]; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.times + */ + times<TResult>( + iteratee: (num: number) => TResult + ): LoDashExplicitArrayWrapper<TResult>; + + /** + * @see _.times + */ + times(): LoDashExplicitArrayWrapper<number>; + } + + //_.toPath + interface LoDashStatic { + /** + * Converts `value` to a property path array. + * + * @static + * @memberOf _ + * @category Util + * @param {*} value The value to convert. + * @returns {Array} Returns the new property path array. + * @example + * + * _.toPath('a.b.c'); + * // => ['a', 'b', 'c'] + * + * _.toPath('a[0].b.c'); + * // => ['a', '0', 'b', 'c'] + * + * var path = ['a', 'b', 'c'], + * newPath = _.toPath(path); + * + * console.log(newPath); + * // => ['a', 'b', 'c'] + * + * console.log(path === newPath); + * // => false + */ + toPath(value: any): string[]; + } + + interface LoDashImplicitWrapperBase<T, TWrapper> { + /** + * @see _.toPath + */ + toPath(): LoDashImplicitWrapper<string[]>; + } + + interface LoDashExplicitWrapperBase<T, TWrapper> { + /** + * @see _.toPath + */ + toPath(): LoDashExplicitWrapper<string[]>; + } + + //_.uniqueId + interface LoDashStatic { + /** + * Generates a unique ID. If prefix is provided the ID is appended to it. + * + * @param prefix The value to prefix the ID with. + * @return Returns the unique ID. + */ + uniqueId(prefix?: string): string; + } + + interface LoDashImplicitWrapper<T> { + /** + * @see _.uniqueId + */ + uniqueId(): string; + } + + interface LoDashExplicitWrapper<T> { + /** + * @see _.uniqueId + */ + uniqueId(): LoDashExplicitWrapper<string>; + } + + interface ListIterator<T, TResult> { + (value: T, index: number, collection: List<T>): TResult; + } + + interface DictionaryIterator<T, TResult> { + (value: T, key?: string, collection?: Dictionary<T>): TResult; + } + + interface NumericDictionaryIterator<T, TResult> { + (value: T, key?: number, collection?: Dictionary<T>): TResult; + } + + interface ObjectIterator<T, TResult> { + (element: T, key?: string, collection?: any): TResult; + } + + interface StringIterator<TResult> { + (char: string, index?: number, string?: string): TResult; + } + + interface MemoVoidIterator<T, TResult> { + (prev: TResult, curr: T, indexOrKey?: any, list?: T[]): void; + } + interface MemoIterator<T, TResult> { + (prev: TResult, curr: T, indexOrKey?: any, list?: T[]): TResult; + } + + interface MemoVoidArrayIterator<T, TResult> { + (acc: TResult, curr: T, index?: number, arr?: T[]): void; + } + interface MemoVoidDictionaryIterator<T, TResult> { + (acc: TResult, curr: T, key?: string, dict?: Dictionary<T>): void; + } + + //interface Collection<T> {} + + // Common interface between Arrays and jQuery objects + interface List<T> { + [index: number]: T; + length: number; + } + + interface Dictionary<T> { + [index: string]: T; + } + + interface NumericDictionary<T> { + [index: number]: T; + } + + interface StringRepresentable { + toString(): string; + } + + interface Cancelable { + cancel(): void; + flush(): void; + } +} + +// Named exports + +declare module "lodash/after" { + const after: typeof _.after; + export = after; +} + + +declare module "lodash/ary" { + const ary: typeof _.ary; + export = ary; +} + + +declare module "lodash/assign" { + const assign: typeof _.assign; + export = assign; +} + + +declare module "lodash/assignIn" { + const assignIn: typeof _.assignIn; + export = assignIn; +} + + +declare module "lodash/assignInWith" { + const assignInWith: typeof _.assignInWith; + export = assignInWith; +} + + +declare module "lodash/assignWith" { + const assignWith: typeof _.assignWith; + export = assignWith; +} + + +declare module "lodash/at" { + const at: typeof _.at; + export = at; +} + + +declare module "lodash/before" { + const before: typeof _.before; + export = before; +} + + +declare module "lodash/bind" { + const bind: typeof _.bind; + export = bind; +} + + +declare module "lodash/bindAll" { + const bindAll: typeof _.bindAll; + export = bindAll; +} + + +declare module "lodash/bindKey" { + const bindKey: typeof _.bindKey; + export = bindKey; +} + + +declare module "lodash/castArray" { + const castArray: typeof _.castArray; + export = castArray; +} + + +declare module "lodash/chain" { + const chain: typeof _.chain; + export = chain; +} + + +declare module "lodash/chunk" { + const chunk: typeof _.chunk; + export = chunk; +} + + +declare module "lodash/compact" { + const compact: typeof _.compact; + export = compact; +} + + +declare module "lodash/concat" { + const concat: typeof _.concat; + export = concat; +} + +/** + * uncoment it if definition exists + */ +/* + declare module "lodash/cond" { + const cond: typeof _.cond; + export = cond; + } + */ + +/** + * uncoment it if definition exists + */ +/* + declare module "lodash/conforms" { + const conforms: typeof _.conforms; + export = conforms; + } + */ + +declare module "lodash/constant" { + const constant: typeof _.constant; + export = constant; +} + + +declare module "lodash/countBy" { + const countBy: typeof _.countBy; + export = countBy; +} + + +declare module "lodash/create" { + const create: typeof _.create; + export = create; +} + + +declare module "lodash/curry" { + const curry: typeof _.curry; + export = curry; +} + + +declare module "lodash/curryRight" { + const curryRight: typeof _.curryRight; + export = curryRight; +} + + +declare module "lodash/debounce" { + const debounce: typeof _.debounce; + export = debounce; +} + + +declare module "lodash/defaults" { + const defaults: typeof _.defaults; + export = defaults; +} + + +declare module "lodash/defaultsDeep" { + const defaultsDeep: typeof _.defaultsDeep; + export = defaultsDeep; +} + + +declare module "lodash/defer" { + const defer: typeof _.defer; + export = defer; +} + + +declare module "lodash/delay" { + const delay: typeof _.delay; + export = delay; +} + + +declare module "lodash/difference" { + const difference: typeof _.difference; + export = difference; +} + + +declare module "lodash/differenceBy" { + const differenceBy: typeof _.differenceBy; + export = differenceBy; +} + + +declare module "lodash/differenceWith" { + const differenceWith: typeof _.differenceWith; + export = differenceWith; +} + + +declare module "lodash/drop" { + const drop: typeof _.drop; + export = drop; +} + + +declare module "lodash/dropRight" { + const dropRight: typeof _.dropRight; + export = dropRight; +} + + +declare module "lodash/dropRightWhile" { + const dropRightWhile: typeof _.dropRightWhile; + export = dropRightWhile; +} + + +declare module "lodash/dropWhile" { + const dropWhile: typeof _.dropWhile; + export = dropWhile; +} + + +declare module "lodash/fill" { + const fill: typeof _.fill; + export = fill; +} + + +declare module "lodash/filter" { + const filter: typeof _.filter; + export = filter; +} + + +declare module "lodash/flatMap" { + const flatMap: typeof _.flatMap; + export = flatMap; +} + +/** + * uncoment it if definition exists + */ +/* + declare module "lodash/flatMapDeep" { + const flatMapDeep: typeof _.flatMapDeep; + export = flatMapDeep; + } + */ +/** + * uncoment it if definition exists + */ +/* + declare module "lodash/flatMapDepth" { + const flatMapDepth: typeof _.flatMapDepth; + export = flatMapDepth; + } + */ + +declare module "lodash/flatten" { + const flatten: typeof _.flatten; + export = flatten; +} + + +declare module "lodash/flattenDeep" { + const flattenDeep: typeof _.flattenDeep; + export = flattenDeep; +} + +declare module "lodash/flattenDepth" { + const flattenDepth: typeof _.flattenDepth; + export = flattenDepth; +} + +declare module "lodash/flip" { + const flip: typeof _.flip; + export = flip; +} + + +declare module "lodash/flow" { + const flow: typeof _.flow; + export = flow; +} + + +declare module "lodash/flowRight" { + const flowRight: typeof _.flowRight; + export = flowRight; +} + + +declare module "lodash/fromPairs" { + const fromPairs: typeof _.fromPairs; + export = fromPairs; +} + + +declare module "lodash/functions" { + const functions: typeof _.functions; + export = functions; +} + + +declare module "lodash/functionsIn" { + const functionsIn: typeof _.functionsIn; + export = functionsIn; +} + + +declare module "lodash/groupBy" { + const groupBy: typeof _.groupBy; + export = groupBy; +} + + +declare module "lodash/initial" { + const initial: typeof _.initial; + export = initial; +} + + +declare module "lodash/intersection" { + const intersection: typeof _.intersection; + export = intersection; +} + + +declare module "lodash/intersectionBy" { + const intersectionBy: typeof _.intersectionBy; + export = intersectionBy; +} + + +declare module "lodash/intersectionWith" { + const intersectionWith: typeof _.intersectionWith; + export = intersectionWith; +} + + +declare module "lodash/invert" { + const invert: typeof _.invert; + export = invert; +} + + +declare module "lodash/invertBy" { + const invertBy: typeof _.invertBy; + export = invertBy; +} + + +declare module "lodash/invokeMap" { + const invokeMap: typeof _.invokeMap; + export = invokeMap; +} + + +declare module "lodash/iteratee" { + const iteratee: typeof _.iteratee; + export = iteratee; +} + + +declare module "lodash/keyBy" { + const keyBy: typeof _.keyBy; + export = keyBy; +} + + +declare module "lodash/keys" { + const keys: typeof _.keys; + export = keys; +} + + +declare module "lodash/keysIn" { + const keysIn: typeof _.keysIn; + export = keysIn; +} + + +declare module "lodash/map" { + const map: typeof _.map; + export = map; +} + + +declare module "lodash/mapKeys" { + const mapKeys: typeof _.mapKeys; + export = mapKeys; +} + + +declare module "lodash/mapValues" { + const mapValues: typeof _.mapValues; + export = mapValues; +} + + +declare module "lodash/matches" { + const matches: typeof _.matches; + export = matches; +} + + +declare module "lodash/matchesProperty" { + const matchesProperty: typeof _.matchesProperty; + export = matchesProperty; +} + + +declare module "lodash/memoize" { + const memoize: typeof _.memoize; + export = memoize; +} + + +declare module "lodash/merge" { + const merge: typeof _.merge; + export = merge; +} + + +declare module "lodash/mergeWith" { + const mergeWith: typeof _.mergeWith; + export = mergeWith; +} + + +declare module "lodash/method" { + const method: typeof _.method; + export = method; +} + + +declare module "lodash/methodOf" { + const methodOf: typeof _.methodOf; + export = methodOf; +} + + +declare module "lodash/mixin" { + const mixin: typeof _.mixin; + export = mixin; +} + + +declare module "lodash/negate" { + const negate: typeof _.negate; + export = negate; +} + + +declare module "lodash/nthArg" { + const nthArg: typeof _.nthArg; + export = nthArg; +} + + +declare module "lodash/omit" { + const omit: typeof _.omit; + export = omit; +} + + +declare module "lodash/omitBy" { + const omitBy: typeof _.omitBy; + export = omitBy; +} + + +declare module "lodash/once" { + const once: typeof _.once; + export = once; +} + + +declare module "lodash/orderBy" { + const orderBy: typeof _.orderBy; + export = orderBy; +} + + +declare module "lodash/over" { + const over: typeof _.over; + export = over; +} + + +declare module "lodash/overArgs" { + const overArgs: typeof _.overArgs; + export = overArgs; +} + + +declare module "lodash/overEvery" { + const overEvery: typeof _.overEvery; + export = overEvery; +} + + +declare module "lodash/overSome" { + const overSome: typeof _.overSome; + export = overSome; +} + + +declare module "lodash/partial" { + const partial: typeof _.partial; + export = partial; +} + + +declare module "lodash/partialRight" { + const partialRight: typeof _.partialRight; + export = partialRight; +} + + +declare module "lodash/partition" { + const partition: typeof _.partition; + export = partition; +} + + +declare module "lodash/pick" { + const pick: typeof _.pick; + export = pick; +} + + +declare module "lodash/pickBy" { + const pickBy: typeof _.pickBy; + export = pickBy; +} + + +declare module "lodash/property" { + const property: typeof _.property; + export = property; +} + + +declare module "lodash/propertyOf" { + const propertyOf: typeof _.propertyOf; + export = propertyOf; +} + + +declare module "lodash/pull" { + const pull: typeof _.pull; + export = pull; +} + + +declare module "lodash/pullAll" { + const pullAll: typeof _.pullAll; + export = pullAll; +} + + +declare module "lodash/pullAllBy" { + const pullAllBy: typeof _.pullAllBy; + export = pullAllBy; +} + +/** + * uncoment it if definition exists + */ +/* + declare module "lodash/pullAllWith" { + const pullAllWith: typeof _.pullAllWith; + export = pullAllWith; + } + */ + +declare module "lodash/pullAt" { + const pullAt: typeof _.pullAt; + export = pullAt; +} + + +declare module "lodash/range" { + const range: typeof _.range; + export = range; +} + + +declare module "lodash/rangeRight" { + const rangeRight: typeof _.rangeRight; + export = rangeRight; +} + + +declare module "lodash/rearg" { + const rearg: typeof _.rearg; + export = rearg; +} + + +declare module "lodash/reject" { + const reject: typeof _.reject; + export = reject; +} + + +declare module "lodash/remove" { + const remove: typeof _.remove; + export = remove; +} + + +declare module "lodash/rest" { + const rest: typeof _.rest; + export = rest; +} + + +declare module "lodash/reverse" { + const reverse: typeof _.reverse; + export = reverse; +} + + +declare module "lodash/sampleSize" { + const sampleSize: typeof _.sampleSize; + export = sampleSize; +} + + +declare module "lodash/set" { + const set: typeof _.set; + export = set; +} + + +declare module "lodash/setWith" { + const setWith: typeof _.setWith; + export = setWith; +} + + +declare module "lodash/shuffle" { + const shuffle: typeof _.shuffle; + export = shuffle; +} + + +declare module "lodash/slice" { + const slice: typeof _.slice; + export = slice; +} + + +declare module "lodash/sortBy" { + const sortBy: typeof _.sortBy; + export = sortBy; +} + + +declare module "lodash/sortedUniq" { + const sortedUniq: typeof _.sortedUniq; + export = sortedUniq; +} + + +declare module "lodash/sortedUniqBy" { + const sortedUniqBy: typeof _.sortedUniqBy; + export = sortedUniqBy; +} + + +declare module "lodash/split" { + const split: typeof _.split; + export = split; +} + + +declare module "lodash/spread" { + const spread: typeof _.spread; + export = spread; +} + + +declare module "lodash/tail" { + const tail: typeof _.tail; + export = tail; +} + + +declare module "lodash/take" { + const take: typeof _.take; + export = take; +} + + +declare module "lodash/takeRight" { + const takeRight: typeof _.takeRight; + export = takeRight; +} + + +declare module "lodash/takeRightWhile" { + const takeRightWhile: typeof _.takeRightWhile; + export = takeRightWhile; +} + + +declare module "lodash/takeWhile" { + const takeWhile: typeof _.takeWhile; + export = takeWhile; +} + + +declare module "lodash/tap" { + const tap: typeof _.tap; + export = tap; +} + + +declare module "lodash/throttle" { + const throttle: typeof _.throttle; + export = throttle; +} + + +declare module "lodash/thru" { + const thru: typeof _.thru; + export = thru; +} + + +declare module "lodash/toArray" { + const toArray: typeof _.toArray; + export = toArray; +} + + +declare module "lodash/toPairs" { + const toPairs: typeof _.toPairs; + export = toPairs; +} + + +declare module "lodash/toPairsIn" { + const toPairsIn: typeof _.toPairsIn; + export = toPairsIn; +} + + +declare module "lodash/toPath" { + const toPath: typeof _.toPath; + export = toPath; +} + + +declare module "lodash/toPlainObject" { + const toPlainObject: typeof _.toPlainObject; + export = toPlainObject; +} + + +declare module "lodash/transform" { + const transform: typeof _.transform; + export = transform; +} + + +declare module "lodash/unary" { + const unary: typeof _.unary; + export = unary; +} + + +declare module "lodash/union" { + const union: typeof _.union; + export = union; +} + + +declare module "lodash/unionBy" { + const unionBy: typeof _.unionBy; + export = unionBy; +} + + +declare module "lodash/unionWith" { + const unionWith: typeof _.unionWith; + export = unionWith; +} + + +declare module "lodash/uniq" { + const uniq: typeof _.uniq; + export = uniq; +} + + +declare module "lodash/uniqBy" { + const uniqBy: typeof _.uniqBy; + export = uniqBy; +} + + +declare module "lodash/uniqWith" { + const uniqWith: typeof _.uniqWith; + export = uniqWith; +} + + +declare module "lodash/unset" { + const unset: typeof _.unset; + export = unset; +} + + +declare module "lodash/unzip" { + const unzip: typeof _.unzip; + export = unzip; +} + + +declare module "lodash/unzipWith" { + const unzipWith: typeof _.unzipWith; + export = unzipWith; +} + + +declare module "lodash/update" { + const update: typeof _.update; + export = update; +} + +/** + * uncoment it if definition exists + */ +/* + declare module "lodash/updateWith" { + const updateWith: typeof _.updateWith; + export = updateWith; + } + */ + +declare module "lodash/values" { + const values: typeof _.values; + export = values; +} + + +declare module "lodash/valuesIn" { + const valuesIn: typeof _.valuesIn; + export = valuesIn; +} + + +declare module "lodash/without" { + const without: typeof _.without; + export = without; +} + + +declare module "lodash/words" { + const words: typeof _.words; + export = words; +} + + +declare module "lodash/wrap" { + const wrap: typeof _.wrap; + export = wrap; +} + + +declare module "lodash/xor" { + const xor: typeof _.xor; + export = xor; +} + + +declare module "lodash/xorBy" { + const xorBy: typeof _.xorBy; + export = xorBy; +} + + +declare module "lodash/xorWith" { + const xorWith: typeof _.xorWith; + export = xorWith; +} + + +declare module "lodash/zip" { + const zip: typeof _.zip; + export = zip; +} + + +declare module "lodash/zipObject" { + const zipObject: typeof _.zipObject; + export = zipObject; +} + +/** + * uncoment it if definition exists + */ +/* + declare module "lodash/zipObjectDeep" { + const zipObjectDeep: typeof _.zipObjectDeep; + export = zipObjectDeep; + } + */ + + +declare module "lodash/zipWith" { + const zipWith: typeof _.zipWith; + export = zipWith; +} + +/** + * uncoment it if definition exists + */ +/* + declare module "lodash/entries" { + const entries: typeof _.entries; + export = entries; + } + */ +/** + * uncoment it if definition exists + */ +/* + declare module "lodash/entriesIn" { + const entriesIn: typeof _.entriesIn; + export = entriesIn; + } + */ + + +declare module "lodash/extend" { + const extend: typeof _.extend; + export = extend; +} + + +declare module "lodash/extendWith" { + const extendWith: typeof _.extendWith; + export = extendWith; +} + + +declare module "lodash/add" { + const add: typeof _.add; + export = add; +} + + +declare module "lodash/attempt" { + const attempt: typeof _.attempt; + export = attempt; +} + + +declare module "lodash/camelCase" { + const camelCase: typeof _.camelCase; + export = camelCase; +} + + +declare module "lodash/capitalize" { + const capitalize: typeof _.capitalize; + export = capitalize; +} + + +declare module "lodash/ceil" { + const ceil: typeof _.ceil; + export = ceil; +} + + +declare module "lodash/clamp" { + const clamp: typeof _.clamp; + export = clamp; +} + + +declare module "lodash/clone" { + const clone: typeof _.clone; + export = clone; +} + + +declare module "lodash/cloneDeep" { + const cloneDeep: typeof _.cloneDeep; + export = cloneDeep; +} + + +declare module "lodash/cloneDeepWith" { + const cloneDeepWith: typeof _.cloneDeepWith; + export = cloneDeepWith; +} + + +declare module "lodash/cloneWith" { + const cloneWith: typeof _.cloneWith; + export = cloneWith; +} + + +declare module "lodash/deburr" { + const deburr: typeof _.deburr; + export = deburr; +} + +/** + * uncoment it if definition exists + */ +/* + declare module "lodash/divide" { + const divide: typeof _.divide; + export = divide; + } + */ + +declare module "lodash/endsWith" { + const endsWith: typeof _.endsWith; + export = endsWith; +} + + +declare module "lodash/eq" { + const eq: typeof _.eq; + export = eq; +} + + +declare module "lodash/escape" { + const escape: typeof _.escape; + export = escape; +} + + +declare module "lodash/escapeRegExp" { + const escapeRegExp: typeof _.escapeRegExp; + export = escapeRegExp; +} + + +declare module "lodash/every" { + const every: typeof _.every; + export = every; +} + + +declare module "lodash/find" { + const find: typeof _.find; + export = find; +} + + +declare module "lodash/findIndex" { + const findIndex: typeof _.findIndex; + export = findIndex; +} + + +declare module "lodash/findKey" { + const findKey: typeof _.findKey; + export = findKey; +} + + +declare module "lodash/findLast" { + const findLast: typeof _.findLast; + export = findLast; +} + + +declare module "lodash/findLastIndex" { + const findLastIndex: typeof _.findLastIndex; + export = findLastIndex; +} + + +declare module "lodash/findLastKey" { + const findLastKey: typeof _.findLastKey; + export = findLastKey; +} + + +declare module "lodash/floor" { + const floor: typeof _.floor; + export = floor; +} + + +declare module "lodash/forEach" { + const forEach: typeof _.forEach; + export = forEach; +} + + +declare module "lodash/forEachRight" { + const forEachRight: typeof _.forEachRight; + export = forEachRight; +} + + +declare module "lodash/forIn" { + const forIn: typeof _.forIn; + export = forIn; +} + + +declare module "lodash/forInRight" { + const forInRight: typeof _.forInRight; + export = forInRight; +} + + +declare module "lodash/forOwn" { + const forOwn: typeof _.forOwn; + export = forOwn; +} + + +declare module "lodash/forOwnRight" { + const forOwnRight: typeof _.forOwnRight; + export = forOwnRight; +} + + +declare module "lodash/get" { + const get: typeof _.get; + export = get; +} + + +declare module "lodash/gt" { + const gt: typeof _.gt; + export = gt; +} + + +declare module "lodash/gte" { + const gte: typeof _.gte; + export = gte; +} + + +declare module "lodash/has" { + const has: typeof _.has; + export = has; +} + + +declare module "lodash/hasIn" { + const hasIn: typeof _.hasIn; + export = hasIn; +} + + +declare module "lodash/head" { + const head: typeof _.head; + export = head; +} + + +declare module "lodash/identity" { + const identity: typeof _.identity; + export = identity; +} + + +declare module "lodash/includes" { + const includes: typeof _.includes; + export = includes; +} + + +declare module "lodash/indexOf" { + const indexOf: typeof _.indexOf; + export = indexOf; +} + + +declare module "lodash/inRange" { + const inRange: typeof _.inRange; + export = inRange; +} + + +declare module "lodash/invoke" { + const invoke: typeof _.invoke; + export = invoke; +} + + +declare module "lodash/isArguments" { + const isArguments: typeof _.isArguments; + export = isArguments; +} + + +declare module "lodash/isArray" { + const isArray: typeof _.isArray; + export = isArray; +} + + +declare module "lodash/isArrayBuffer" { + const isArrayBuffer: typeof _.isArrayBuffer; + export = isArrayBuffer; +} + + +declare module "lodash/isArrayLike" { + const isArrayLike: typeof _.isArrayLike; + export = isArrayLike; +} + + +declare module "lodash/isArrayLikeObject" { + const isArrayLikeObject: typeof _.isArrayLikeObject; + export = isArrayLikeObject; +} + + +declare module "lodash/isBoolean" { + const isBoolean: typeof _.isBoolean; + export = isBoolean; +} + + +declare module "lodash/isBuffer" { + const isBuffer: typeof _.isBuffer; + export = isBuffer; +} + + +declare module "lodash/isDate" { + const isDate: typeof _.isDate; + export = isDate; +} + + +declare module "lodash/isElement" { + const isElement: typeof _.isElement; + export = isElement; +} + + +declare module "lodash/isEmpty" { + const isEmpty: typeof _.isEmpty; + export = isEmpty; +} + + +declare module "lodash/isEqual" { + const isEqual: typeof _.isEqual; + export = isEqual; +} + + +declare module "lodash/isEqualWith" { + const isEqualWith: typeof _.isEqualWith; + export = isEqualWith; +} + + +declare module "lodash/isError" { + const isError: typeof _.isError; + export = isError; +} + + +declare module "lodash/isFinite" { + const isFinite: typeof _.isFinite; + export = isFinite; +} + + +declare module "lodash/isFunction" { + const isFunction: typeof _.isFunction; + export = isFunction; +} + + +declare module "lodash/isInteger" { + const isInteger: typeof _.isInteger; + export = isInteger; +} + + +declare module "lodash/isLength" { + const isLength: typeof _.isLength; + export = isLength; +} + + +declare module "lodash/isMap" { + const isMap: typeof _.isMap; + export = isMap; +} + + +declare module "lodash/isMatch" { + const isMatch: typeof _.isMatch; + export = isMatch; +} + + +declare module "lodash/isMatchWith" { + const isMatchWith: typeof _.isMatchWith; + export = isMatchWith; +} + + +declare module "lodash/isNaN" { + const isNaN: typeof _.isNaN; + export = isNaN; +} + + +declare module "lodash/isNative" { + const isNative: typeof _.isNative; + export = isNative; +} + + +declare module "lodash/isNil" { + const isNil: typeof _.isNil; + export = isNil; +} + + +declare module "lodash/isNull" { + const isNull: typeof _.isNull; + export = isNull; +} + + +declare module "lodash/isNumber" { + const isNumber: typeof _.isNumber; + export = isNumber; +} + + +declare module "lodash/isObject" { + const isObject: typeof _.isObject; + export = isObject; +} + + +declare module "lodash/isObjectLike" { + const isObjectLike: typeof _.isObjectLike; + export = isObjectLike; +} + + +declare module "lodash/isPlainObject" { + const isPlainObject: typeof _.isPlainObject; + export = isPlainObject; +} + + +declare module "lodash/isRegExp" { + const isRegExp: typeof _.isRegExp; + export = isRegExp; +} + + +declare module "lodash/isSafeInteger" { + const isSafeInteger: typeof _.isSafeInteger; + export = isSafeInteger; +} + + +declare module "lodash/isSet" { + const isSet: typeof _.isSet; + export = isSet; +} + + +declare module "lodash/isString" { + const isString: typeof _.isString; + export = isString; +} + + +declare module "lodash/isSymbol" { + const isSymbol: typeof _.isSymbol; + export = isSymbol; +} + + +declare module "lodash/isTypedArray" { + const isTypedArray: typeof _.isTypedArray; + export = isTypedArray; +} + + +declare module "lodash/isUndefined" { + const isUndefined: typeof _.isUndefined; + export = isUndefined; +} + + +declare module "lodash/isWeakMap" { + const isWeakMap: typeof _.isWeakMap; + export = isWeakMap; +} + + +declare module "lodash/isWeakSet" { + const isWeakSet: typeof _.isWeakSet; + export = isWeakSet; +} + + +declare module "lodash/join" { + const join: typeof _.join; + export = join; +} + + +declare module "lodash/kebabCase" { + const kebabCase: typeof _.kebabCase; + export = kebabCase; +} + + +declare module "lodash/last" { + const last: typeof _.last; + export = last; +} + + +declare module "lodash/lastIndexOf" { + const lastIndexOf: typeof _.lastIndexOf; + export = lastIndexOf; +} + + +declare module "lodash/lowerCase" { + const lowerCase: typeof _.lowerCase; + export = lowerCase; +} + + +declare module "lodash/lowerFirst" { + const lowerFirst: typeof _.lowerFirst; + export = lowerFirst; +} + + +declare module "lodash/lt" { + const lt: typeof _.lt; + export = lt; +} + + +declare module "lodash/lte" { + const lte: typeof _.lte; + export = lte; +} + + +declare module "lodash/max" { + const max: typeof _.max; + export = max; +} + + +declare module "lodash/maxBy" { + const maxBy: typeof _.maxBy; + export = maxBy; +} + + +declare module "lodash/mean" { + const mean: typeof _.mean; + export = mean; +} + +/** + * uncoment it if definition exists + */ +/* + declare module "lodash/meanBy" { + const meanBy: typeof _.meanBy; + export = meanBy; + } + */ + +declare module "lodash/min" { + const min: typeof _.min; + export = min; +} + + +declare module "lodash/minBy" { + const minBy: typeof _.minBy; + export = minBy; +} + +/** + * uncoment it if definition exists + */ +/* + declare module "lodash/multiply" { + const multiply: typeof _.multiply; + export = multiply; + } + */ + +/** + * uncoment it if definition exists + */ +/* + declare module "lodash/nth" { + const nth: typeof _.nth; + export = nth; + } + */ + +declare module "lodash/noConflict" { + const noConflict: typeof _.noConflict; + export = noConflict; +} + + +declare module "lodash/noop" { + const noop: typeof _.noop; + export = noop; +} + + +declare module "lodash/now" { + const now: typeof _.now; + export = now; +} + + +declare module "lodash/pad" { + const pad: typeof _.pad; + export = pad; +} + + +declare module "lodash/padEnd" { + const padEnd: typeof _.padEnd; + export = padEnd; +} + + +declare module "lodash/padStart" { + const padStart: typeof _.padStart; + export = padStart; +} + + +declare module "lodash/parseInt" { + const parseInt: typeof _.parseInt; + export = parseInt; +} + + +declare module "lodash/random" { + const random: typeof _.random; + export = random; +} + + +declare module "lodash/reduce" { + const reduce: typeof _.reduce; + export = reduce; +} + + +declare module "lodash/reduceRight" { + const reduceRight: typeof _.reduceRight; + export = reduceRight; +} + + +declare module "lodash/repeat" { + const repeat: typeof _.repeat; + export = repeat; +} + + +declare module "lodash/replace" { + const replace: typeof _.replace; + export = replace; +} + + +declare module "lodash/result" { + const result: typeof _.result; + export = result; +} + + +declare module "lodash/round" { + const round: typeof _.round; + export = round; +} + + +declare module "lodash/runInContext" { + const runInContext: typeof _.runInContext; + export = runInContext; +} + + +declare module "lodash/sample" { + const sample: typeof _.sample; + export = sample; +} + + +declare module "lodash/size" { + const size: typeof _.size; + export = size; +} + + +declare module "lodash/snakeCase" { + const snakeCase: typeof _.snakeCase; + export = snakeCase; +} + + +declare module "lodash/some" { + const some: typeof _.some; + export = some; +} + + +declare module "lodash/sortedIndex" { + const sortedIndex: typeof _.sortedIndex; + export = sortedIndex; +} + + +declare module "lodash/sortedIndexBy" { + const sortedIndexBy: typeof _.sortedIndexBy; + export = sortedIndexBy; +} + + +declare module "lodash/sortedIndexOf" { + const sortedIndexOf: typeof _.sortedIndexOf; + export = sortedIndexOf; +} + + +declare module "lodash/sortedLastIndex" { + const sortedLastIndex: typeof _.sortedLastIndex; + export = sortedLastIndex; +} + + +declare module "lodash/sortedLastIndexBy" { + const sortedLastIndexBy: typeof _.sortedLastIndexBy; + export = sortedLastIndexBy; +} + + +declare module "lodash/sortedLastIndexOf" { + const sortedLastIndexOf: typeof _.sortedLastIndexOf; + export = sortedLastIndexOf; +} + + +declare module "lodash/startCase" { + const startCase: typeof _.startCase; + export = startCase; +} + + +declare module "lodash/startsWith" { + const startsWith: typeof _.startsWith; + export = startsWith; +} + + +declare module "lodash/subtract" { + const subtract: typeof _.subtract; + export = subtract; +} + + +declare module "lodash/sum" { + const sum: typeof _.sum; + export = sum; +} + + +declare module "lodash/sumBy" { + const sumBy: typeof _.sumBy; + export = sumBy; +} + + +declare module "lodash/template" { + const template: typeof _.template; + export = template; +} + + +declare module "lodash/times" { + const times: typeof _.times; + export = times; +} + + +declare module "lodash/toInteger" { + const toInteger: typeof _.toInteger; + export = toInteger; +} + + +declare module "lodash/toLength" { + const toLength: typeof _.toLength; + export = toLength; +} + + +declare module "lodash/toLower" { + const toLower: typeof _.toLower; + export = toLower; +} + + +declare module "lodash/toNumber" { + const toNumber: typeof _.toNumber; + export = toNumber; +} + + +declare module "lodash/toSafeInteger" { + const toSafeInteger: typeof _.toSafeInteger; + export = toSafeInteger; +} + + +declare module "lodash/toString" { + const toString: typeof _.toString; + export = toString; +} + + +declare module "lodash/toUpper" { + const toUpper: typeof _.toUpper; + export = toUpper; +} + + +declare module "lodash/trim" { + const trim: typeof _.trim; + export = trim; +} + + +declare module "lodash/trimEnd" { + const trimEnd: typeof _.trimEnd; + export = trimEnd; +} + + +declare module "lodash/trimStart" { + const trimStart: typeof _.trimStart; + export = trimStart; +} + + +declare module "lodash/truncate" { + const truncate: typeof _.truncate; + export = truncate; +} + + +declare module "lodash/unescape" { + const unescape: typeof _.unescape; + export = unescape; +} + + +declare module "lodash/uniqueId" { + const uniqueId: typeof _.uniqueId; + export = uniqueId; +} + + +declare module "lodash/upperCase" { + const upperCase: typeof _.upperCase; + export = upperCase; +} + + +declare module "lodash/upperFirst" { + const upperFirst: typeof _.upperFirst; + export = upperFirst; +} + + +declare module "lodash/each" { + const each: typeof _.each; + export = each; +} + + +declare module "lodash/eachRight" { + const eachRight: typeof _.eachRight; + export = eachRight; +} + + +declare module "lodash/first" { + const first: typeof _.first; + export = first; +} + +declare module "lodash/fp" { + export = _; +} + +declare module "lodash" { + export = _; +} + +/************************************************* + * * + * The lodash method _.XXX exported as a module. * + * * + *************************************************/ + + +declare module "lodash.after" { + const after: typeof _.after; + export = after; +} + + +declare module "lodash.ary" { + const ary: typeof _.ary; + export = ary; +} + + +declare module "lodash.assign" { + const assign: typeof _.assign; + export = assign; +} + + +declare module "lodash.assignIn" { + const assignIn: typeof _.assignIn; + export = assignIn; +} + + +declare module "lodash.assignInWith" { + const assignInWith: typeof _.assignInWith; + export = assignInWith; +} + + +declare module "lodash.assignWith" { + const assignWith: typeof _.assignWith; + export = assignWith; +} + + +declare module "lodash.at" { + const at: typeof _.at; + export = at; +} + + +declare module "lodash.before" { + const before: typeof _.before; + export = before; +} + + +declare module "lodash.bind" { + const bind: typeof _.bind; + export = bind; +} + + +declare module "lodash.bindAll" { + const bindAll: typeof _.bindAll; + export = bindAll; +} + + +declare module "lodash.bindKey" { + const bindKey: typeof _.bindKey; + export = bindKey; +} + + +declare module "lodash.castArray" { + const castArray: typeof _.castArray; + export = castArray; +} + + +declare module "lodash.chain" { + const chain: typeof _.chain; + export = chain; +} + + +declare module "lodash.chunk" { + const chunk: typeof _.chunk; + export = chunk; +} + + +declare module "lodash.compact" { + const compact: typeof _.compact; + export = compact; +} + + +declare module "lodash.concat" { + const concat: typeof _.concat; + export = concat; +} + +/** + * uncoment it if definition exists + */ +/* + declare module "lodash.cond" { + const cond: typeof _.cond; + export = cond; + } + */ + +/** + * uncoment it if definition exists + */ +/* + declare module "lodash.conforms" { + const conforms: typeof _.conforms; + export = conforms; + } + */ + +declare module "lodash.constant" { + const constant: typeof _.constant; + export = constant; +} + + +declare module "lodash.countBy" { + const countBy: typeof _.countBy; + export = countBy; +} + + +declare module "lodash.create" { + const create: typeof _.create; + export = create; +} + + +declare module "lodash.curry" { + const curry: typeof _.curry; + export = curry; +} + + +declare module "lodash.curryRight" { + const curryRight: typeof _.curryRight; + export = curryRight; +} + + +declare module "lodash.debounce" { + const debounce: typeof _.debounce; + export = debounce; +} + + +declare module "lodash.defaults" { + const defaults: typeof _.defaults; + export = defaults; +} + + +declare module "lodash.defaultsDeep" { + const defaultsDeep: typeof _.defaultsDeep; + export = defaultsDeep; +} + + +declare module "lodash.defer" { + const defer: typeof _.defer; + export = defer; +} + + +declare module "lodash.delay" { + const delay: typeof _.delay; + export = delay; +} + + +declare module "lodash.difference" { + const difference: typeof _.difference; + export = difference; +} + + +declare module "lodash.differenceBy" { + const differenceBy: typeof _.differenceBy; + export = differenceBy; +} + + +declare module "lodash.differenceWith" { + const differenceWith: typeof _.differenceWith; + export = differenceWith; +} + + +declare module "lodash.drop" { + const drop: typeof _.drop; + export = drop; +} + + +declare module "lodash.dropRight" { + const dropRight: typeof _.dropRight; + export = dropRight; +} + + +declare module "lodash.dropRightWhile" { + const dropRightWhile: typeof _.dropRightWhile; + export = dropRightWhile; +} + + +declare module "lodash.dropWhile" { + const dropWhile: typeof _.dropWhile; + export = dropWhile; +} + + +declare module "lodash.fill" { + const fill: typeof _.fill; + export = fill; +} + + +declare module "lodash.filter" { + const filter: typeof _.filter; + export = filter; +} + + +declare module "lodash.flatMap" { + const flatMap: typeof _.flatMap; + export = flatMap; +} + +/** + * uncoment it if definition exists + */ +/* + declare module "lodash.flatMapDeep" { + const flatMapDeep: typeof _.flatMapDeep; + export = flatMapDeep; + } + */ +/** + * uncoment it if definition exists + */ +/* + declare module "lodash.flatMapDepth" { + const flatMapDepth: typeof _.flatMapDepth; + export = flatMapDepth; + } + */ + +declare module "lodash.flatten" { + const flatten: typeof _.flatten; + export = flatten; +} + + +declare module "lodash.flattenDeep" { + const flattenDeep: typeof _.flattenDeep; + export = flattenDeep; +} + +declare module "lodash.flattenDepth" { + const flattenDepth: typeof _.flattenDepth; + export = flattenDepth; +} + +declare module "lodash.flip" { + const flip: typeof _.flip; + export = flip; +} + + +declare module "lodash.flow" { + const flow: typeof _.flow; + export = flow; +} + + +declare module "lodash.flowRight" { + const flowRight: typeof _.flowRight; + export = flowRight; +} + + +declare module "lodash.fromPairs" { + const fromPairs: typeof _.fromPairs; + export = fromPairs; +} + + +declare module "lodash.functions" { + const functions: typeof _.functions; + export = functions; +} + + +declare module "lodash.functionsIn" { + const functionsIn: typeof _.functionsIn; + export = functionsIn; +} + + +declare module "lodash.groupBy" { + const groupBy: typeof _.groupBy; + export = groupBy; +} + + +declare module "lodash.initial" { + const initial: typeof _.initial; + export = initial; +} + + +declare module "lodash.intersection" { + const intersection: typeof _.intersection; + export = intersection; +} + + +declare module "lodash.intersectionBy" { + const intersectionBy: typeof _.intersectionBy; + export = intersectionBy; +} + + +declare module "lodash.intersectionWith" { + const intersectionWith: typeof _.intersectionWith; + export = intersectionWith; +} + + +declare module "lodash.invert" { + const invert: typeof _.invert; + export = invert; +} + + +declare module "lodash.invertBy" { + const invertBy: typeof _.invertBy; + export = invertBy; +} + + +declare module "lodash.invokeMap" { + const invokeMap: typeof _.invokeMap; + export = invokeMap; +} + + +declare module "lodash.iteratee" { + const iteratee: typeof _.iteratee; + export = iteratee; +} + + +declare module "lodash.keyBy" { + const keyBy: typeof _.keyBy; + export = keyBy; +} + + +declare module "lodash.keys" { + const keys: typeof _.keys; + export = keys; +} + + +declare module "lodash.keysIn" { + const keysIn: typeof _.keysIn; + export = keysIn; +} + + +declare module "lodash.map" { + const map: typeof _.map; + export = map; +} + + +declare module "lodash.mapKeys" { + const mapKeys: typeof _.mapKeys; + export = mapKeys; +} + + +declare module "lodash.mapValues" { + const mapValues: typeof _.mapValues; + export = mapValues; +} + + +declare module "lodash.matches" { + const matches: typeof _.matches; + export = matches; +} + + +declare module "lodash.matchesProperty" { + const matchesProperty: typeof _.matchesProperty; + export = matchesProperty; +} + + +declare module "lodash.memoize" { + const memoize: typeof _.memoize; + export = memoize; +} + + +declare module "lodash.merge" { + const merge: typeof _.merge; + export = merge; +} + + +declare module "lodash.mergeWith" { + const mergeWith: typeof _.mergeWith; + export = mergeWith; +} + + +declare module "lodash.method" { + const method: typeof _.method; + export = method; +} + + +declare module "lodash.methodOf" { + const methodOf: typeof _.methodOf; + export = methodOf; +} + + +declare module "lodash.mixin" { + const mixin: typeof _.mixin; + export = mixin; +} + + +declare module "lodash.negate" { + const negate: typeof _.negate; + export = negate; +} + + +declare module "lodash.nthArg" { + const nthArg: typeof _.nthArg; + export = nthArg; +} + + +declare module "lodash.omit" { + const omit: typeof _.omit; + export = omit; +} + + +declare module "lodash.omitBy" { + const omitBy: typeof _.omitBy; + export = omitBy; +} + + +declare module "lodash.once" { + const once: typeof _.once; + export = once; +} + + +declare module "lodash.orderBy" { + const orderBy: typeof _.orderBy; + export = orderBy; +} + + +declare module "lodash.over" { + const over: typeof _.over; + export = over; +} + + +declare module "lodash.overArgs" { + const overArgs: typeof _.overArgs; + export = overArgs; +} + + +declare module "lodash.overEvery" { + const overEvery: typeof _.overEvery; + export = overEvery; +} + + +declare module "lodash.overSome" { + const overSome: typeof _.overSome; + export = overSome; +} + + +declare module "lodash.partial" { + const partial: typeof _.partial; + export = partial; +} + + +declare module "lodash.partialRight" { + const partialRight: typeof _.partialRight; + export = partialRight; +} + + +declare module "lodash.partition" { + const partition: typeof _.partition; + export = partition; +} + + +declare module "lodash.pick" { + const pick: typeof _.pick; + export = pick; +} + + +declare module "lodash.pickBy" { + const pickBy: typeof _.pickBy; + export = pickBy; +} + + +declare module "lodash.property" { + const property: typeof _.property; + export = property; +} + + +declare module "lodash.propertyOf" { + const propertyOf: typeof _.propertyOf; + export = propertyOf; +} + + +declare module "lodash.pull" { + const pull: typeof _.pull; + export = pull; +} + + +declare module "lodash.pullAll" { + const pullAll: typeof _.pullAll; + export = pullAll; +} + + +declare module "lodash.pullAllBy" { + const pullAllBy: typeof _.pullAllBy; + export = pullAllBy; +} + +/** + * uncoment it if definition exists + */ +/* + declare module "lodash.pullAllWith" { + const pullAllWith: typeof _.pullAllWith; + export = pullAllWith; + } + */ + +declare module "lodash.pullAt" { + const pullAt: typeof _.pullAt; + export = pullAt; +} + + +declare module "lodash.range" { + const range: typeof _.range; + export = range; +} + + +declare module "lodash.rangeRight" { + const rangeRight: typeof _.rangeRight; + export = rangeRight; +} + + +declare module "lodash.rearg" { + const rearg: typeof _.rearg; + export = rearg; +} + + +declare module "lodash.reject" { + const reject: typeof _.reject; + export = reject; +} + + +declare module "lodash.remove" { + const remove: typeof _.remove; + export = remove; +} + + +declare module "lodash.rest" { + const rest: typeof _.rest; + export = rest; +} + + +declare module "lodash.reverse" { + const reverse: typeof _.reverse; + export = reverse; +} + + +declare module "lodash.sampleSize" { + const sampleSize: typeof _.sampleSize; + export = sampleSize; +} + + +declare module "lodash.set" { + const set: typeof _.set; + export = set; +} + + +declare module "lodash.setWith" { + const setWith: typeof _.setWith; + export = setWith; +} + + +declare module "lodash.shuffle" { + const shuffle: typeof _.shuffle; + export = shuffle; +} + + +declare module "lodash.slice" { + const slice: typeof _.slice; + export = slice; +} + + +declare module "lodash.sortBy" { + const sortBy: typeof _.sortBy; + export = sortBy; +} + + +declare module "lodash.sortedUniq" { + const sortedUniq: typeof _.sortedUniq; + export = sortedUniq; +} + + +declare module "lodash.sortedUniqBy" { + const sortedUniqBy: typeof _.sortedUniqBy; + export = sortedUniqBy; +} + + +declare module "lodash.split" { + const split: typeof _.split; + export = split; +} + + +declare module "lodash.spread" { + const spread: typeof _.spread; + export = spread; +} + + +declare module "lodash.tail" { + const tail: typeof _.tail; + export = tail; +} + + +declare module "lodash.take" { + const take: typeof _.take; + export = take; +} + + +declare module "lodash.takeRight" { + const takeRight: typeof _.takeRight; + export = takeRight; +} + + +declare module "lodash.takeRightWhile" { + const takeRightWhile: typeof _.takeRightWhile; + export = takeRightWhile; +} + + +declare module "lodash.takeWhile" { + const takeWhile: typeof _.takeWhile; + export = takeWhile; +} + + +declare module "lodash.tap" { + const tap: typeof _.tap; + export = tap; +} + + +declare module "lodash.throttle" { + const throttle: typeof _.throttle; + export = throttle; +} + + +declare module "lodash.thru" { + const thru: typeof _.thru; + export = thru; +} + + +declare module "lodash.toArray" { + const toArray: typeof _.toArray; + export = toArray; +} + + +declare module "lodash.toPairs" { + const toPairs: typeof _.toPairs; + export = toPairs; +} + + +declare module "lodash.toPairsIn" { + const toPairsIn: typeof _.toPairsIn; + export = toPairsIn; +} + + +declare module "lodash.toPath" { + const toPath: typeof _.toPath; + export = toPath; +} + + +declare module "lodash.toPlainObject" { + const toPlainObject: typeof _.toPlainObject; + export = toPlainObject; +} + + +declare module "lodash.transform" { + const transform: typeof _.transform; + export = transform; +} + + +declare module "lodash.unary" { + const unary: typeof _.unary; + export = unary; +} + + +declare module "lodash.union" { + const union: typeof _.union; + export = union; +} + + +declare module "lodash.unionBy" { + const unionBy: typeof _.unionBy; + export = unionBy; +} + + +declare module "lodash.unionWith" { + const unionWith: typeof _.unionWith; + export = unionWith; +} + + +declare module "lodash.uniq" { + const uniq: typeof _.uniq; + export = uniq; +} + + +declare module "lodash.uniqBy" { + const uniqBy: typeof _.uniqBy; + export = uniqBy; +} + + +declare module "lodash.uniqWith" { + const uniqWith: typeof _.uniqWith; + export = uniqWith; +} + + +declare module "lodash.unset" { + const unset: typeof _.unset; + export = unset; +} + + +declare module "lodash.unzip" { + const unzip: typeof _.unzip; + export = unzip; +} + + +declare module "lodash.unzipWith" { + const unzipWith: typeof _.unzipWith; + export = unzipWith; +} + + +declare module "lodash.update" { + const update: typeof _.update; + export = update; +} + +/** + * uncoment it if definition exists + */ +/* + declare module "lodash.updateWith" { + const updateWith: typeof _.updateWith; + export = updateWith; + } + */ + +declare module "lodash.values" { + const values: typeof _.values; + export = values; +} + + +declare module "lodash.valuesIn" { + const valuesIn: typeof _.valuesIn; + export = valuesIn; +} + + +declare module "lodash.without" { + const without: typeof _.without; + export = without; +} + + +declare module "lodash.words" { + const words: typeof _.words; + export = words; +} + + +declare module "lodash.wrap" { + const wrap: typeof _.wrap; + export = wrap; +} + + +declare module "lodash.xor" { + const xor: typeof _.xor; + export = xor; +} + + +declare module "lodash.xorBy" { + const xorBy: typeof _.xorBy; + export = xorBy; +} + + +declare module "lodash.xorWith" { + const xorWith: typeof _.xorWith; + export = xorWith; +} + + +declare module "lodash.zip" { + const zip: typeof _.zip; + export = zip; +} + + +declare module "lodash.zipObject" { + const zipObject: typeof _.zipObject; + export = zipObject; +} + +/** + * uncoment it if definition exists + */ +/* + declare module "lodash.zipObjectDeep" { + const zipObjectDeep: typeof _.zipObjectDeep; + export = zipObjectDeep; + } + */ + + +declare module "lodash.zipWith" { + const zipWith: typeof _.zipWith; + export = zipWith; +} + +/** + * uncoment it if definition exists + */ +/* + declare module "lodash.entries" { + const entries: typeof _.entries; + export = entries; + } + */ +/** + * uncoment it if definition exists + */ +/* + declare module "lodash.entriesIn" { + const entriesIn: typeof _.entriesIn; + export = entriesIn; + } + */ + + +declare module "lodash.extend" { + const extend: typeof _.extend; + export = extend; +} + + +declare module "lodash.extendWith" { + const extendWith: typeof _.extendWith; + export = extendWith; +} + + +declare module "lodash.add" { + const add: typeof _.add; + export = add; +} + + +declare module "lodash.attempt" { + const attempt: typeof _.attempt; + export = attempt; +} + + +declare module "lodash.camelCase" { + const camelCase: typeof _.camelCase; + export = camelCase; +} + + +declare module "lodash.capitalize" { + const capitalize: typeof _.capitalize; + export = capitalize; +} + + +declare module "lodash.ceil" { + const ceil: typeof _.ceil; + export = ceil; +} + + +declare module "lodash.clamp" { + const clamp: typeof _.clamp; + export = clamp; +} + + +declare module "lodash.clone" { + const clone: typeof _.clone; + export = clone; +} + + +declare module "lodash.cloneDeep" { + const cloneDeep: typeof _.cloneDeep; + export = cloneDeep; +} + + +declare module "lodash.cloneDeepWith" { + const cloneDeepWith: typeof _.cloneDeepWith; + export = cloneDeepWith; +} + + +declare module "lodash.cloneWith" { + const cloneWith: typeof _.cloneWith; + export = cloneWith; +} + + +declare module "lodash.deburr" { + const deburr: typeof _.deburr; + export = deburr; +} + +/** + * uncoment it if definition exists + */ +/* + declare module "lodash.divide" { + const divide: typeof _.divide; + export = divide; + } + */ + +declare module "lodash.endsWith" { + const endsWith: typeof _.endsWith; + export = endsWith; +} + + +declare module "lodash.eq" { + const eq: typeof _.eq; + export = eq; +} + + +declare module "lodash.escape" { + const escape: typeof _.escape; + export = escape; +} + + +declare module "lodash.escapeRegExp" { + const escapeRegExp: typeof _.escapeRegExp; + export = escapeRegExp; +} + + +declare module "lodash.every" { + const every: typeof _.every; + export = every; +} + + +declare module "lodash.find" { + const find: typeof _.find; + export = find; +} + + +declare module "lodash.findIndex" { + const findIndex: typeof _.findIndex; + export = findIndex; +} + + +declare module "lodash.findKey" { + const findKey: typeof _.findKey; + export = findKey; +} + + +declare module "lodash.findLast" { + const findLast: typeof _.findLast; + export = findLast; +} + + +declare module "lodash.findLastIndex" { + const findLastIndex: typeof _.findLastIndex; + export = findLastIndex; +} + + +declare module "lodash.findLastKey" { + const findLastKey: typeof _.findLastKey; + export = findLastKey; +} + + +declare module "lodash.floor" { + const floor: typeof _.floor; + export = floor; +} + + +declare module "lodash.forEach" { + const forEach: typeof _.forEach; + export = forEach; +} + + +declare module "lodash.forEachRight" { + const forEachRight: typeof _.forEachRight; + export = forEachRight; +} + + +declare module "lodash.forIn" { + const forIn: typeof _.forIn; + export = forIn; +} + + +declare module "lodash.forInRight" { + const forInRight: typeof _.forInRight; + export = forInRight; +} + + +declare module "lodash.forOwn" { + const forOwn: typeof _.forOwn; + export = forOwn; +} + + +declare module "lodash.forOwnRight" { + const forOwnRight: typeof _.forOwnRight; + export = forOwnRight; +} + + +declare module "lodash.get" { + const get: typeof _.get; + export = get; +} + + +declare module "lodash.gt" { + const gt: typeof _.gt; + export = gt; +} + + +declare module "lodash.gte" { + const gte: typeof _.gte; + export = gte; +} + + +declare module "lodash.has" { + const has: typeof _.has; + export = has; +} + + +declare module "lodash.hasIn" { + const hasIn: typeof _.hasIn; + export = hasIn; +} + + +declare module "lodash.head" { + const head: typeof _.head; + export = head; +} + + +declare module "lodash.identity" { + const identity: typeof _.identity; + export = identity; +} + + +declare module "lodash.includes" { + const includes: typeof _.includes; + export = includes; +} + + +declare module "lodash.indexOf" { + const indexOf: typeof _.indexOf; + export = indexOf; +} + + +declare module "lodash.inRange" { + const inRange: typeof _.inRange; + export = inRange; +} + + +declare module "lodash.invoke" { + const invoke: typeof _.invoke; + export = invoke; +} + + +declare module "lodash.isArguments" { + const isArguments: typeof _.isArguments; + export = isArguments; +} + + +declare module "lodash.isArray" { + const isArray: typeof _.isArray; + export = isArray; +} + + +declare module "lodash.isArrayBuffer" { + const isArrayBuffer: typeof _.isArrayBuffer; + export = isArrayBuffer; +} + + +declare module "lodash.isArrayLike" { + const isArrayLike: typeof _.isArrayLike; + export = isArrayLike; +} + + +declare module "lodash.isArrayLikeObject" { + const isArrayLikeObject: typeof _.isArrayLikeObject; + export = isArrayLikeObject; +} + + +declare module "lodash.isBoolean" { + const isBoolean: typeof _.isBoolean; + export = isBoolean; +} + + +declare module "lodash.isBuffer" { + const isBuffer: typeof _.isBuffer; + export = isBuffer; +} + + +declare module "lodash.isDate" { + const isDate: typeof _.isDate; + export = isDate; +} + + +declare module "lodash.isElement" { + const isElement: typeof _.isElement; + export = isElement; +} + + +declare module "lodash.isEmpty" { + const isEmpty: typeof _.isEmpty; + export = isEmpty; +} + + +declare module "lodash.isEqual" { + const isEqual: typeof _.isEqual; + export = isEqual; +} + + +declare module "lodash.isEqualWith" { + const isEqualWith: typeof _.isEqualWith; + export = isEqualWith; +} + + +declare module "lodash.isError" { + const isError: typeof _.isError; + export = isError; +} + + +declare module "lodash.isFinite" { + const isFinite: typeof _.isFinite; + export = isFinite; +} + + +declare module "lodash.isFunction" { + const isFunction: typeof _.isFunction; + export = isFunction; +} + + +declare module "lodash.isInteger" { + const isInteger: typeof _.isInteger; + export = isInteger; +} + + +declare module "lodash.isLength" { + const isLength: typeof _.isLength; + export = isLength; +} + + +declare module "lodash.isMap" { + const isMap: typeof _.isMap; + export = isMap; +} + + +declare module "lodash.isMatch" { + const isMatch: typeof _.isMatch; + export = isMatch; +} + + +declare module "lodash.isMatchWith" { + const isMatchWith: typeof _.isMatchWith; + export = isMatchWith; +} + + +declare module "lodash.isNaN" { + const isNaN: typeof _.isNaN; + export = isNaN; +} + + +declare module "lodash.isNative" { + const isNative: typeof _.isNative; + export = isNative; +} + + +declare module "lodash.isNil" { + const isNil: typeof _.isNil; + export = isNil; +} + + +declare module "lodash.isNull" { + const isNull: typeof _.isNull; + export = isNull; +} + + +declare module "lodash.isNumber" { + const isNumber: typeof _.isNumber; + export = isNumber; +} + + +declare module "lodash.isObject" { + const isObject: typeof _.isObject; + export = isObject; +} + + +declare module "lodash.isObjectLike" { + const isObjectLike: typeof _.isObjectLike; + export = isObjectLike; +} + + +declare module "lodash.isPlainObject" { + const isPlainObject: typeof _.isPlainObject; + export = isPlainObject; +} + + +declare module "lodash.isRegExp" { + const isRegExp: typeof _.isRegExp; + export = isRegExp; +} + + +declare module "lodash.isSafeInteger" { + const isSafeInteger: typeof _.isSafeInteger; + export = isSafeInteger; +} + + +declare module "lodash.isSet" { + const isSet: typeof _.isSet; + export = isSet; +} + + +declare module "lodash.isString" { + const isString: typeof _.isString; + export = isString; +} + + +declare module "lodash.isSymbol" { + const isSymbol: typeof _.isSymbol; + export = isSymbol; +} + + +declare module "lodash.isTypedArray" { + const isTypedArray: typeof _.isTypedArray; + export = isTypedArray; +} + + +declare module "lodash.isUndefined" { + const isUndefined: typeof _.isUndefined; + export = isUndefined; +} + + +declare module "lodash.isWeakMap" { + const isWeakMap: typeof _.isWeakMap; + export = isWeakMap; +} + + +declare module "lodash.isWeakSet" { + const isWeakSet: typeof _.isWeakSet; + export = isWeakSet; +} + + +declare module "lodash.join" { + const join: typeof _.join; + export = join; +} + + +declare module "lodash.kebabCase" { + const kebabCase: typeof _.kebabCase; + export = kebabCase; +} + + +declare module "lodash.last" { + const last: typeof _.last; + export = last; +} + + +declare module "lodash.lastIndexOf" { + const lastIndexOf: typeof _.lastIndexOf; + export = lastIndexOf; +} + + +declare module "lodash.lowerCase" { + const lowerCase: typeof _.lowerCase; + export = lowerCase; +} + + +declare module "lodash.lowerFirst" { + const lowerFirst: typeof _.lowerFirst; + export = lowerFirst; +} + + +declare module "lodash.lt" { + const lt: typeof _.lt; + export = lt; +} + + +declare module "lodash.lte" { + const lte: typeof _.lte; + export = lte; +} + + +declare module "lodash.max" { + const max: typeof _.max; + export = max; +} + + +declare module "lodash.maxBy" { + const maxBy: typeof _.maxBy; + export = maxBy; +} + + +declare module "lodash.mean" { + const mean: typeof _.mean; + export = mean; +} + +/** + * uncoment it if definition exists + */ +/* + declare module "lodash.meanBy" { + const meanBy: typeof _.meanBy; + export = meanBy; + } + */ + +declare module "lodash.min" { + const min: typeof _.min; + export = min; +} + + +declare module "lodash.minBy" { + const minBy: typeof _.minBy; + export = minBy; +} + +/** + * uncoment it if definition exists + */ +/* + declare module "lodash.multiply" { + const multiply: typeof _.multiply; + export = multiply; + } + */ + +/** + * uncoment it if definition exists + */ +/* + declare module "lodash.nth" { + const nth: typeof _.nth; + export = nth; + } + */ + +declare module "lodash.noConflict" { + const noConflict: typeof _.noConflict; + export = noConflict; +} + + +declare module "lodash.noop" { + const noop: typeof _.noop; + export = noop; +} + + +declare module "lodash.now" { + const now: typeof _.now; + export = now; +} + + +declare module "lodash.pad" { + const pad: typeof _.pad; + export = pad; +} + + +declare module "lodash.padEnd" { + const padEnd: typeof _.padEnd; + export = padEnd; +} + + +declare module "lodash.padStart" { + const padStart: typeof _.padStart; + export = padStart; +} + + +declare module "lodash.parseInt" { + const parseInt: typeof _.parseInt; + export = parseInt; +} + + +declare module "lodash.random" { + const random: typeof _.random; + export = random; +} + + +declare module "lodash.reduce" { + const reduce: typeof _.reduce; + export = reduce; +} + + +declare module "lodash.reduceRight" { + const reduceRight: typeof _.reduceRight; + export = reduceRight; +} + + +declare module "lodash.repeat" { + const repeat: typeof _.repeat; + export = repeat; +} + + +declare module "lodash.replace" { + const replace: typeof _.replace; + export = replace; +} + + +declare module "lodash.result" { + const result: typeof _.result; + export = result; +} + + +declare module "lodash.round" { + const round: typeof _.round; + export = round; +} + + +declare module "lodash.runInContext" { + const runInContext: typeof _.runInContext; + export = runInContext; +} + + +declare module "lodash.sample" { + const sample: typeof _.sample; + export = sample; +} + + +declare module "lodash.size" { + const size: typeof _.size; + export = size; +} + + +declare module "lodash.snakeCase" { + const snakeCase: typeof _.snakeCase; + export = snakeCase; +} + + +declare module "lodash.some" { + const some: typeof _.some; + export = some; +} + + +declare module "lodash.sortedIndex" { + const sortedIndex: typeof _.sortedIndex; + export = sortedIndex; +} + + +declare module "lodash.sortedIndexBy" { + const sortedIndexBy: typeof _.sortedIndexBy; + export = sortedIndexBy; +} + + +declare module "lodash.sortedIndexOf" { + const sortedIndexOf: typeof _.sortedIndexOf; + export = sortedIndexOf; +} + + +declare module "lodash.sortedLastIndex" { + const sortedLastIndex: typeof _.sortedLastIndex; + export = sortedLastIndex; +} + + +declare module "lodash.sortedLastIndexBy" { + const sortedLastIndexBy: typeof _.sortedLastIndexBy; + export = sortedLastIndexBy; +} + + +declare module "lodash.sortedLastIndexOf" { + const sortedLastIndexOf: typeof _.sortedLastIndexOf; + export = sortedLastIndexOf; +} + + +declare module "lodash.startCase" { + const startCase: typeof _.startCase; + export = startCase; +} + + +declare module "lodash.startsWith" { + const startsWith: typeof _.startsWith; + export = startsWith; +} + + +declare module "lodash.subtract" { + const subtract: typeof _.subtract; + export = subtract; +} + + +declare module "lodash.sum" { + const sum: typeof _.sum; + export = sum; +} + + +declare module "lodash.sumBy" { + const sumBy: typeof _.sumBy; + export = sumBy; +} + + +declare module "lodash.template" { + const template: typeof _.template; + export = template; +} + + +declare module "lodash.times" { + const times: typeof _.times; + export = times; +} + + +declare module "lodash.toInteger" { + const toInteger: typeof _.toInteger; + export = toInteger; +} + + +declare module "lodash.toLength" { + const toLength: typeof _.toLength; + export = toLength; +} + + +declare module "lodash.toLower" { + const toLower: typeof _.toLower; + export = toLower; +} + + +declare module "lodash.toNumber" { + const toNumber: typeof _.toNumber; + export = toNumber; +} + + +declare module "lodash.toSafeInteger" { + const toSafeInteger: typeof _.toSafeInteger; + export = toSafeInteger; +} + + +declare module "lodash.toString" { + const toString: typeof _.toString; + export = toString; +} + + +declare module "lodash.toUpper" { + const toUpper: typeof _.toUpper; + export = toUpper; +} + + +declare module "lodash.trim" { + const trim: typeof _.trim; + export = trim; +} + + +declare module "lodash.trimEnd" { + const trimEnd: typeof _.trimEnd; + export = trimEnd; +} + + +declare module "lodash.trimStart" { + const trimStart: typeof _.trimStart; + export = trimStart; +} + + +declare module "lodash.truncate" { + const truncate: typeof _.truncate; + export = truncate; +} + + +declare module "lodash.unescape" { + const unescape: typeof _.unescape; + export = unescape; +} + + +declare module "lodash.uniqueId" { + const uniqueId: typeof _.uniqueId; + export = uniqueId; +} + + +declare module "lodash.upperCase" { + const upperCase: typeof _.upperCase; + export = upperCase; +} + + +declare module "lodash.upperFirst" { + const upperFirst: typeof _.upperFirst; + export = upperFirst; +} + + +declare module "lodash.each" { + const each: typeof _.each; + export = each; +} + + +declare module "lodash.eachRight" { + const eachRight: typeof _.eachRight; + export = eachRight; +} + + +declare module "lodash.first" { + const first: typeof _.first; + export = first; +} + +// Backward compatibility with --target es5 +interface Set<T> {} +interface Map<K, V> {} +interface WeakSet<T> {} +interface WeakMap<K, V> {}
\ No newline at end of file diff --git a/catalog-ui/typings/notifyjs/notifyjs.d.ts b/catalog-ui/typings/notifyjs/notifyjs.d.ts new file mode 100644 index 0000000000..f72828fc06 --- /dev/null +++ b/catalog-ui/typings/notifyjs/notifyjs.d.ts @@ -0,0 +1,125 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ +// Type definitions for notify.js 1.2.0 +// Project: https://github.com/alexgibson/notify.js +// Definitions by: soundTricker <https://github.com/soundTricker> +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +declare var Notify: { + new (title : string , options? : notifyjs.INotifyOption): notifyjs.INotify; + + /** + * Check is permission is needed for the user to receive notifications. + * @return true : needs permission, false : does not need + */ + needsPermission() : boolean; + + /** + * Asks the user for permission to display notifications + * @param onPermissionGrantedCallback A callback for permmision is granted. + * @param onPermissionDeniedCallback A callback for permmision is denied. + */ + requestPermission(onPermissionGrantedCallback?: ()=> any, onPermissionDeniedCallback? : ()=> any) : void; + + /** + * return true if the browser supports HTML5 Notification + * @param true : the browser supports HTML5 Notification, false ; the browswer does not supports HTML5 Notification. + */ + isSupported() : boolean; +} + +declare module notifyjs { + + /** + * Interface for Web Notifications API Wrapper. + */ + interface INotify { + /** + * Show the notification. + */ + show() : void; + + /** + * Remove all event listener. + */ + destroy() : void; + + /** + * Close the notification. + */ + close() : void; + onShowNotification(e : Event) : void; + onCloseNotification() : void; + onClickNotification() : void; + onErrorNotification() : void; + handleEvent(e : Event) : void; + } + + /** + * Interface for the Notify's optional parameter. + */ + interface INotifyOption { + + /** + * notification message body + */ + body? : string; + + /** + * path for icon to display in notification + */ + icon? : string; + + /** + * unique identifier to stop duplicate notifications + */ + tag? : string; + + /** + * number of seconds to close the notification automatically + */ + timeout? : number; + + /** + * callback when notification is shown + */ + notifyShow? (e : Event): any; + /** + * callback when notification is closed + */ + notifyClose? : Function; + /** + * callback when notification is clicked + */ + notifyClick? : Function; + /** + * callback when notification throws an error + */ + notifyError? : Function; + /** + * callback when user has granted permission + */ + permissionGranted? : Function; + /** + * callback when user has denied permission + */ + permissionDenied? : Function; + } +} diff --git a/catalog-ui/typings/tsd.d.ts b/catalog-ui/typings/tsd.d.ts new file mode 100644 index 0000000000..4fe638ef72 --- /dev/null +++ b/catalog-ui/typings/tsd.d.ts @@ -0,0 +1,21 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ +/// <reference path="notifyjs/notifyjs.d.ts" /> +/// <reference path="jasmine/jasmine.d.ts" /> |