pax_global_header00006660000000000000000000000064126635032430014516gustar00rootroot0000000000000052 comment=1dffd25c96537f537e6b5df729f1466c0d78219b WebDevelopment-assignment-2/000077500000000000000000000000001266350324300163075ustar00rootroot00000000000000WebDevelopment-assignment-2/.gitignore000066400000000000000000000000371266350324300202770ustar00rootroot00000000000000dist gulpfile.js* node_modules WebDevelopment-assignment-2/.openshift/000077500000000000000000000000001266350324300203645ustar00rootroot00000000000000WebDevelopment-assignment-2/.openshift/README.md000066400000000000000000000002341266350324300216420ustar00rootroot00000000000000For information about .openshift directory, consult the documentation: http://openshift.github.io/documentation/oo_user_guide.html#the-openshift-directory WebDevelopment-assignment-2/.openshift/action_hooks/000077500000000000000000000000001266350324300230445ustar00rootroot00000000000000WebDevelopment-assignment-2/.openshift/action_hooks/README.md000066400000000000000000000002111266350324300243150ustar00rootroot00000000000000For information about action hooks, consult the documentation: http://openshift.github.io/documentation/oo_user_guide.html#action-hooks WebDevelopment-assignment-2/.openshift/action_hooks/build000077500000000000000000000031311266350324300240670ustar00rootroot00000000000000#!/bin/bash # This is a simple build script and will be executed on your CI system if # available. Otherwise it will execute while your application is stopped # before the deploy step. This script gets executed directly, so it # could be python, php, ruby, etc. # Source utility functions. source "$OPENSHIFT_REPO_DIR/.openshift/lib/utils" # Setup path to include the custom Node[.js] version. _SHOW_SETUP_PATH_MESSAGES="true" setup_path_for_custom_node_version # So we we moved the package.json file out of the way in pre_build, # so that the OpenShift git post-receive hook doesn't try and use the # old npm version to install the dependencies. Move it back in. tmp_package_json="$(get_node_tmp_dir)/package.json" if [ -f "$tmp_package_json" ]; then # Only overlay it if there is no current package.json file. [ -f "${OPENSHIFT_REPO_DIR}/package.json" ] || \ mv "$tmp_package_json" "${OPENSHIFT_REPO_DIR}/package.json" fi # Do npm install with the new npm binary. if [ -f "${OPENSHIFT_REPO_DIR}"/package.json ]; then echo " - Installing dependencies w/ new version of npm ... " echo (cd "${OPENSHIFT_REPO_DIR}"; export TMPDIR="/tmp"; npm install -d) fi ############# # Use gulp to transpile/minify code before running it # TODO: check if gulp needs to touch files # else remove changes to $HOME OLD_HOME=$HOME cd $OPENSHIFT_REPO_DIR export HOME=$OPENSHIFT_REPO_DIR echo "INFO: running 'typings install'" typings install echo "INFO: running 'tsc' to generate gulpfile.js" tsc echo "INFO: Running 'gulp' (default task)" gulp export HOME=$OLD_HOME echo "INFO: HOME is $HOME"WebDevelopment-assignment-2/.openshift/action_hooks/deploy000077500000000000000000000010001266350324300242550ustar00rootroot00000000000000#!/bin/bash # This deploy hook gets executed after dependencies are resolved and the # build hook has been run but before the application has been started back # up again. This script gets executed directly, so it could be python, php, # ruby, etc. # Source utility functions. source "$OPENSHIFT_REPO_DIR/.openshift/lib/utils" # On slave/serving gears, need to do the install as part of deploy # so check if its needed. Just ensure the custom Node[.js] version is # installed. ensure_node_is_installed WebDevelopment-assignment-2/.openshift/action_hooks/post_deploy000077500000000000000000000002711266350324300253330ustar00rootroot00000000000000#!/bin/bash # This is a simple post deploy hook executed after your application # is deployed and started. This script gets executed directly, so # it could be python, php, ruby, etc. WebDevelopment-assignment-2/.openshift/action_hooks/post_start_nodejs000077500000000000000000000025121266350324300265360ustar00rootroot00000000000000#!/bin/bash # The pre_start_cartridge and pre_stop_cartridge hooks are *SOURCED* # immediately before (re)starting or stopping the specified cartridge. # They are able to make any desired environment variable changes as # well as other adjustments to the application environment. # The post_start_cartridge and post_stop_cartridge hooks are executed # immediately after (re)starting or stopping the specified cartridge. # Exercise caution when adding commands to these hooks. They can # prevent your application from stopping cleanly or starting at all. # Application start and stop is subject to different timeouts # throughout the system. # Source utility functions. source "$OPENSHIFT_REPO_DIR/.openshift/lib/utils" # Get the node version. ver=$(get_node_version) # Set URI to the custom sample /env route. app_uri="http://$OPENSHIFT_GEAR_DNS/env" # Wait a bit to give the server time to come up. sleep 5 # Check if the app_uri is available - user code could have removed the # one in the sample -- we just print this for sanity testing. zcode=$(curl --write-out %{http_code} -s -o /dev/null "$app_uri") if [ "$zcode" -eq 200 ]; then echo "" echo " - Using Node.js version $ver, checking app URI ... " echo " - test URI = $app_uri" echo " - Version from test URI = $(curl -s $app_uri | grep 'Version')" echo "" fi WebDevelopment-assignment-2/.openshift/action_hooks/post_start_nodejs-0.6000077700000000000000000000000001266350324300325162post_start_nodejsustar00rootroot00000000000000WebDevelopment-assignment-2/.openshift/action_hooks/post_stop_nodejs000077500000000000000000000012051266350324300263640ustar00rootroot00000000000000#!/bin/bash # The pre_start_cartridge and pre_stop_cartridge hooks are *SOURCED* # immediately before (re)starting or stopping the specified cartridge. # They are able to make any desired environment variable changes as # well as other adjustments to the application environment. # The post_start_cartridge and post_stop_cartridge hooks are executed # immediately after (re)starting or stopping the specified cartridge. # Exercise caution when adding commands to these hooks. They can # prevent your application from stopping cleanly or starting at all. # Application start and stop is subject to different timeouts # throughout the system. WebDevelopment-assignment-2/.openshift/action_hooks/post_stop_nodejs-0.6000077700000000000000000000000001266350324300321762post_stop_nodejsustar00rootroot00000000000000WebDevelopment-assignment-2/.openshift/action_hooks/pre_build000077500000000000000000000012451266350324300247410ustar00rootroot00000000000000#!/bin/bash # This is a simple script and will be executed on your CI system if # available. Otherwise it will execute while your application is stopped # before the build step. This script gets executed directly, so it # could be python, php, ruby, etc. # Source utility functions. source "$OPENSHIFT_REPO_DIR/.openshift/lib/utils" # Ensure custom node version if not installed. echo "" ensure_node_is_installed # We need to move the package.json file out of the way in pre_build, so # that the OpenShift git post-receive hook doesn't try and use the old # npm version to install the dependencies. mv "${OPENSHIFT_REPO_DIR}/package.json" "$(get_node_tmp_dir)" WebDevelopment-assignment-2/.openshift/action_hooks/pre_start_nodejs000077500000000000000000000016751266350324300263500ustar00rootroot00000000000000#!/bin/bash # The pre_start_cartridge and pre_stop_cartridge hooks are *SOURCED* # immediately before (re)starting or stopping the specified cartridge. # They are able to make any desired environment variable changes as # well as other adjustments to the application environment. # The post_start_cartridge and post_stop_cartridge hooks are executed # immediately after (re)starting or stopping the specified cartridge. # Exercise caution when adding commands to these hooks. They can # prevent your application from stopping cleanly or starting at all. # Application start and stop is subject to different timeouts # throughout the system. # Source utility functions. source "$OPENSHIFT_REPO_DIR/.openshift/lib/utils" # Setup path to include the custom Node[.js] version. ver=$(get_node_version) echo "" echo " - pre_start_nodejs: Adding Node.js version $ver binaries to path" _SHOW_SETUP_PATH_MESSAGES="true" setup_path_for_custom_node_version WebDevelopment-assignment-2/.openshift/action_hooks/pre_start_nodejs-0.6000077700000000000000000000000001266350324300321202pre_start_nodejsustar00rootroot00000000000000WebDevelopment-assignment-2/.openshift/action_hooks/pre_stop_nodejs000077500000000000000000000021571266350324300261740ustar00rootroot00000000000000#!/bin/bash # The pre_start_cartridge and pre_stop_cartridge hooks are *SOURCED* # immediately before (re)starting or stopping the specified cartridge. # They are able to make any desired environment variable changes as # well as other adjustments to the application environment. # The post_start_cartridge and post_stop_cartridge hooks are executed # immediately after (re)starting or stopping the specified cartridge. # Exercise caution when adding commands to these hooks. They can # prevent your application from stopping cleanly or starting at all. # Application start and stop is subject to different timeouts # throughout the system. # First time in .openshift/lib/utils might not exist, so add a check # to ensure file exists. if [ -f "$OPENSHIFT_REPO_DIR/.openshift/lib/utils" ]; then # Source utility functions. source "$OPENSHIFT_REPO_DIR/.openshift/lib/utils" # Setup path to include the custom Node[.js] version. ver=$(get_node_version) echo "" echo " - pre_stop_nodejs: Adding Node.js version $ver binaries to path" _SHOW_SETUP_PATH_MESSAGES="true" setup_path_for_custom_node_version fi WebDevelopment-assignment-2/.openshift/action_hooks/pre_stop_nodejs-0.6000077700000000000000000000000001266350324300316002pre_stop_nodejsustar00rootroot00000000000000WebDevelopment-assignment-2/.openshift/cron/000077500000000000000000000000001266350324300213255ustar00rootroot00000000000000WebDevelopment-assignment-2/.openshift/cron/README.cron000066400000000000000000000023011266350324300231410ustar00rootroot00000000000000Run scripts or jobs on a periodic basis ======================================= Any scripts or jobs added to the minutely, hourly, daily, weekly or monthly directories will be run on a scheduled basis (frequency is as indicated by the name of the directory) using run-parts. run-parts ignores any files that are hidden or dotfiles (.*) or backup files (*~ or *,) or named *.{rpmsave,rpmorig,rpmnew,swp,cfsaved} The presence of two specially named files jobs.deny and jobs.allow controls how run-parts executes your scripts/jobs. jobs.deny ===> Prevents specific scripts or jobs from being executed. jobs.allow ===> Only execute the named scripts or jobs (all other/non-named scripts that exist in this directory are ignored). The principles of jobs.deny and jobs.allow are the same as those of cron.deny and cron.allow and are described in detail at: http://docs.redhat.com/docs/en-US/Red_Hat_Enterprise_Linux/6/html/Deployment_Guide/ch-Automating_System_Tasks.html#s2-autotasks-cron-access See: man crontab or above link for more details and see the the weekly/ directory for an example. PLEASE NOTE: The Cron cartridge must be installed in order to run the configured jobs. WebDevelopment-assignment-2/.openshift/cron/daily/000077500000000000000000000000001266350324300224275ustar00rootroot00000000000000WebDevelopment-assignment-2/.openshift/cron/daily/.gitignore000066400000000000000000000000001266350324300244050ustar00rootroot00000000000000WebDevelopment-assignment-2/.openshift/cron/hourly/000077500000000000000000000000001266350324300226475ustar00rootroot00000000000000WebDevelopment-assignment-2/.openshift/cron/hourly/.gitignore000066400000000000000000000000001266350324300246250ustar00rootroot00000000000000WebDevelopment-assignment-2/.openshift/cron/minutely/000077500000000000000000000000001266350324300231735ustar00rootroot00000000000000WebDevelopment-assignment-2/.openshift/cron/minutely/.gitignore000066400000000000000000000000001266350324300251510ustar00rootroot00000000000000WebDevelopment-assignment-2/.openshift/cron/monthly/000077500000000000000000000000001266350324300230175ustar00rootroot00000000000000WebDevelopment-assignment-2/.openshift/cron/monthly/.gitignore000066400000000000000000000000001266350324300247750ustar00rootroot00000000000000WebDevelopment-assignment-2/.openshift/cron/weekly/000077500000000000000000000000001266350324300226255ustar00rootroot00000000000000WebDevelopment-assignment-2/.openshift/cron/weekly/README000066400000000000000000000013501266350324300235040ustar00rootroot00000000000000Run scripts or jobs on a weekly basis ===================================== Any scripts or jobs added to this directory will be run on a scheduled basis (weekly) using run-parts. run-parts ignores any files that are hidden or dotfiles (.*) or backup files (*~ or *,) or named *.{rpmsave,rpmorig,rpmnew,swp,cfsaved} and handles the files named jobs.deny and jobs.allow specially. In this specific example, the chronograph script is the only script or job file executed on a weekly basis (due to white-listing it in jobs.allow). And the README and chrono.dat file are ignored either as a result of being black-listed in jobs.deny or because they are NOT white-listed in the jobs.allow file. For more details, please see ../README.cron file. WebDevelopment-assignment-2/.openshift/cron/weekly/chrono.dat000066400000000000000000000000621266350324300246050ustar00rootroot00000000000000Time And Relative D...n In Execution (Open)Shift! WebDevelopment-assignment-2/.openshift/cron/weekly/chronograph000077500000000000000000000000771266350324300250710ustar00rootroot00000000000000#!/bin/bash echo "`date`: `cat $(dirname \"$0\")/chrono.dat`" WebDevelopment-assignment-2/.openshift/cron/weekly/jobs.allow000066400000000000000000000006241266350324300246240ustar00rootroot00000000000000# # Script or job files listed in here (one entry per line) will be # executed on a weekly-basis. # # Example: The chronograph script will be executed weekly but the README # and chrono.dat files in this directory will be ignored. # # The README file is actually ignored due to the entry in the # jobs.deny which is checked before jobs.allow (this file). # chronograph WebDevelopment-assignment-2/.openshift/cron/weekly/jobs.deny000066400000000000000000000002041266350324300244370ustar00rootroot00000000000000# # Any script or job files listed in here (one entry per line) will NOT be # executed (read as ignored by run-parts). # README WebDevelopment-assignment-2/.openshift/lib/000077500000000000000000000000001266350324300211325ustar00rootroot00000000000000WebDevelopment-assignment-2/.openshift/lib/setup_custom_nodejs_env000066400000000000000000000021361266350324300260230ustar00rootroot00000000000000# Utility functions for bash session - sourced in via the user's # bash profile ($OPENSHIFT_DATA_DIR/.bash_profile). # Source utility functions. source $OPENSHIFT_REPO_DIR/.openshift/lib/utils # Internal function to setup path and remove the wrappers. function _setup_path_and_remove_wrappers() { # First invocation of npm or node, so setup the custom path and # unset the wrappers. Add the custom node binaries to the PATH. [ -z "$ZDEBUG" ] || echo "Setting path to include custom Node version" setup_path_for_custom_node_version unset node unset npm unset _setup_path_and_remove_wrappers } # End of function _setup_path_and_remove_wrappers. # Temporary wrapper function to setup path before invoking npm. function npm() { # Setup path, remove wrappers and reinvoke npm. _setup_path_and_remove_wrappers npm "$@" } # End of function npm. # Temporary wrapper function to setup path before invoking node. function node() { # Setup path, remove wrappers and reinvoke node. _setup_path_and_remove_wrappers node "$@" } # End of function node. # # EOF WebDevelopment-assignment-2/.openshift/lib/utils000077500000000000000000000115461266350324300222270ustar00rootroot00000000000000#!/bin/bash # # Utility functions. # # Returns the configured Node version - defaults to 0.8.24. function get_node_version() { marker="$OPENSHIFT_REPO_DIR/.openshift/markers/NODEJS_VERSION" nodejs_ver=$(egrep -v "^\s*#.*" "$marker" | egrep -v "^\s*$" | tail -1) echo "${nodejs_ver:-"0.8.24"}" } # End of function get_node_version. # Returns the directory where Node is to be installed/is installed. function get_node_install_dir() { echo "$OPENSHIFT_DATA_DIR" } # End of function get_node_install_dir. # Returns the path to the npm binary. function get_npm_bin_path() { ver=${1:-"$(get_node_version)"} echo "$(get_node_install_dir)/node-v$ver-linux-x64/bin" } # End of function get_npm_bin_path. # Returns the path to the node binary. function get_node_bin_path() { echo "$(get_npm_bin_path $@)" } # End of function get_node_bin_path. # Returns the temporary directory we use for processing. function get_node_tmp_dir() { ztmpdir="$OPENSHIFT_DATA_DIR/.nodejs.tmp" # Ensure temp directory is created. [ -d "$ztmpdir" ] || mkdir -p "$ztmpdir" echo "$ztmpdir" } # End of function get_node_tmp_dir. # # Download and install the specified Node.js version. # function _install_nodejs() { ver=${1:-"$(get_node_version)"} # Sample download links: # http://nodejs.org/dist/v0.8.24/node-v0.8.24-linux-x64.tar.gz # http://nodejs.org/dist/v0.10.10/node-v0.10.10-linux-x64.tar.gz zfile="node-v${ver}-linux-x64.tar.gz" zlink="http://nodejs.org/dist/v${ver}/${zfile}" instdir="$(get_node_install_dir)" # Download and extract the gzipped tarball. dldir="$OPENSHIFT_DATA_DIR/downloads" mkdir -p "$dldir" echo " - Downloading and extracting $zlink ... " if ! curl -L -o "$dldir/$zfile" "$zlink"; then echo " - ERROR -- download failed for $zlink" echo " - download uri = $dldir/$zfile" return 1 fi (cd "$instdir"; tar -zxf "$dldir/$zfile") echo " - Done installing Node.js version $ver" } # End of function _install_nodejs. # Ensure npm and node symlinks exist in ~/.node_modules/.bin/ directory. function _ensure_symlinks_in_node_modules_bin_dir() { zdir="$HOME/.node_modules/.bin/" if [ -d "$zdir" ]; then ln -sf "$(get_npm_bin_path)/npm" "$zdir" ln -sf "$(get_node_bin_path)/node" "$zdir" fi } # End of function _ensure_symlinks_in_node_modules_bin_dir. # Ensure context - this is a bit too hacky. function _ensure_context_exists() { zenv="$OPENSHIFT_HOMEDIR/nodejs/configuration/node.env" if ! egrep '^\s*function\s+nodejs_context' "$zenv" > /dev/null 2>&1; then echo -e "function nodejs_context() { bash -c \"\$@\"; }\n" >> "$zenv" || : fi } # End of function _ensure_context_exists. # Ensure the shell env setup bits are added to user's .bash_profile. function _ensure_bash_profile_setup() { dot_bash_profile=$OPENSHIFT_DATA_DIR/.bash_profile pattern='\s*source(.*)\.openshift/lib/setup_custom_nodejs_env\s*(.*)\s*' if ! egrep "$pattern" $dot_bash_profile > /dev/null 2>&1 ; then cat >> $dot_bash_profile < /// import {Gulpclass, SequenceTask, Task } from "gulpclass/Decorators"; import * as gulp from 'gulp' import * as del from 'del' import * as ts from 'gulp-typescript' import * as sourcemaps from 'gulp-sourcemaps' @Gulpclass() export class Gulpfile { @Task("clean") clean() { return del('dist') } @Task("build:server") buildServer() { const tsProject = ts.createProject('server/tsconfig.json') const tsResult = gulp.src('server/**/*.ts') .pipe(sourcemaps.init()) .pipe(ts(tsProject)) .js .pipe(sourcemaps.write()) .pipe(gulp.dest('dist')) return tsResult } @Task("build:public") buildPublic() { const tsProject = ts.createProject('public/tsconfig.json') const tsResult = gulp.src('public/**/*.ts') .pipe(sourcemaps.init()) .pipe(ts(tsProject)) .js .pipe(gulp.dest('dist')) const html = gulp.src('public/**/*.html') .pipe(gulp.dest('dist')) const css = gulp.src('public/**/*.css') .pipe(gulp.dest('dist')) return [tsResult, html, css] } @SequenceTask("build") build() { return ["clean", "build:server", "build:public"] } @SequenceTask("default") default() { return ["build"] } }WebDevelopment-assignment-2/package.json000066400000000000000000000017361266350324300206040ustar00rootroot00000000000000{ "name": "CS4550-sp2016", "version": "1.0.0", "description": "Course project for CS4550 spring 2016", "keywords": [ "OpenShift", "Node.js", "application", "openshift" ], "author": { "name": "Ian Redpath", "email": "iredpath@ccs.neu.edu", "url": "http://www.github.com/iredpath" }, "homepage": "http://www.webdevelopment-redpathian.rhcloud.com", "repository": { "type": "git", "url": "https://github.com/iredpath/WebDevelopment" }, "engines": { "node": ">= 5.4.0", "npm": ">= 3.3.12" }, "dependencies": { "express": "^4.13.4" }, "devDependencies": { "angular2": "^2.0.0-beta.7", "del": "^2.2.0", "gulp": "^3.9.1", "gulp-sourcemaps": "^1.6.0", "gulp-typescript": "^2.11.0", "gulpclass": "0.0.8", "run-sequence": "^1.1.5", "rxjs": "^5.0.0-beta.2", "tsc": "^1.20150623.0", "typescript": "^1.7.5", "typings": "^0.6.8" }, "main": "dist/server.js", "scripts": { } } WebDevelopment-assignment-2/public/000077500000000000000000000000001266350324300175655ustar00rootroot00000000000000WebDevelopment-assignment-2/public/assignment/000077500000000000000000000000001266350324300217355ustar00rootroot00000000000000WebDevelopment-assignment-2/public/assignment/app.ts000066400000000000000000000020541266350324300230660ustar00rootroot00000000000000/// import { bootstrap } from 'angular2/platform/browser' import { provide, Component, View } from 'angular2/core' import { RouteConfig, ROUTER_PROVIDERS, ROUTER_DIRECTIVES, LocationStrategy, HashLocationStrategy } from 'angular2/router' import { HeaderController } from './views/header/header.controller' import { SidebarController } from './views/sidebar/sidebar.controller' import { ROUTER_CONFIG } from './router/config' import { UserService } from './services/user.service.client' import { StateService } from './services/state.service.client' import { FormsService } from './services/forms.service.client' import { UserFactory } from './models/user.factory' @Component({ selector: 'form-maker-app' }) @View({ templateUrl: './app.view.html', directives: [HeaderController, SidebarController, ROUTER_DIRECTIVES] }) @RouteConfig(ROUTER_CONFIG) class App {} bootstrap(App, [UserService, StateService, FormsService, UserFactory, ROUTER_PROVIDERS, provide(LocationStrategy, { useClass: HashLocationStrategy })])WebDevelopment-assignment-2/public/assignment/app.view.html000066400000000000000000000002431266350324300243530ustar00rootroot00000000000000 WebDevelopment-assignment-2/public/assignment/css/000077500000000000000000000000001266350324300225255ustar00rootroot00000000000000WebDevelopment-assignment-2/public/assignment/css/dashboard.css000066400000000000000000000030241266350324300251650ustar00rootroot00000000000000/* * Base structure */ /* Move down content because we have a fixed navbar that is 50px tall */ body { padding-top: 50px; } /* * Global add-ons */ .sub-header { padding-bottom: 10px; border-bottom: 1px solid #eee; } /* * Top navigation * Hide default border to remove 1px line. */ .navbar-fixed-top { border: 0; } /* * Sidebar */ /* Hide for mobile, show later */ .sidebar { display: none; } @media (min-width: 768px) { .sidebar { position: fixed; top: 51px; bottom: 0; left: 0; z-index: 1000; display: block; padding: 20px; overflow-x: hidden; overflow-y: auto; /* Scrollable contents if viewport is shorter than content. */ background-color: #f5f5f5; border-right: 1px solid #eee; } } /* Sidebar navigation */ .nav-sidebar { margin-right: -21px; /* 20px padding + 1px border */ margin-bottom: 20px; margin-left: -20px; } .nav-sidebar > li > a { padding-right: 20px; padding-left: 20px; } .nav-sidebar > .active > a, .nav-sidebar > .active > a:hover, .nav-sidebar > .active > a:focus { color: #fff; background-color: #428bca; } /* * Main content */ .main { padding: 20px; } @media (min-width: 768px) { .main { padding-right: 40px; padding-left: 40px; } } .main .page-header { margin-top: 0; } /* * Placeholder dashboard ideas */ .placeholders { margin-bottom: 30px; text-align: center; } .placeholders h4 { margin-bottom: 0; } .placeholder { margin-bottom: 20px; } .placeholder img { display: inline-block; border-radius: 50%; }WebDevelopment-assignment-2/public/assignment/css/style.css000066400000000000000000000007371266350324300244060ustar00rootroot00000000000000span.glyphicon:hover { cursor: pointer; color: #337ab7; text-decoration: none; } .icon-div-2 > span { width: 50%; max-width: 30px; float: left; } .icon-div-4 > span { width: 25%; max-width: 30px; float: left; } .icon-div-4 > .left-spacer { height: 1px; /* will not space without height >= 1 */ } .nav-tabs { margin-bottom: 25px; } .add-new-field-div { border-top: 1px solid #eee; margin-top: 20px; padding-top: 20px; } .nav > li > a:hover { cursor: pointer; }WebDevelopment-assignment-2/public/assignment/index.html000066400000000000000000000045221266350324300237350ustar00rootroot00000000000000 Form Maker Loading... WebDevelopment-assignment-2/public/assignment/models/000077500000000000000000000000001266350324300232205ustar00rootroot00000000000000WebDevelopment-assignment-2/public/assignment/models/form.model.ts000066400000000000000000000007251266350324300256360ustar00rootroot00000000000000import { Injectable } from 'angular2/core' @Injectable() export class Form { _id:number userId:number title:string constructor() { this.title = "" } setId(id: number) { this._id = id } setUserId(id:number) { this.userId = id } getId() { return this._id } getUserId() { return this.userId } getTitle() { return this.title } configure(formData:any) { this._id = formData._id this.userId = formData.userId this.title = formData.title } }WebDevelopment-assignment-2/public/assignment/models/user.factory.ts000066400000000000000000000003131266350324300262110ustar00rootroot00000000000000import { Injectable } from 'angular2/core' import { User } from './user.model' @Injectable() export class UserFactory { newUser() { return new User() } static newUser() { return new User() } }WebDevelopment-assignment-2/public/assignment/models/user.model.ts000066400000000000000000000016101266350324300256430ustar00rootroot00000000000000import { Injectable } from 'angular2/core' @Injectable() export class User { _id:number username:string password:string firstName:string lastName:string email:string roles:Array constructor() { this.username = "" this.password = "" this.firstName = "" this.lastName = "" this.email = "" this.roles = [] } setId(id: number) { this._id = id } getId() { return this._id } getUsername() { return this.username } getPassword() { return this.password } getFirstName() { return this.firstName } getLastName() { return this.lastName } getEmail() { return this.email } getRoles() { return this.roles } configure(userData:any) { this._id = userData._id this.username = userData.username this.password = userData.password this.firstName = userData.firstName this.lastName = userData.lastName this.email = userData.email this.roles = userData.roles } }WebDevelopment-assignment-2/public/assignment/router/000077500000000000000000000000001266350324300232555ustar00rootroot00000000000000WebDevelopment-assignment-2/public/assignment/router/config.ts000066400000000000000000000017241266350324300250760ustar00rootroot00000000000000import { HeaderController } from '../views/header/header.controller' import { SidebarController } from '../views/sidebar/sidebar.controller' import { HomeController } from '../views/home/home.controller' import { FormsController } from '../views/forms/forms.controller' import { AdminController } from '../views/admin/admin.controller' import { ProfileController } from '../views/users/profile.controller' import { RegisterController } from '../views/users/register.controller' import { LoginController } from '../views/users/login.controller' export const ROUTER_CONFIG = [ { path: '/home', component: HomeController, as: "Home", useAsDefault: true }, { path: '/forms', component: FormsController, as: "Forms" }, { path: '/admin', component: AdminController, as: "Admin" }, { path: '/profile', component: ProfileController, as: "Profile" }, { path: '/register', component: RegisterController, as: "Register" }, { path: '/login', component: LoginController, as: "Login" } ]WebDevelopment-assignment-2/public/assignment/services/000077500000000000000000000000001266350324300235605ustar00rootroot00000000000000WebDevelopment-assignment-2/public/assignment/services/forms.service.client.ts000066400000000000000000000020441266350324300301720ustar00rootroot00000000000000import { Injectable } from 'angular2/core' import { Form } from '../models/form.model' @Injectable() export class FormsService { forms:Array
constructor() { const formData = [ {"_id": "000", "title": "Contacts", "userId": 123}, {"_id": "010", "title": "ToDo", "userId": 123}, {"_id": "020", "title": "CDs", "userId": 234}, ] // Create forms based on formData this.forms = _.map(formData, (formObj) => { let form = new Form() form.configure(formObj) return form }) } createFormForUser(userId, form, callback) { form.setId((new Date).getTime()) form.setUserId(userId) this.forms.push(form) callback(form) } findAllFormForUser(userId, callback) { callback(_.filter(this.forms, form => form.getUserId() === userId)) } deleteFormById(formId, callback) { callback(_.remove(this.forms, form => form.getId() === formId)) } updateFormById(formId, newForm, callback) { callback(_.forEach(this.forms, form => { if(form.getId() === formId) { form = newForm return } })) } }WebDevelopment-assignment-2/public/assignment/services/state.service.client.ts000066400000000000000000000010571266350324300301670ustar00rootroot00000000000000import { Injectable } from 'angular2/core' import { User } from '../models/user.model' import { UserFactory } from '../models/user.factory' @Injectable() export class StateService { activeUser: User constructor(public userFactory:UserFactory) { this.activeUser = userFactory.newUser() } setActiveUser(user) { this.activeUser = user } getActiveUser() { return this.activeUser } isActiveUser() { return !!this.activeUser.getId() } isActiveAdminUser() { return this.isActiveUser() && _.includes(this.activeUser.getRoles(), "admin") } }WebDevelopment-assignment-2/public/assignment/services/user.service.client.ts000066400000000000000000000033101266350324300300170ustar00rootroot00000000000000import { Injectable } from 'angular2/core' import { User } from '../models/user.model' import { UserFactory } from '../models/user.factory' @Injectable() export class UserService { users:Array constructor(public userFactory:UserFactory) { const userData = [ { "_id":123, "firstName":"Alice", "lastName":"Wonderland", "username":"alice", "password":"alice", "roles": ["student"] }, { "_id":234, "firstName":"Bob", "lastName":"Hope", "username":"bob", "password":"bob", "roles": ["admin"] }, { "_id":345, "firstName":"Charlie", "lastName":"Brown", "username":"charlie", "password":"charlie", "roles": ["faculty"] }, { "_id":456, "firstName":"Dan", "lastName":"Craig", "username":"dan", "password":"dan", "roles": ["faculty", "admin"] }, { "_id":567, "firstName":"Edward", "lastName":"Norton", "username":"ed", "password":"ed", "roles": ["student"] } ] // Create users based on userData this.users = _.map(userData, (userData) => { let user = this.userFactory.newUser() user.configure(userData) return user }) } findUserByCredentials(username, password, callback) { let user:User for(user of this.users) { if(user.getUsername() === username && user.getPassword() === password) { callback(user) return } } callback(null) } findAllUsers(callback) { callback(this.users) } createUser(user, callback) { user.setId((new Date).getTime()) this.users.push(user) callback(user) } deleteUserById(userId, callback) { callback(_.remove(this.users, user => { user.getId() === userId })) } updateUser(userId, user, callback) { callback(_.forEach(this.users, oldUser => { if(user._id === userId) { oldUser = user return } })) } }WebDevelopment-assignment-2/public/assignment/views/000077500000000000000000000000001266350324300230725ustar00rootroot00000000000000WebDevelopment-assignment-2/public/assignment/views/admin/000077500000000000000000000000001266350324300241625ustar00rootroot00000000000000WebDevelopment-assignment-2/public/assignment/views/admin/admin.controller.ts000066400000000000000000000010741266350324300300060ustar00rootroot00000000000000import { View, Component } from 'angular2/core' import { Router } from 'angular2/router' import { StateService } from '../../services/state.service.client' import { User } from '../../models/user.model' @Component({ selector: "form-builder-admin" }) @View({ templateUrl: "/assignment/views/admin/admin.view.html" }) export class AdminController { user:User constructor(public stateService:StateService, public router:Router) { if (!stateService.isActiveUser()) { router.navigate(['/Login', {}]) } else { this.user = stateService.getActiveUser() } } }WebDevelopment-assignment-2/public/assignment/views/admin/admin.view.html000066400000000000000000000040511266350324300271110ustar00rootroot00000000000000

Admin

Users

Username
Password
Role
Action
alice student
bob faculty | admin
charlie
WebDevelopment-assignment-2/public/assignment/views/app.view.html000066400000000000000000000002651266350324300255140ustar00rootroot00000000000000

app view

WebDevelopment-assignment-2/public/assignment/views/bootstrap.ts000066400000000000000000000006371266350324300254650ustar00rootroot00000000000000import { bootstrap } from 'angular2/platform/browser' import { provide } from 'angular2/core' import { CORE_DIRECTIVES } from 'angular2/common' import { ROUTER_BINDINGS, ROUTER_PROVIDERS, LocationStrategy, PathLocationStrategy } from 'angular2/router' import { Main } from './main' bootstrap(Main, [ ROUTER_PROVIDERS, CORE_DIRECTIVES, provide(LocationStrategy, { useClass: PathLocationStrategy }) ]); WebDevelopment-assignment-2/public/assignment/views/forms/000077500000000000000000000000001266350324300242205ustar00rootroot00000000000000WebDevelopment-assignment-2/public/assignment/views/forms/form-fields.view.html000066400000000000000000000114771266350324300303000ustar00rootroot00000000000000

Forms : Registration Form

WebDevelopment-assignment-2/public/assignment/views/forms/forms.controller.ts000066400000000000000000000026241266350324300301040ustar00rootroot00000000000000import { View, Component } from 'angular2/core' import { Router } from 'angular2/router' import { Form } from '../../models/form.model' import { FormsService } from '../../services/forms.service.client' import { StateService } from '../../services/state.service.client' @Component({ selector: "form-builder-forms" }) @View({ templateUrl: "/assignment/views/forms/forms.view.html" }) export class FormsController { form:Form forms:Array
constructor(public formsService:FormsService, public stateService:StateService, public router:Router) { if (!stateService.isActiveUser()) { router.navigate(['/Login', {}]) } else { this.form = new Form() formsService.findAllFormForUser(stateService.getActiveUser().getId(), forms => { this.forms = forms }) } } addForm() { const callback = form => console.log(`added form ${form} successfully`) const activeUser = this.stateService.getActiveUser() this.formsService.createFormForUser(activeUser.getId(), this.form, callback) } updateForm() { const callback = forms => this.forms = forms this.formsService.updateFormById(this.form.getId(), this.form, callback) } deleteForm(selected:Form) { if(selected.getId() === this.form.getId()) { this.form = new Form() } const callback = forms => this.forms = forms this.formsService.deleteFormById(selected.getId(), callback) } selectForm(selected:Form) { this.form = selected } }WebDevelopment-assignment-2/public/assignment/views/forms/forms.view.html000066400000000000000000000025541266350324300272130ustar00rootroot00000000000000

Forms

Form Name
Action
{{form.title}}
WebDevelopment-assignment-2/public/assignment/views/header/000077500000000000000000000000001266350324300243225ustar00rootroot00000000000000WebDevelopment-assignment-2/public/assignment/views/header/header.controller.ts000066400000000000000000000016271266350324300303120ustar00rootroot00000000000000import { View, Component } from 'angular2/core' import { RouterLink, Router, Location } from 'angular2/router' import { StateService } from '../../services/state.service.client' import { UserFactory } from '../../models/user.factory' @Component({ selector: "form-builder-header" }) @View({ templateUrl: "/assignment/views/header/header.view.html", directives: [RouterLink] }) export class HeaderController { location:Location constructor(public userFactory:UserFactory, public stateService:StateService, public router:Router, location:Location) { this.location = location } isRouteActive(route) { return this.location.path().indexOf(route) > -1 } isActiveUser() { return this.stateService.isActiveUser() } isActiveAdminUser() { return this.stateService.isActiveAdminUser() } logout() { this.stateService.setActiveUser(this.userFactory.newUser()) this.router.navigate(['/Home', {}]) } }WebDevelopment-assignment-2/public/assignment/views/header/header.view.html000066400000000000000000000026461266350324300274210ustar00rootroot00000000000000 WebDevelopment-assignment-2/public/assignment/views/home/000077500000000000000000000000001266350324300240225ustar00rootroot00000000000000WebDevelopment-assignment-2/public/assignment/views/home/home.controller.ts000066400000000000000000000003011266350324300274760ustar00rootroot00000000000000import { View, Component } from 'angular2/core' @Component({ selector: "FormBuilder-Home" }) @View({ templateUrl: "/assignment/views/home/home.view.html" }) export class HomeController { }WebDevelopment-assignment-2/public/assignment/views/home/home.view.html000066400000000000000000000010741266350324300266130ustar00rootroot00000000000000

Welcome!

Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

WebDevelopment-assignment-2/public/assignment/views/main.ts000066400000000000000000000007431266350324300243720ustar00rootroot00000000000000import { Component } from 'angular2/core'; import { Router, RouteConfig, ROUTER_DIRECTIVES } from 'angular2/router' import { HomeController } from './home/home.controller' @RouteConfig([ { path: '/', component: HomeController, as: 'Home' } ]) @Component({ selector: 'app-body', template: '', directives: [ ROUTER_DIRECTIVES ] }) export class Main { constructor() { console.log("We are up and running!"); } }WebDevelopment-assignment-2/public/assignment/views/sidebar/000077500000000000000000000000001266350324300245035ustar00rootroot00000000000000WebDevelopment-assignment-2/public/assignment/views/sidebar/sidebar.controller.ts000066400000000000000000000014471266350324300306540ustar00rootroot00000000000000import { View, Component } from 'angular2/core' import { RouterLink, Router, Location } from 'angular2/router' import { StateService } from '../../services/state.service.client' import { UserFactory } from '../../models/user.factory' @Component({ selector: "form-builder-sidebar" }) @View({ templateUrl: "/assignment/views/sidebar/sidebar.view.html", directives: [RouterLink] }) export class SidebarController { location:Location constructor(public userFactory:UserFactory, public stateService:StateService, public router:Router, location:Location) { this.location = location } isRouteActive(route) { return this.location.path().indexOf(route) > -1 } isActiveUser() { return this.stateService.isActiveUser() } isActiveAdminUser() { return this.stateService.isActiveAdminUser() } }WebDevelopment-assignment-2/public/assignment/views/sidebar/sidebar.view.html000066400000000000000000000013041266350324300277510ustar00rootroot00000000000000
WebDevelopment-assignment-2/public/assignment/views/users/000077500000000000000000000000001266350324300242335ustar00rootroot00000000000000WebDevelopment-assignment-2/public/assignment/views/users/login.controller.ts000066400000000000000000000017701266350324300301020ustar00rootroot00000000000000import { View, Component, Inject } from 'angular2/core' import { Router } from 'angular2/router' import { UserService } from '../../services/user.service.client' import { StateService } from '../../services/state.service.client' import { User } from '../../models/user.model' import { UserFactory } from '../../models/user.factory' @Component({ selector: "form-builder-login" }) @View({ templateUrl: "/assignment/views/users/login.view.html", directives: [] }) export class LoginController { user:User constructor( public userService:UserService, public stateService:StateService, public router:Router, public userFactory:UserFactory ) { this.user = stateService.getActiveUser() } login() { this.userService.findUserByCredentials(this.user.getUsername(), this.user.getPassword(), resp => { if (resp) { this.stateService.setActiveUser(resp) this.router.navigate(['/Profile', {}]) } else { alert('Invalid name/password') this.user = this.userFactory.newUser() } }) } }WebDevelopment-assignment-2/public/assignment/views/users/login.view.html000066400000000000000000000015441266350324300272060ustar00rootroot00000000000000

Login

Login
WebDevelopment-assignment-2/public/assignment/views/users/profile.controller.ts000066400000000000000000000014661266350324300304340ustar00rootroot00000000000000import { View, Component } from 'angular2/core' import { Router } from 'angular2/router' import { UserService } from '../../services/user.service.client' import { StateService } from '../../services/state.service.client' import { User } from '../../models/user.model' @Component({ selector: "form-builder-profile" }) @View({ templateUrl: "/assignment/views/users/profile.view.html" }) export class ProfileController { user: User constructor(public userService: UserService, public stateService: StateService, public router: Router) { if (!stateService.isActiveUser()) { router.navigate(['/Login', {}]) } else { this.user = stateService.getActiveUser() } } update() { this.userService.updateUser(this.user.getId(), this.user, resp => { console.log("successfully updated user " + resp) }) } }WebDevelopment-assignment-2/public/assignment/views/users/profile.view.html000066400000000000000000000032261266350324300275350ustar00rootroot00000000000000

Profile

Update
WebDevelopment-assignment-2/public/assignment/views/users/register.controller.ts000066400000000000000000000016051266350324300306130ustar00rootroot00000000000000import { View, Component, Inject } from 'angular2/core' import { Router } from 'angular2/router' import { UserService } from '../../services/user.service.client' import { StateService } from '../../services/state.service.client' import { User } from '../../models/user.model' import { UserFactory } from '../../models/user.factory' @Component({ selector: "form-builder-register" }) @View({ templateUrl: "/assignment/views/users/register.view.html" }) export class RegisterController { user:User constructor( public userService:UserService, public stateService:StateService, public router:Router, public userFactory:UserFactory ) { this.user = stateService.getActiveUser() } register() { this.userService.createUser(this.user, resp => { console.log('successfully created user ' + resp) this.stateService.setActiveUser(resp) this.router.navigate(['/Profile', {}]) }) } }WebDevelopment-assignment-2/public/assignment/views/users/register.view.html000066400000000000000000000026001266350324300277140ustar00rootroot00000000000000

Register

Register
WebDevelopment-assignment-2/public/css/000077500000000000000000000000001266350324300203555ustar00rootroot00000000000000WebDevelopment-assignment-2/public/css/index.css000066400000000000000000000004301266350324300221730ustar00rootroot00000000000000body { padding-top: 50px; } .main { padding: 20px; } @media (min-width: 768px) { .main { padding-right: 40px; padding-left: 40px; } } .main .page-header { margin-top: 0; } .form-maker { margin-bottom: 30px; } .virtual-movie-library-link > a { display: block; }WebDevelopment-assignment-2/public/index.html000066400000000000000000000056611266350324300215720ustar00rootroot00000000000000 CS4550 Spring 2016

Form Maker

A basic user interface for creating, updating, and answering forms. Developers can create forms, and view or download responses as CSV files. Submitters can fill out and submit all of these forms. This application uses the MEAN stack, consisting of MongoDB, Express, Angularjs, and NodeJS.

Visit Form Maker

Virtual Movie Library

A simple, elegant way to display your movie collection. Create lists to show off what you own, what you wish you had, or any other grouping you can think of. If you mark your libraries as public, you can receive comments and ratings from other users! Movie data is taken directly from IMDB, you can add any movie in the database by its title.

Show me! Project Proposal
WebDevelopment-assignment-2/public/tsconfig.json000077500000000000000000000004471266350324300223040ustar00rootroot00000000000000{ "compilerOptions": { "target": "ES5", "module": "system", "moduleResolution": "node", "sourceMap": true, "emitDecoratorMetadata": true, "experimentalDecorators": true, "removeComments": false, "noImplicitAny": false }, "filesGlob": [ "./**/*.ts" ] }WebDevelopment-assignment-2/scripts/000077500000000000000000000000001266350324300177765ustar00rootroot00000000000000WebDevelopment-assignment-2/scripts/bash/000077500000000000000000000000001266350324300207135ustar00rootroot00000000000000WebDevelopment-assignment-2/scripts/bash/deploy-branch.sh000077500000000000000000000017411266350324300240040ustar00rootroot00000000000000#!/bin/bash BRANCH_NAME=$1 if [ -z $BRANCH_NAME ]; then echo "Usage: deploy-branch branch-name" exit 1 fi echo "INFO: checking out ${BRANCH_NAME}" git checkout $BRANCH_NAME if [ $? -ne 0 ]; then echo "ERROR: unable to checkout branch $BRANCH_NAME" exit 1 fi echo "INFO: pushing ${BRANCH_NAME} to openshift remote repository" git push -u origin $BRANCH_NAME if [ $? -ne 0 ]; then echo "ERROR: unable to push ${BRANCH_NAME} to remote" exit 1 fi echo "INFO: deploying from branch ${BRANCH_NAME}" rhc deploy $BRANCH_NAME -a WebDevelopment if [ $? -ne 0 ]; then echo "ERROR: failure deploying from ${BRANCH_NAME}. Falling back to master" rhc deploy master -a WebDevelopment if [ $? -ne 0 ]; then echo "ERROR: failure deploying master" # this should NEVER happen, master is expected to be clean else echo "INFO: successfully deployed branch master" fi else echo "INFO: branch ${BRANCH_NAME} deployed successfully" echo "INFO: feel free to merge ${BRANCH_NAME} into master" fi WebDevelopment-assignment-2/scripts/bash/merge-branch.sh000077500000000000000000000027221266350324300236070ustar00rootroot00000000000000#!/bin/bash BRANCH_NAME=$1 if [ -z $BRANCH_NAME ]; then echo "Usage: merge-branch branch-name" exit 1 fi # checkout master git checkout master if [ $? -ne 0 ]; then echo "ERROR: unable to checkout branch master" exit 1 fi # reset master to track origin git branch -u origin/master if [ $? -ne 0 ]; then echo "ERROR: unable to set local master branch to track from origin/master" exit 1 fi # merge in our branch git merge $BRANCH_NAME if [ $? -ne 0 ]; then echo "ERROR: unable to merge branch $BRANCH_NAME with master" exit 1 else: echo "INFO: branch ${BRANCH_NAME} successfully merged into openshift master" fi # push changes to openshift git push -u origin master if [ $? -ne 0 ]; then echo "ERROR: unable to push changes to openshift remote" exit 1 else: echo "INFO: local changes successfully pushed to openshift master" fi # deploy master rhc deploy master -a WebDevelopment if [ $? -ne 0 ]; then echo "ERROR: unable to deploy branch master" # should never happen, this script is only run after successful deploy exit 1 else: echo "INFO: openshift master branch successfully delpoyed" fi # push to github git push -u github master if [ $? -ne 0 ]; then echo "ERROR: unable to push changes to github remote" exit 1 else: echo "INFO: openshift master branch successfully pushed to github" fi # reset master to track origin git branch -u origin/master if [ $? -ne 0 ]; then echo "ERROR: unable to set local master branch to track from origin/master" exit 1 fi WebDevelopment-assignment-2/server/000077500000000000000000000000001266350324300176155ustar00rootroot00000000000000WebDevelopment-assignment-2/server/server.ts000077500000000000000000000004371266350324300215020ustar00rootroot00000000000000import * as express from 'express' import * as path from 'path' const ipaddress:string = process.env.OPENSHIFT_NODEJS_IP || '127.0.0.1'; const port:number = process.env.OPENSHIFT_NODEJS_PORT || 3000; let app = express(); app.use(express.static(__dirname)) app.listen(port, ipaddress) WebDevelopment-assignment-2/server/tsconfig.json000077500000000000000000000003431266350324300223270ustar00rootroot00000000000000{ "compilerOptions": { "target": "ES5", "module": "commonjs", "sourceMap": true, "emitDecoratorMetadata": true, "experimentalDecorators": true, "removeComments": false, "noImplicitAny": false } }WebDevelopment-assignment-2/server/typings/000077500000000000000000000000001266350324300213125ustar00rootroot00000000000000WebDevelopment-assignment-2/server/typings/express/000077500000000000000000000000001266350324300230035ustar00rootroot00000000000000WebDevelopment-assignment-2/server/typings/express/express.d.ts000077500000000000000000001151061266350324300252750ustar00rootroot00000000000000// Type definitions for Express 4.x // Project: http://expressjs.com // Definitions by: Boris Yankov // Definitions: https://github.com/borisyankov/DefinitelyTyped /* =================== USAGE =================== import * as express from "express"; var app = express(); =============================================== */ /// /// declare module Express { // These open interfaces may be extended in an application-specific manner via declaration merging. // See for example method-override.d.ts (https://github.com/borisyankov/DefinitelyTyped/blob/master/method-override/method-override.d.ts) export interface Request { } export interface Response { } export interface Application { } } declare module "express" { import * as http from "http"; import * as serveStatic from "serve-static"; function e(): e.Express; module e { interface IRoute { path: string; stack: any; all(...handler: RequestHandler[]): IRoute; get(...handler: RequestHandler[]): IRoute; post(...handler: RequestHandler[]): IRoute; put(...handler: RequestHandler[]): IRoute; delete(...handler: RequestHandler[]): IRoute; patch(...handler: RequestHandler[]): IRoute; options(...handler: RequestHandler[]): IRoute; head(...handler: RequestHandler[]): IRoute; } interface IRouterMatcher { (name: string, ...handlers: RequestHandler[]): T; (name: RegExp, ...handlers: RequestHandler[]): T; } interface IRouter extends RequestHandler { /** * Map the given param placeholder `name`(s) to the given callback(s). * * Parameter mapping is used to provide pre-conditions to routes * which use normalized placeholders. For example a _:user_id_ parameter * could automatically load a user's information from the database without * any additional code, * * The callback uses the samesignature as middleware, the only differencing * being that the value of the placeholder is passed, in this case the _id_ * of the user. Once the `next()` function is invoked, just like middleware * it will continue on to execute the route, or subsequent parameter functions. * * app.param('user_id', function(req, res, next, id){ * User.find(id, function(err, user){ * if (err) { * next(err); * } else if (user) { * req.user = user; * next(); * } else { * next(new Error('failed to load user')); * } * }); * }); * * @param name * @param fn */ param(name: string, handler: RequestParamHandler): T; param(name: string, matcher: RegExp): T; param(name: string, mapper: (param: any) => any): T; // Alternatively, you can pass only a callback, in which case you have the opportunity to alter the app.param() API param(callback: (name: string, matcher: RegExp) => RequestParamHandler): T; /** * Special-cased "all" method, applying the given route `path`, * middleware, and callback to _every_ HTTP method. * * @param path * @param fn */ all: IRouterMatcher; get: IRouterMatcher; post: IRouterMatcher; put: IRouterMatcher; delete: IRouterMatcher; patch: IRouterMatcher; options: IRouterMatcher; head: IRouterMatcher; route(path: string): IRoute; use(...handler: RequestHandler[]): T; use(handler: ErrorRequestHandler): T; use(path: string, ...handler: RequestHandler[]): T; use(path: string, handler: ErrorRequestHandler): T; use(path: string[], ...handler: RequestHandler[]): T; use(path: string[], handler: ErrorRequestHandler): T; use(path: RegExp, ...handler: RequestHandler[]): T; use(path: RegExp, handler: ErrorRequestHandler): T; use(path:string, router:Router): T; } export function Router(options?: any): Router; export interface Router extends IRouter {} interface CookieOptions { maxAge?: number; signed?: boolean; expires?: Date; httpOnly?: boolean; path?: string; domain?: string; secure?: boolean; } interface Errback { (err: Error): void; } interface Request extends http.ServerRequest, Express.Request { /** * Return request header. * * The `Referrer` header field is special-cased, * both `Referrer` and `Referer` are interchangeable. * * Examples: * * req.get('Content-Type'); * // => "text/plain" * * req.get('content-type'); * // => "text/plain" * * req.get('Something'); * // => undefined * * Aliased as `req.header()`. * * @param name */ get (name: string): string; header(name: string): string; headers: { [key: string]: string; }; /** * Check if the given `type(s)` is acceptable, returning * the best match when true, otherwise `undefined`, in which * case you should respond with 406 "Not Acceptable". * * The `type` value may be a single mime type string * such as "application/json", the extension name * such as "json", a comma-delimted list such as "json, html, text/plain", * or an array `["json", "html", "text/plain"]`. When a list * or array is given the _best_ match, if any is returned. * * Examples: * * // Accept: text/html * req.accepts('html'); * // => "html" * * // Accept: text/*, application/json * req.accepts('html'); * // => "html" * req.accepts('text/html'); * // => "text/html" * req.accepts('json, text'); * // => "json" * req.accepts('application/json'); * // => "application/json" * * // Accept: text/*, application/json * req.accepts('image/png'); * req.accepts('png'); * // => undefined * * // Accept: text/*;q=.5, application/json * req.accepts(['html', 'json']); * req.accepts('html, json'); * // => "json" */ accepts(type: string): string; accepts(type: string[]): string; /** * Check if the given `charset` is acceptable, * otherwise you should respond with 406 "Not Acceptable". * * @param charset */ acceptsCharset(charset: string): boolean; /** * Check if the given `lang` is acceptable, * otherwise you should respond with 406 "Not Acceptable". * * @param lang */ acceptsLanguage(lang: string): boolean; /** * Parse Range header field, * capping to the given `size`. * * Unspecified ranges such as "0-" require * knowledge of your resource length. In * the case of a byte range this is of course * the total number of bytes. If the Range * header field is not given `null` is returned, * `-1` when unsatisfiable, `-2` when syntactically invalid. * * NOTE: remember that ranges are inclusive, so * for example "Range: users=0-3" should respond * with 4 users when available, not 3. * * @param size */ range(size: number): any[]; /** * Return an array of Accepted media types * ordered from highest quality to lowest. */ accepted: MediaType[]; /** * Return an array of Accepted languages * ordered from highest quality to lowest. * * Examples: * * Accept-Language: en;q=.5, en-us * ['en-us', 'en'] */ acceptedLanguages: any[]; /** * Return an array of Accepted charsets * ordered from highest quality to lowest. * * Examples: * * Accept-Charset: iso-8859-5;q=.2, unicode-1-1;q=0.8 * ['unicode-1-1', 'iso-8859-5'] */ acceptedCharsets: any[]; /** * Return the value of param `name` when present or `defaultValue`. * * - Checks route placeholders, ex: _/user/:id_ * - Checks body params, ex: id=12, {"id":12} * - Checks query string params, ex: ?id=12 * * To utilize request bodies, `req.body` * should be an object. This can be done by using * the `connect.bodyParser()` middleware. * * @param name * @param defaultValue */ param(name: string, defaultValue?: any): string; /** * Check if the incoming request contains the "Content-Type" * header field, and it contains the give mime `type`. * * Examples: * * // With Content-Type: text/html; charset=utf-8 * req.is('html'); * req.is('text/html'); * req.is('text/*'); * // => true * * // When Content-Type is application/json * req.is('json'); * req.is('application/json'); * req.is('application/*'); * // => true * * req.is('html'); * // => false * * @param type */ is(type: string): boolean; /** * Return the protocol string "http" or "https" * when requested with TLS. When the "trust proxy" * setting is enabled the "X-Forwarded-Proto" header * field will be trusted. If you're running behind * a reverse proxy that supplies https for you this * may be enabled. */ protocol: string; /** * Short-hand for: * * req.protocol == 'https' */ secure: boolean; /** * Return the remote address, or when * "trust proxy" is `true` return * the upstream addr. */ ip: string; /** * When "trust proxy" is `true`, parse * the "X-Forwarded-For" ip address list. * * For example if the value were "client, proxy1, proxy2" * you would receive the array `["client", "proxy1", "proxy2"]` * where "proxy2" is the furthest down-stream. */ ips: string[]; /** * Return subdomains as an array. * * Subdomains are the dot-separated parts of the host before the main domain of * the app. By default, the domain of the app is assumed to be the last two * parts of the host. This can be changed by setting "subdomain offset". * * For example, if the domain is "tobi.ferrets.example.com": * If "subdomain offset" is not set, req.subdomains is `["ferrets", "tobi"]`. * If "subdomain offset" is 3, req.subdomains is `["tobi"]`. */ subdomains: string[]; /** * Short-hand for `url.parse(req.url).pathname`. */ path: string; /** * Parse the "Host" header field hostname. */ hostname: string; /** * @deprecated Use hostname instead. */ host: string; /** * Check if the request is fresh, aka * Last-Modified and/or the ETag * still match. */ fresh: boolean; /** * Check if the request is stale, aka * "Last-Modified" and / or the "ETag" for the * resource has changed. */ stale: boolean; /** * Check if the request was an _XMLHttpRequest_. */ xhr: boolean; //body: { username: string; password: string; remember: boolean; title: string; }; body: any; //cookies: { string; remember: boolean; }; cookies: any; method: string; params: any; user: any; authenticatedUser: any; /** * Clear cookie `name`. * * @param name * @param options */ clearCookie(name: string, options?: any): Response; query: any; route: any; signedCookies: any; originalUrl: string; url: string; baseUrl: string; app: Application; } interface MediaType { value: string; quality: number; type: string; subtype: string; } interface Send { (status: number, body?: any): Response; (body: any): Response; } interface Response extends http.ServerResponse, Express.Response { /** * Set status `code`. * * @param code */ status(code: number): Response; /** * Set the response HTTP status code to `statusCode` and send its string representation as the response body. * @link http://expressjs.com/4x/api.html#res.sendStatus * * Examples: * * res.sendStatus(200); // equivalent to res.status(200).send('OK') * res.sendStatus(403); // equivalent to res.status(403).send('Forbidden') * res.sendStatus(404); // equivalent to res.status(404).send('Not Found') * res.sendStatus(500); // equivalent to res.status(500).send('Internal Server Error') * * @param code */ sendStatus(code: number): Response; /** * Set Link header field with the given `links`. * * Examples: * * res.links({ * next: 'http://api.example.com/users?page=2', * last: 'http://api.example.com/users?page=5' * }); * * @param links */ links(links: any): Response; /** * Send a response. * * Examples: * * res.send(new Buffer('wahoo')); * res.send({ some: 'json' }); * res.send('

some html

'); * res.send(404, 'Sorry, cant find that'); * res.send(404); */ send: Send; /** * Send JSON response. * * Examples: * * res.json(null); * res.json({ user: 'tj' }); * res.json(500, 'oh noes!'); * res.json(404, 'I dont have that'); */ json: Send; /** * Send JSON response with JSONP callback support. * * Examples: * * res.jsonp(null); * res.jsonp({ user: 'tj' }); * res.jsonp(500, 'oh noes!'); * res.jsonp(404, 'I dont have that'); */ jsonp: Send; /** * Transfer the file at the given `path`. * * Automatically sets the _Content-Type_ response header field. * The callback `fn(err)` is invoked when the transfer is complete * or when an error occurs. Be sure to check `res.sentHeader` * if you wish to attempt responding, as the header and some data * may have already been transferred. * * Options: * * - `maxAge` defaulting to 0 (can be string converted by `ms`) * - `root` root directory for relative filenames * - `headers` object of headers to serve with file * - `dotfiles` serve dotfiles, defaulting to false; can be `"allow"` to send them * * Other options are passed along to `send`. * * Examples: * * The following example illustrates how `res.sendFile()` may * be used as an alternative for the `static()` middleware for * dynamic situations. The code backing `res.sendFile()` is actually * the same code, so HTTP cache support etc is identical. * * app.get('/user/:uid/photos/:file', function(req, res){ * var uid = req.params.uid * , file = req.params.file; * * req.user.mayViewFilesFrom(uid, function(yes){ * if (yes) { * res.sendFile('/uploads/' + uid + '/' + file); * } else { * res.send(403, 'Sorry! you cant see that.'); * } * }); * }); * * @api public */ sendFile(path: string): void; sendFile(path: string, options: any): void; sendFile(path: string, fn: Errback): void; sendFile(path: string, options: any, fn: Errback): void; /** * @deprecated Use sendFile instead. */ sendfile(path: string): void; /** * @deprecated Use sendFile instead. */ sendfile(path: string, options: any): void; /** * @deprecated Use sendFile instead. */ sendfile(path: string, fn: Errback): void; /** * @deprecated Use sendFile instead. */ sendfile(path: string, options: any, fn: Errback): void; /** * Transfer the file at the given `path` as an attachment. * * Optionally providing an alternate attachment `filename`, * and optional callback `fn(err)`. The callback is invoked * when the data transfer is complete, or when an error has * ocurred. Be sure to check `res.headerSent` if you plan to respond. * * This method uses `res.sendfile()`. */ download(path: string): void; download(path: string, filename: string): void; download(path: string, fn: Errback): void; download(path: string, filename: string, fn: Errback): void; /** * Set _Content-Type_ response header with `type` through `mime.lookup()` * when it does not contain "/", or set the Content-Type to `type` otherwise. * * Examples: * * res.type('.html'); * res.type('html'); * res.type('json'); * res.type('application/json'); * res.type('png'); * * @param type */ contentType(type: string): Response; /** * Set _Content-Type_ response header with `type` through `mime.lookup()` * when it does not contain "/", or set the Content-Type to `type` otherwise. * * Examples: * * res.type('.html'); * res.type('html'); * res.type('json'); * res.type('application/json'); * res.type('png'); * * @param type */ type(type: string): Response; /** * Respond to the Acceptable formats using an `obj` * of mime-type callbacks. * * This method uses `req.accepted`, an array of * acceptable types ordered by their quality values. * When "Accept" is not present the _first_ callback * is invoked, otherwise the first match is used. When * no match is performed the server responds with * 406 "Not Acceptable". * * Content-Type is set for you, however if you choose * you may alter this within the callback using `res.type()` * or `res.set('Content-Type', ...)`. * * res.format({ * 'text/plain': function(){ * res.send('hey'); * }, * * 'text/html': function(){ * res.send('

hey

'); * }, * * 'appliation/json': function(){ * res.send({ message: 'hey' }); * } * }); * * In addition to canonicalized MIME types you may * also use extnames mapped to these types: * * res.format({ * text: function(){ * res.send('hey'); * }, * * html: function(){ * res.send('

hey

'); * }, * * json: function(){ * res.send({ message: 'hey' }); * } * }); * * By default Express passes an `Error` * with a `.status` of 406 to `next(err)` * if a match is not made. If you provide * a `.default` callback it will be invoked * instead. * * @param obj */ format(obj: any): Response; /** * Set _Content-Disposition_ header to _attachment_ with optional `filename`. * * @param filename */ attachment(filename?: string): Response; /** * Set header `field` to `val`, or pass * an object of header fields. * * Examples: * * res.set('Foo', ['bar', 'baz']); * res.set('Accept', 'application/json'); * res.set({ Accept: 'text/plain', 'X-API-Key': 'tobi' }); * * Aliased as `res.header()`. */ set(field: any): Response; set(field: string, value?: string): Response; header(field: any): Response; header(field: string, value?: string): Response; // Property indicating if HTTP headers has been sent for the response. headersSent: boolean; /** * Get value for header `field`. * * @param field */ get (field: string): string; /** * Clear cookie `name`. * * @param name * @param options */ clearCookie(name: string, options?: any): Response; /** * Set cookie `name` to `val`, with the given `options`. * * Options: * * - `maxAge` max-age in milliseconds, converted to `expires` * - `signed` sign the cookie * - `path` defaults to "/" * * Examples: * * // "Remember Me" for 15 minutes * res.cookie('rememberme', '1', { expires: new Date(Date.now() + 900000), httpOnly: true }); * * // save as above * res.cookie('rememberme', '1', { maxAge: 900000, httpOnly: true }) */ cookie(name: string, val: string, options: CookieOptions): Response; cookie(name: string, val: any, options: CookieOptions): Response; cookie(name: string, val: any): Response; /** * Set the location header to `url`. * * The given `url` can also be the name of a mapped url, for * example by default express supports "back" which redirects * to the _Referrer_ or _Referer_ headers or "/". * * Examples: * * res.location('/foo/bar').; * res.location('http://example.com'); * res.location('../login'); // /blog/post/1 -> /blog/login * * Mounting: * * When an application is mounted and `res.location()` * is given a path that does _not_ lead with "/" it becomes * relative to the mount-point. For example if the application * is mounted at "/blog", the following would become "/blog/login". * * res.location('login'); * * While the leading slash would result in a location of "/login": * * res.location('/login'); * * @param url */ location(url: string): Response; /** * Redirect to the given `url` with optional response `status` * defaulting to 302. * * The resulting `url` is determined by `res.location()`, so * it will play nicely with mounted apps, relative paths, * `"back"` etc. * * Examples: * * res.redirect('/foo/bar'); * res.redirect('http://example.com'); * res.redirect(301, 'http://example.com'); * res.redirect('http://example.com', 301); * res.redirect('../login'); // /blog/post/1 -> /blog/login */ redirect(url: string): void; redirect(status: number, url: string): void; redirect(url: string, status: number): void; /** * Render `view` with the given `options` and optional callback `fn`. * When a callback function is given a response will _not_ be made * automatically, otherwise a response of _200_ and _text/html_ is given. * * Options: * * - `cache` boolean hinting to the engine it should cache * - `filename` filename of the view being rendered */ render(view: string, options?: Object, callback?: (err: Error, html: string) => void ): void; render(view: string, callback?: (err: Error, html: string) => void ): void; locals: any; charset: string; } interface ErrorRequestHandler { (err: any, req: Request, res: Response, next: Function): any; } interface RequestHandler { (req: Request, res: Response, next: Function): any; } interface Handler extends RequestHandler {} interface RequestParamHandler { (req: Request, res: Response, next: Function, param: any): any; } interface Application extends IRouter, Express.Application { /** * Initialize the server. * * - setup default configuration * - setup default middleware * - setup route reflection methods */ init(): void; /** * Initialize application configuration. */ defaultConfiguration(): void; /** * Register the given template engine callback `fn` * as `ext`. * * By default will `require()` the engine based on the * file extension. For example if you try to render * a "foo.jade" file Express will invoke the following internally: * * app.engine('jade', require('jade').__express); * * For engines that do not provide `.__express` out of the box, * or if you wish to "map" a different extension to the template engine * you may use this method. For example mapping the EJS template engine to * ".html" files: * * app.engine('html', require('ejs').renderFile); * * In this case EJS provides a `.renderFile()` method with * the same signature that Express expects: `(path, options, callback)`, * though note that it aliases this method as `ejs.__express` internally * so if you're using ".ejs" extensions you dont need to do anything. * * Some template engines do not follow this convention, the * [Consolidate.js](https://github.com/visionmedia/consolidate.js) * library was created to map all of node's popular template * engines to follow this convention, thus allowing them to * work seamlessly within Express. */ engine(ext: string, fn: Function): Application; /** * Assign `setting` to `val`, or return `setting`'s value. * * app.set('foo', 'bar'); * app.get('foo'); * // => "bar" * app.set('foo', ['bar', 'baz']); * app.get('foo'); * // => ["bar", "baz"] * * Mounted servers inherit their parent server's settings. * * @param setting * @param val */ set(setting: string, val: any): Application; get: { (name: string): any; // Getter (name: string, ...handlers: RequestHandler[]): Application; (name: RegExp, ...handlers: RequestHandler[]): Application; }; /** * Return the app's absolute pathname * based on the parent(s) that have * mounted it. * * For example if the application was * mounted as "/admin", which itself * was mounted as "/blog" then the * return value would be "/blog/admin". */ path(): string; /** * Check if `setting` is enabled (truthy). * * app.enabled('foo') * // => false * * app.enable('foo') * app.enabled('foo') * // => true */ enabled(setting: string): boolean; /** * Check if `setting` is disabled. * * app.disabled('foo') * // => true * * app.enable('foo') * app.disabled('foo') * // => false * * @param setting */ disabled(setting: string): boolean; /** * Enable `setting`. * * @param setting */ enable(setting: string): Application; /** * Disable `setting`. * * @param setting */ disable(setting: string): Application; /** * Configure callback for zero or more envs, * when no `env` is specified that callback will * be invoked for all environments. Any combination * can be used multiple times, in any order desired. * * Examples: * * app.configure(function(){ * // executed for all envs * }); * * app.configure('stage', function(){ * // executed staging env * }); * * app.configure('stage', 'production', function(){ * // executed for stage and production * }); * * Note: * * These callbacks are invoked immediately, and * are effectively sugar for the following: * * var env = process.env.NODE_ENV || 'development'; * * switch (env) { * case 'development': * ... * break; * case 'stage': * ... * break; * case 'production': * ... * break; * } * * @param env * @param fn */ configure(fn: Function): Application; configure(env0: string, fn: Function): Application; configure(env0: string, env1: string, fn: Function): Application; configure(env0: string, env1: string, env2: string, fn: Function): Application; configure(env0: string, env1: string, env2: string, env3: string, fn: Function): Application; configure(env0: string, env1: string, env2: string, env3: string, env4: string, fn: Function): Application; /** * Render the given view `name` name with `options` * and a callback accepting an error and the * rendered template string. * * Example: * * app.render('email', { name: 'Tobi' }, function(err, html){ * // ... * }) * * @param name * @param options or fn * @param fn */ render(name: string, options?: Object, callback?: (err: Error, html: string) => void): void; render(name: string, callback: (err: Error, html: string) => void): void; /** * Listen for connections. * * A node `http.Server` is returned, with this * application (which is a `Function`) as its * callback. If you wish to create both an HTTP * and HTTPS server you may do so with the "http" * and "https" modules as shown here: * * var http = require('http') * , https = require('https') * , express = require('express') * , app = express(); * * http.createServer(app).listen(80); * https.createServer({ ... }, app).listen(443); */ listen(port: number, hostname: string, backlog: number, callback?: Function): http.Server; listen(port: number, hostname: string, callback?: Function): http.Server; listen(port: number, callback?: Function): http.Server; listen(path: string, callback?: Function): http.Server; listen(handle: any, listeningListener?: Function): http.Server; route(path: string): IRoute; router: string; settings: any; resource: any; map: any; locals: any; /** * The app.routes object houses all of the routes defined mapped by the * associated HTTP verb. This object may be used for introspection * capabilities, for example Express uses this internally not only for * routing but to provide default OPTIONS behaviour unless app.options() * is used. Your application or framework may also remove routes by * simply by removing them from this object. */ routes: any; } interface Express extends Application { /** * Framework version. */ version: string; /** * Expose mime. */ mime: string; (): Application; /** * Create an express application. */ createApplication(): Application; createServer(): Application; application: any; request: Request; response: Response; } var static: typeof serveStatic; } export = e; } WebDevelopment-assignment-2/server/typings/mime/000077500000000000000000000000001266350324300222415ustar00rootroot00000000000000WebDevelopment-assignment-2/server/typings/mime/mime.d.ts000077500000000000000000000011611266350324300237640ustar00rootroot00000000000000// Type definitions for mime // Project: https://github.com/broofa/node-mime // Definitions by: Jeff Goddard // Definitions: https://github.com/borisyankov/DefinitelyTyped // Imported from: https://github.com/soywiz/typescript-node-definitions/mime.d.ts declare module "mime" { export function lookup(path: string): string; export function extension(mime: string): string; export function load(filepath: string): void; export function define(mimes: Object): void; interface Charsets { lookup(mime: string): string; } export var charsets: Charsets; export var default_type: string; } WebDevelopment-assignment-2/server/typings/node/000077500000000000000000000000001266350324300222375ustar00rootroot00000000000000WebDevelopment-assignment-2/server/typings/node/node.d.ts000077500000000000000000002604661266350324300237770ustar00rootroot00000000000000// Type definitions for Node.js v4.x // Project: http://nodejs.org/ // Definitions by: Microsoft TypeScript , DefinitelyTyped // Definitions: https://github.com/borisyankov/DefinitelyTyped /************************************************ * * * Node.js v4.x API * * * ************************************************/ interface Error { stack?: string; } // compat for TypeScript 1.5.3 // if you use with --target es3 or --target es5 and use below definitions, // use the lib.es6.d.ts that is bundled with TypeScript 1.5.3. interface MapConstructor {} interface WeakMapConstructor {} interface SetConstructor {} interface WeakSetConstructor {} /************************************************ * * * GLOBAL * * * ************************************************/ declare var process: NodeJS.Process; declare var global: NodeJS.Global; declare var __filename: string; declare var __dirname: string; declare function setTimeout(callback: (...args: any[]) => void, ms: number, ...args: any[]): NodeJS.Timer; declare function clearTimeout(timeoutId: NodeJS.Timer): void; declare function setInterval(callback: (...args: any[]) => void, ms: number, ...args: any[]): NodeJS.Timer; declare function clearInterval(intervalId: NodeJS.Timer): void; declare function setImmediate(callback: (...args: any[]) => void, ...args: any[]): any; declare function clearImmediate(immediateId: any): void; interface NodeRequireFunction { (id: string): any; } interface NodeRequire extends NodeRequireFunction { resolve(id:string): string; cache: any; extensions: any; main: any; } declare var require: NodeRequire; interface NodeModule { exports: any; require: NodeRequireFunction; id: string; filename: string; loaded: boolean; parent: any; children: any[]; } declare var module: NodeModule; // Same as module.exports declare var exports: any; declare var SlowBuffer: { new (str: string, encoding?: string): Buffer; new (size: number): Buffer; new (size: Uint8Array): Buffer; new (array: any[]): Buffer; prototype: Buffer; isBuffer(obj: any): boolean; byteLength(string: string, encoding?: string): number; concat(list: Buffer[], totalLength?: number): Buffer; }; // Buffer class interface Buffer extends NodeBuffer {} /** * Raw data is stored in instances of the Buffer class. * A Buffer is similar to an array of integers but corresponds to a raw memory allocation outside the V8 heap. A Buffer cannot be resized. * Valid string encodings: 'ascii'|'utf8'|'utf16le'|'ucs2'(alias of 'utf16le')|'base64'|'binary'(deprecated)|'hex' */ declare var Buffer: { /** * Allocates a new buffer containing the given {str}. * * @param str String to store in buffer. * @param encoding encoding to use, optional. Default is 'utf8' */ new (str: string, encoding?: string): Buffer; /** * Allocates a new buffer of {size} octets. * * @param size count of octets to allocate. */ new (size: number): Buffer; /** * Allocates a new buffer containing the given {array} of octets. * * @param array The octets to store. */ new (array: Uint8Array): Buffer; /** * Allocates a new buffer containing the given {array} of octets. * * @param array The octets to store. */ new (array: any[]): Buffer; prototype: Buffer; /** * Returns true if {obj} is a Buffer * * @param obj object to test. */ isBuffer(obj: any): obj is Buffer; /** * Returns true if {encoding} is a valid encoding argument. * Valid string encodings in Node 0.12: 'ascii'|'utf8'|'utf16le'|'ucs2'(alias of 'utf16le')|'base64'|'binary'(deprecated)|'hex' * * @param encoding string to test. */ isEncoding(encoding: string): boolean; /** * Gives the actual byte length of a string. encoding defaults to 'utf8'. * This is not the same as String.prototype.length since that returns the number of characters in a string. * * @param string string to test. * @param encoding encoding used to evaluate (defaults to 'utf8') */ byteLength(string: string, encoding?: string): number; /** * Returns a buffer which is the result of concatenating all the buffers in the list together. * * If the list has no items, or if the totalLength is 0, then it returns a zero-length buffer. * If the list has exactly one item, then the first item of the list is returned. * If the list has more than one item, then a new Buffer is created. * * @param list An array of Buffer objects to concatenate * @param totalLength Total length of the buffers when concatenated. * If totalLength is not provided, it is read from the buffers in the list. However, this adds an additional loop to the function, so it is faster to provide the length explicitly. */ concat(list: Buffer[], totalLength?: number): Buffer; /** * The same as buf1.compare(buf2). */ compare(buf1: Buffer, buf2: Buffer): number; }; /************************************************ * * * GLOBAL INTERFACES * * * ************************************************/ declare module NodeJS { export interface ErrnoException extends Error { errno?: number; code?: string; path?: string; syscall?: string; stack?: string; } export interface EventEmitter { addListener(event: string, listener: Function): EventEmitter; on(event: string, listener: Function): EventEmitter; once(event: string, listener: Function): EventEmitter; removeListener(event: string, listener: Function): EventEmitter; removeAllListeners(event?: string): EventEmitter; setMaxListeners(n: number): EventEmitter; getMaxListeners(): number; listeners(event: string): Function[]; emit(event: string, ...args: any[]): boolean; listenerCount(type: string): number; } export interface ReadableStream extends EventEmitter { readable: boolean; read(size?: number): string|Buffer; setEncoding(encoding: string): void; pause(): void; resume(): void; pipe(destination: T, options?: { end?: boolean; }): T; unpipe(destination?: T): void; unshift(chunk: string): void; unshift(chunk: Buffer): void; wrap(oldStream: ReadableStream): ReadableStream; } export interface WritableStream extends EventEmitter { writable: boolean; write(buffer: Buffer|string, cb?: Function): boolean; write(str: string, encoding?: string, cb?: Function): boolean; end(): void; end(buffer: Buffer, cb?: Function): void; end(str: string, cb?: Function): void; end(str: string, encoding?: string, cb?: Function): void; } export interface ReadWriteStream extends ReadableStream, WritableStream {} export interface Process extends EventEmitter { stdout: WritableStream; stderr: WritableStream; stdin: ReadableStream; argv: string[]; execPath: string; abort(): void; chdir(directory: string): void; cwd(): string; env: any; exit(code?: number): void; getgid(): number; setgid(id: number): void; setgid(id: string): void; getuid(): number; setuid(id: number): void; setuid(id: string): void; version: string; versions: { http_parser: string; node: string; v8: string; ares: string; uv: string; zlib: string; openssl: string; }; config: { target_defaults: { cflags: any[]; default_configuration: string; defines: string[]; include_dirs: string[]; libraries: string[]; }; variables: { clang: number; host_arch: string; node_install_npm: boolean; node_install_waf: boolean; node_prefix: string; node_shared_openssl: boolean; node_shared_v8: boolean; node_shared_zlib: boolean; node_use_dtrace: boolean; node_use_etw: boolean; node_use_openssl: boolean; target_arch: string; v8_no_strict_aliasing: number; v8_use_snapshot: boolean; visibility: string; }; }; kill(pid:number, signal?: string|number): void; pid: number; title: string; arch: string; platform: string; memoryUsage(): { rss: number; heapTotal: number; heapUsed: number; }; nextTick(callback: Function): void; umask(mask?: number): number; uptime(): number; hrtime(time?:number[]): number[]; // Worker send?(message: any, sendHandle?: any): void; } export interface Global { Array: typeof Array; ArrayBuffer: typeof ArrayBuffer; Boolean: typeof Boolean; Buffer: typeof Buffer; DataView: typeof DataView; Date: typeof Date; Error: typeof Error; EvalError: typeof EvalError; Float32Array: typeof Float32Array; Float64Array: typeof Float64Array; Function: typeof Function; GLOBAL: Global; Infinity: typeof Infinity; Int16Array: typeof Int16Array; Int32Array: typeof Int32Array; Int8Array: typeof Int8Array; Intl: typeof Intl; JSON: typeof JSON; Map: MapConstructor; Math: typeof Math; NaN: typeof NaN; Number: typeof Number; Object: typeof Object; Promise: Function; RangeError: typeof RangeError; ReferenceError: typeof ReferenceError; RegExp: typeof RegExp; Set: SetConstructor; String: typeof String; Symbol: Function; SyntaxError: typeof SyntaxError; TypeError: typeof TypeError; URIError: typeof URIError; Uint16Array: typeof Uint16Array; Uint32Array: typeof Uint32Array; Uint8Array: typeof Uint8Array; Uint8ClampedArray: Function; WeakMap: WeakMapConstructor; WeakSet: WeakSetConstructor; clearImmediate: (immediateId: any) => void; clearInterval: (intervalId: NodeJS.Timer) => void; clearTimeout: (timeoutId: NodeJS.Timer) => void; console: typeof console; decodeURI: typeof decodeURI; decodeURIComponent: typeof decodeURIComponent; encodeURI: typeof encodeURI; encodeURIComponent: typeof encodeURIComponent; escape: (str: string) => string; eval: typeof eval; global: Global; isFinite: typeof isFinite; isNaN: typeof isNaN; parseFloat: typeof parseFloat; parseInt: typeof parseInt; process: Process; root: Global; setImmediate: (callback: (...args: any[]) => void, ...args: any[]) => any; setInterval: (callback: (...args: any[]) => void, ms: number, ...args: any[]) => NodeJS.Timer; setTimeout: (callback: (...args: any[]) => void, ms: number, ...args: any[]) => NodeJS.Timer; undefined: typeof undefined; unescape: (str: string) => string; gc: () => void; v8debug?: any; } export interface Timer { ref() : void; unref() : void; } } /** * @deprecated */ interface NodeBuffer { [index: number]: number; write(string: string, offset?: number, length?: number, encoding?: string): number; toString(encoding?: string, start?: number, end?: number): string; toJSON(): any; length: number; equals(otherBuffer: Buffer): boolean; compare(otherBuffer: Buffer): number; copy(targetBuffer: Buffer, targetStart?: number, sourceStart?: number, sourceEnd?: number): number; slice(start?: number, end?: number): Buffer; writeUIntLE(value: number, offset: number, byteLength: number, noAssert?: boolean): number; writeUIntBE(value: number, offset: number, byteLength: number, noAssert?: boolean): number; writeIntLE(value: number, offset: number, byteLength: number, noAssert?: boolean): number; writeIntBE(value: number, offset: number, byteLength: number, noAssert?: boolean): number; readUIntLE(offset: number, byteLength: number, noAssert?: boolean): number; readUIntBE(offset: number, byteLength: number, noAssert?: boolean): number; readIntLE(offset: number, byteLength: number, noAssert?: boolean): number; readIntBE(offset: number, byteLength: number, noAssert?: boolean): number; readUInt8(offset: number, noAsset?: boolean): number; readUInt16LE(offset: number, noAssert?: boolean): number; readUInt16BE(offset: number, noAssert?: boolean): number; readUInt32LE(offset: number, noAssert?: boolean): number; readUInt32BE(offset: number, noAssert?: boolean): number; readInt8(offset: number, noAssert?: boolean): number; readInt16LE(offset: number, noAssert?: boolean): number; readInt16BE(offset: number, noAssert?: boolean): number; readInt32LE(offset: number, noAssert?: boolean): number; readInt32BE(offset: number, noAssert?: boolean): number; readFloatLE(offset: number, noAssert?: boolean): number; readFloatBE(offset: number, noAssert?: boolean): number; readDoubleLE(offset: number, noAssert?: boolean): number; readDoubleBE(offset: number, noAssert?: boolean): number; writeUInt8(value: number, offset: number, noAssert?: boolean): number; writeUInt16LE(value: number, offset: number, noAssert?: boolean): number; writeUInt16BE(value: number, offset: number, noAssert?: boolean): number; writeUInt32LE(value: number, offset: number, noAssert?: boolean): number; writeUInt32BE(value: number, offset: number, noAssert?: boolean): number; writeInt8(value: number, offset: number, noAssert?: boolean): number; writeInt16LE(value: number, offset: number, noAssert?: boolean): number; writeInt16BE(value: number, offset: number, noAssert?: boolean): number; writeInt32LE(value: number, offset: number, noAssert?: boolean): number; writeInt32BE(value: number, offset: number, noAssert?: boolean): number; writeFloatLE(value: number, offset: number, noAssert?: boolean): number; writeFloatBE(value: number, offset: number, noAssert?: boolean): number; writeDoubleLE(value: number, offset: number, noAssert?: boolean): number; writeDoubleBE(value: number, offset: number, noAssert?: boolean): number; fill(value: any, offset?: number, end?: number): Buffer; } /************************************************ * * * MODULES * * * ************************************************/ declare module "buffer" { export var INSPECT_MAX_BYTES: number; } declare module "querystring" { export interface StringifyOptions { encodeURIComponent?: Function; } export interface ParseOptions { maxKeys?: number; decodeURIComponent?: Function; } export function stringify(obj: T, sep?: string, eq?: string, options?: StringifyOptions): string; export function parse(str: string, sep?: string, eq?: string, options?: ParseOptions): any; export function parse(str: string, sep?: string, eq?: string, options?: ParseOptions): T; export function escape(str: string): string; export function unescape(str: string): string; } declare module "events" { export class EventEmitter implements NodeJS.EventEmitter { static EventEmitter: EventEmitter; static listenerCount(emitter: EventEmitter, event: string): number; // deprecated static defaultMaxListeners: number; addListener(event: string, listener: Function): EventEmitter; on(event: string, listener: Function): EventEmitter; once(event: string, listener: Function): EventEmitter; removeListener(event: string, listener: Function): EventEmitter; removeAllListeners(event?: string): EventEmitter; setMaxListeners(n: number): EventEmitter; getMaxListeners(): number; listeners(event: string): Function[]; emit(event: string, ...args: any[]): boolean; listenerCount(type: string): number; } } declare module "http" { import * as events from "events"; import * as net from "net"; import * as stream from "stream"; export interface RequestOptions { protocol?: string; host?: string; hostname?: string; family?: number; port?: number localAddress?: string; socketPath?: string; method?: string; path?: string; headers?: { [key: string]: any }; auth?: string; agent?: Agent|boolean; } export interface Server extends events.EventEmitter { listen(port: number, hostname?: string, backlog?: number, callback?: Function): Server; listen(port: number, hostname?: string, callback?: Function): Server; listen(path: string, callback?: Function): Server; listen(handle: any, listeningListener?: Function): Server; close(cb?: any): Server; address(): { port: number; family: string; address: string; }; maxHeadersCount: number; } /** * @deprecated Use IncomingMessage */ export interface ServerRequest extends IncomingMessage { connection: net.Socket; } export interface ServerResponse extends events.EventEmitter, stream.Writable { // Extended base methods write(buffer: Buffer): boolean; write(buffer: Buffer, cb?: Function): boolean; write(str: string, cb?: Function): boolean; write(str: string, encoding?: string, cb?: Function): boolean; write(str: string, encoding?: string, fd?: string): boolean; writeContinue(): void; writeHead(statusCode: number, reasonPhrase?: string, headers?: any): void; writeHead(statusCode: number, headers?: any): void; statusCode: number; statusMessage: string; headersSent: boolean; setHeader(name: string, value: string): void; sendDate: boolean; getHeader(name: string): string; removeHeader(name: string): void; write(chunk: any, encoding?: string): any; addTrailers(headers: any): void; // Extended base methods end(): void; end(buffer: Buffer, cb?: Function): void; end(str: string, cb?: Function): void; end(str: string, encoding?: string, cb?: Function): void; end(data?: any, encoding?: string): void; } export interface ClientRequest extends events.EventEmitter, stream.Writable { // Extended base methods write(buffer: Buffer): boolean; write(buffer: Buffer, cb?: Function): boolean; write(str: string, cb?: Function): boolean; write(str: string, encoding?: string, cb?: Function): boolean; write(str: string, encoding?: string, fd?: string): boolean; write(chunk: any, encoding?: string): void; abort(): void; setTimeout(timeout: number, callback?: Function): void; setNoDelay(noDelay?: boolean): void; setSocketKeepAlive(enable?: boolean, initialDelay?: number): void; // Extended base methods end(): void; end(buffer: Buffer, cb?: Function): void; end(str: string, cb?: Function): void; end(str: string, encoding?: string, cb?: Function): void; end(data?: any, encoding?: string): void; } export interface IncomingMessage extends events.EventEmitter, stream.Readable { httpVersion: string; headers: any; rawHeaders: string[]; trailers: any; rawTrailers: any; setTimeout(msecs: number, callback: Function): NodeJS.Timer; /** * Only valid for request obtained from http.Server. */ method?: string; /** * Only valid for request obtained from http.Server. */ url?: string; /** * Only valid for response obtained from http.ClientRequest. */ statusCode?: number; /** * Only valid for response obtained from http.ClientRequest. */ statusMessage?: string; socket: net.Socket; } /** * @deprecated Use IncomingMessage */ export interface ClientResponse extends IncomingMessage { } export interface AgentOptions { /** * Keep sockets around in a pool to be used by other requests in the future. Default = false */ keepAlive?: boolean; /** * When using HTTP KeepAlive, how often to send TCP KeepAlive packets over sockets being kept alive. Default = 1000. * Only relevant if keepAlive is set to true. */ keepAliveMsecs?: number; /** * Maximum number of sockets to allow per host. Default for Node 0.10 is 5, default for Node 0.12 is Infinity */ maxSockets?: number; /** * Maximum number of sockets to leave open in a free state. Only relevant if keepAlive is set to true. Default = 256. */ maxFreeSockets?: number; } export class Agent { maxSockets: number; sockets: any; requests: any; constructor(opts?: AgentOptions); /** * Destroy any sockets that are currently in use by the agent. * It is usually not necessary to do this. However, if you are using an agent with KeepAlive enabled, * then it is best to explicitly shut down the agent when you know that it will no longer be used. Otherwise, * sockets may hang open for quite a long time before the server terminates them. */ destroy(): void; } export var METHODS: string[]; export var STATUS_CODES: { [errorCode: number]: string; [errorCode: string]: string; }; export function createServer(requestListener?: (request: IncomingMessage, response: ServerResponse) =>void ): Server; export function createClient(port?: number, host?: string): any; export function request(options: RequestOptions, callback?: (res: IncomingMessage) => void): ClientRequest; export function get(options: any, callback?: (res: IncomingMessage) => void): ClientRequest; export var globalAgent: Agent; } declare module "cluster" { import * as child from "child_process"; import * as events from "events"; export interface ClusterSettings { exec?: string; args?: string[]; silent?: boolean; } export class Worker extends events.EventEmitter { id: string; process: child.ChildProcess; suicide: boolean; send(message: any, sendHandle?: any): void; kill(signal?: string): void; destroy(signal?: string): void; disconnect(): void; } export var settings: ClusterSettings; export var isMaster: boolean; export var isWorker: boolean; export function setupMaster(settings?: ClusterSettings): void; export function fork(env?: any): Worker; export function disconnect(callback?: Function): void; export var worker: Worker; export var workers: Worker[]; // Event emitter export function addListener(event: string, listener: Function): void; export function on(event: string, listener: Function): any; export function once(event: string, listener: Function): void; export function removeListener(event: string, listener: Function): void; export function removeAllListeners(event?: string): void; export function setMaxListeners(n: number): void; export function listeners(event: string): Function[]; export function emit(event: string, ...args: any[]): boolean; } declare module "zlib" { import * as stream from "stream"; export interface ZlibOptions { chunkSize?: number; windowBits?: number; level?: number; memLevel?: number; strategy?: number; dictionary?: any; } export interface Gzip extends stream.Transform { } export interface Gunzip extends stream.Transform { } export interface Deflate extends stream.Transform { } export interface Inflate extends stream.Transform { } export interface DeflateRaw extends stream.Transform { } export interface InflateRaw extends stream.Transform { } export interface Unzip extends stream.Transform { } export function createGzip(options?: ZlibOptions): Gzip; export function createGunzip(options?: ZlibOptions): Gunzip; export function createDeflate(options?: ZlibOptions): Deflate; export function createInflate(options?: ZlibOptions): Inflate; export function createDeflateRaw(options?: ZlibOptions): DeflateRaw; export function createInflateRaw(options?: ZlibOptions): InflateRaw; export function createUnzip(options?: ZlibOptions): Unzip; export function deflate(buf: Buffer, callback: (error: Error, result: any) =>void ): void; export function deflateSync(buf: Buffer, options?: ZlibOptions): any; export function deflateRaw(buf: Buffer, callback: (error: Error, result: any) =>void ): void; export function deflateRawSync(buf: Buffer, options?: ZlibOptions): any; export function gzip(buf: Buffer, callback: (error: Error, result: any) =>void ): void; export function gzipSync(buf: Buffer, options?: ZlibOptions): any; export function gunzip(buf: Buffer, callback: (error: Error, result: any) =>void ): void; export function gunzipSync(buf: Buffer, options?: ZlibOptions): any; export function inflate(buf: Buffer, callback: (error: Error, result: any) =>void ): void; export function inflateSync(buf: Buffer, options?: ZlibOptions): any; export function inflateRaw(buf: Buffer, callback: (error: Error, result: any) =>void ): void; export function inflateRawSync(buf: Buffer, options?: ZlibOptions): any; export function unzip(buf: Buffer, callback: (error: Error, result: any) =>void ): void; export function unzipSync(buf: Buffer, options?: ZlibOptions): any; // Constants export var Z_NO_FLUSH: number; export var Z_PARTIAL_FLUSH: number; export var Z_SYNC_FLUSH: number; export var Z_FULL_FLUSH: number; export var Z_FINISH: number; export var Z_BLOCK: number; export var Z_TREES: number; export var Z_OK: number; export var Z_STREAM_END: number; export var Z_NEED_DICT: number; export var Z_ERRNO: number; export var Z_STREAM_ERROR: number; export var Z_DATA_ERROR: number; export var Z_MEM_ERROR: number; export var Z_BUF_ERROR: number; export var Z_VERSION_ERROR: number; export var Z_NO_COMPRESSION: number; export var Z_BEST_SPEED: number; export var Z_BEST_COMPRESSION: number; export var Z_DEFAULT_COMPRESSION: number; export var Z_FILTERED: number; export var Z_HUFFMAN_ONLY: number; export var Z_RLE: number; export var Z_FIXED: number; export var Z_DEFAULT_STRATEGY: number; export var Z_BINARY: number; export var Z_TEXT: number; export var Z_ASCII: number; export var Z_UNKNOWN: number; export var Z_DEFLATED: number; export var Z_NULL: number; } declare module "os" { export interface CpuInfo { model: string; speed: number; times: { user: number; nice: number; sys: number; idle: number; irq: number; } } export interface NetworkInterfaceInfo { address: string; netmask: string; family: string; mac: string; internal: boolean; } export function tmpdir(): string; export function homedir(): string; export function endianness(): string; export function hostname(): string; export function type(): string; export function platform(): string; export function arch(): string; export function release(): string; export function uptime(): number; export function loadavg(): number[]; export function totalmem(): number; export function freemem(): number; export function cpus(): CpuInfo[]; export function networkInterfaces(): {[index: string]: NetworkInterfaceInfo[]}; export var EOL: string; } declare module "https" { import * as tls from "tls"; import * as events from "events"; import * as http from "http"; export interface ServerOptions { pfx?: any; key?: any; passphrase?: string; cert?: any; ca?: any; crl?: any; ciphers?: string; honorCipherOrder?: boolean; requestCert?: boolean; rejectUnauthorized?: boolean; NPNProtocols?: any; SNICallback?: (servername: string) => any; } export interface RequestOptions extends http.RequestOptions{ pfx?: any; key?: any; passphrase?: string; cert?: any; ca?: any; ciphers?: string; rejectUnauthorized?: boolean; secureProtocol?: string; } export interface Agent { maxSockets: number; sockets: any; requests: any; } export var Agent: { new (options?: RequestOptions): Agent; }; export interface Server extends tls.Server { } export function createServer(options: ServerOptions, requestListener?: Function): Server; export function request(options: RequestOptions, callback?: (res: http.IncomingMessage) =>void ): http.ClientRequest; export function get(options: RequestOptions, callback?: (res: http.IncomingMessage) =>void ): http.ClientRequest; export var globalAgent: Agent; } declare module "punycode" { export function decode(string: string): string; export function encode(string: string): string; export function toUnicode(domain: string): string; export function toASCII(domain: string): string; export var ucs2: ucs2; interface ucs2 { decode(string: string): number[]; encode(codePoints: number[]): string; } export var version: any; } declare module "repl" { import * as stream from "stream"; import * as events from "events"; export interface ReplOptions { prompt?: string; input?: NodeJS.ReadableStream; output?: NodeJS.WritableStream; terminal?: boolean; eval?: Function; useColors?: boolean; useGlobal?: boolean; ignoreUndefined?: boolean; writer?: Function; } export function start(options: ReplOptions): events.EventEmitter; } declare module "readline" { import * as events from "events"; import * as stream from "stream"; export interface Key { sequence?: string; name?: string; ctrl?: boolean; meta?: boolean; shift?: boolean; } export interface ReadLine extends events.EventEmitter { setPrompt(prompt: string): void; prompt(preserveCursor?: boolean): void; question(query: string, callback: (answer: string) => void): void; pause(): ReadLine; resume(): ReadLine; close(): void; write(data: string|Buffer, key?: Key): void; } export interface Completer { (line: string): CompleterResult; (line: string, callback: (err: any, result: CompleterResult) => void): any; } export interface CompleterResult { completions: string[]; line: string; } export interface ReadLineOptions { input: NodeJS.ReadableStream; output?: NodeJS.WritableStream; completer?: Completer; terminal?: boolean; historySize?: number; } export function createInterface(input: NodeJS.ReadableStream, output?: NodeJS.WritableStream, completer?: Completer, terminal?: boolean): ReadLine; export function createInterface(options: ReadLineOptions): ReadLine; export function cursorTo(stream: NodeJS.WritableStream, x: number, y: number): void; export function moveCursor(stream: NodeJS.WritableStream, dx: number|string, dy: number|string): void; export function clearLine(stream: NodeJS.WritableStream, dir: number): void; export function clearScreenDown(stream: NodeJS.WritableStream): void; } declare module "vm" { export interface Context { } export interface Script { runInThisContext(): void; runInNewContext(sandbox?: Context): void; } export function runInThisContext(code: string, filename?: string): void; export function runInNewContext(code: string, sandbox?: Context, filename?: string): void; export function runInContext(code: string, context: Context, filename?: string): void; export function createContext(initSandbox?: Context): Context; export function createScript(code: string, filename?: string): Script; } declare module "child_process" { import * as events from "events"; import * as stream from "stream"; export interface ChildProcess extends events.EventEmitter { stdin: stream.Writable; stdout: stream.Readable; stderr: stream.Readable; pid: number; kill(signal?: string): void; send(message: any, sendHandle?: any): void; disconnect(): void; unref(): void; } export function spawn(command: string, args?: string[], options?: { cwd?: string; stdio?: any; custom?: any; env?: any; detached?: boolean; }): ChildProcess; export function exec(command: string, options: { cwd?: string; stdio?: any; customFds?: any; env?: any; encoding?: string; timeout?: number; maxBuffer?: number; killSignal?: string; }, callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess; export function exec(command: string, callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess; export function execFile(file: string, callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess; export function execFile(file: string, args?: string[], callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess; export function execFile(file: string, args?: string[], options?: { cwd?: string; stdio?: any; customFds?: any; env?: any; encoding?: string; timeout?: number; maxBuffer?: number; killSignal?: string; }, callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess; export function fork(modulePath: string, args?: string[], options?: { cwd?: string; env?: any; execPath?: string; execArgv?: string[]; silent?: boolean; uid?: number; gid?: number; }): ChildProcess; export function spawnSync(command: string, args?: string[], options?: { cwd?: string; input?: string | Buffer; stdio?: any; env?: any; uid?: number; gid?: number; timeout?: number; maxBuffer?: number; killSignal?: string; encoding?: string; }): { pid: number; output: string[]; stdout: string | Buffer; stderr: string | Buffer; status: number; signal: string; error: Error; }; export function execSync(command: string, options?: { cwd?: string; input?: string|Buffer; stdio?: any; env?: any; uid?: number; gid?: number; timeout?: number; maxBuffer?: number; killSignal?: string; encoding?: string; }): string | Buffer; export function execFileSync(command: string, args?: string[], options?: { cwd?: string; input?: string|Buffer; stdio?: any; env?: any; uid?: number; gid?: number; timeout?: number; maxBuffer?: number; killSignal?: string; encoding?: string; }): string | Buffer; } declare module "url" { export interface Url { href?: string; protocol?: string; auth?: string; hostname?: string; port?: string; host?: string; pathname?: string; search?: string; query?: any; // string | Object slashes?: boolean; hash?: string; path?: string; } export function parse(urlStr: string, parseQueryString?: boolean , slashesDenoteHost?: boolean ): Url; export function format(url: Url): string; export function resolve(from: string, to: string): string; } declare module "dns" { export function lookup(domain: string, family: number, callback: (err: Error, address: string, family: number) =>void ): string; export function lookup(domain: string, callback: (err: Error, address: string, family: number) =>void ): string; export function resolve(domain: string, rrtype: string, callback: (err: Error, addresses: string[]) =>void ): string[]; export function resolve(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[]; export function resolve4(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[]; export function resolve6(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[]; export function resolveMx(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[]; export function resolveTxt(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[]; export function resolveSrv(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[]; export function resolveNs(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[]; export function resolveCname(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[]; export function reverse(ip: string, callback: (err: Error, domains: string[]) =>void ): string[]; } declare module "net" { import * as stream from "stream"; export interface Socket extends stream.Duplex { // Extended base methods write(buffer: Buffer): boolean; write(buffer: Buffer, cb?: Function): boolean; write(str: string, cb?: Function): boolean; write(str: string, encoding?: string, cb?: Function): boolean; write(str: string, encoding?: string, fd?: string): boolean; connect(port: number, host?: string, connectionListener?: Function): void; connect(path: string, connectionListener?: Function): void; bufferSize: number; setEncoding(encoding?: string): void; write(data: any, encoding?: string, callback?: Function): void; destroy(): void; pause(): void; resume(): void; setTimeout(timeout: number, callback?: Function): void; setNoDelay(noDelay?: boolean): void; setKeepAlive(enable?: boolean, initialDelay?: number): void; address(): { port: number; family: string; address: string; }; unref(): void; ref(): void; remoteAddress: string; remoteFamily: string; remotePort: number; localAddress: string; localPort: number; bytesRead: number; bytesWritten: number; // Extended base methods end(): void; end(buffer: Buffer, cb?: Function): void; end(str: string, cb?: Function): void; end(str: string, encoding?: string, cb?: Function): void; end(data?: any, encoding?: string): void; } export var Socket: { new (options?: { fd?: string; type?: string; allowHalfOpen?: boolean; }): Socket; }; export interface Server extends Socket { listen(port: number, host?: string, backlog?: number, listeningListener?: Function): Server; listen(path: string, listeningListener?: Function): Server; listen(handle: any, listeningListener?: Function): Server; close(callback?: Function): Server; address(): { port: number; family: string; address: string; }; maxConnections: number; connections: number; } export function createServer(connectionListener?: (socket: Socket) =>void ): Server; export function createServer(options?: { allowHalfOpen?: boolean; }, connectionListener?: (socket: Socket) =>void ): Server; export function connect(options: { port: number, host?: string, localAddress? : string, localPort? : string, family? : number, allowHalfOpen?: boolean; }, connectionListener?: Function): Socket; export function connect(port: number, host?: string, connectionListener?: Function): Socket; export function connect(path: string, connectionListener?: Function): Socket; export function createConnection(options: { port: number, host?: string, localAddress? : string, localPort? : string, family? : number, allowHalfOpen?: boolean; }, connectionListener?: Function): Socket; export function createConnection(port: number, host?: string, connectionListener?: Function): Socket; export function createConnection(path: string, connectionListener?: Function): Socket; export function isIP(input: string): number; export function isIPv4(input: string): boolean; export function isIPv6(input: string): boolean; } declare module "dgram" { import * as events from "events"; interface RemoteInfo { address: string; port: number; size: number; } interface AddressInfo { address: string; family: string; port: number; } export function createSocket(type: string, callback?: (msg: Buffer, rinfo: RemoteInfo) => void): Socket; interface Socket extends events.EventEmitter { send(buf: Buffer, offset: number, length: number, port: number, address: string, callback?: (error: Error, bytes: number) => void): void; bind(port: number, address?: string, callback?: () => void): void; close(): void; address(): AddressInfo; setBroadcast(flag: boolean): void; setMulticastTTL(ttl: number): void; setMulticastLoopback(flag: boolean): void; addMembership(multicastAddress: string, multicastInterface?: string): void; dropMembership(multicastAddress: string, multicastInterface?: string): void; } } declare module "fs" { import * as stream from "stream"; import * as events from "events"; interface Stats { isFile(): boolean; isDirectory(): boolean; isBlockDevice(): boolean; isCharacterDevice(): boolean; isSymbolicLink(): boolean; isFIFO(): boolean; isSocket(): boolean; dev: number; ino: number; mode: number; nlink: number; uid: number; gid: number; rdev: number; size: number; blksize: number; blocks: number; atime: Date; mtime: Date; ctime: Date; birthtime: Date; } interface FSWatcher extends events.EventEmitter { close(): void; } export interface ReadStream extends stream.Readable { close(): void; } export interface WriteStream extends stream.Writable { close(): void; bytesWritten: number; } /** * Asynchronous rename. * @param oldPath * @param newPath * @param callback No arguments other than a possible exception are given to the completion callback. */ export function rename(oldPath: string, newPath: string, callback?: (err?: NodeJS.ErrnoException) => void): void; /** * Synchronous rename * @param oldPath * @param newPath */ export function renameSync(oldPath: string, newPath: string): void; export function truncate(path: string, callback?: (err?: NodeJS.ErrnoException) => void): void; export function truncate(path: string, len: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function truncateSync(path: string, len?: number): void; export function ftruncate(fd: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function ftruncate(fd: number, len: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function ftruncateSync(fd: number, len?: number): void; export function chown(path: string, uid: number, gid: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function chownSync(path: string, uid: number, gid: number): void; export function fchown(fd: number, uid: number, gid: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function fchownSync(fd: number, uid: number, gid: number): void; export function lchown(path: string, uid: number, gid: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function lchownSync(path: string, uid: number, gid: number): void; export function chmod(path: string, mode: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function chmod(path: string, mode: string, callback?: (err?: NodeJS.ErrnoException) => void): void; export function chmodSync(path: string, mode: number): void; export function chmodSync(path: string, mode: string): void; export function fchmod(fd: number, mode: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function fchmod(fd: number, mode: string, callback?: (err?: NodeJS.ErrnoException) => void): void; export function fchmodSync(fd: number, mode: number): void; export function fchmodSync(fd: number, mode: string): void; export function lchmod(path: string, mode: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function lchmod(path: string, mode: string, callback?: (err?: NodeJS.ErrnoException) => void): void; export function lchmodSync(path: string, mode: number): void; export function lchmodSync(path: string, mode: string): void; export function stat(path: string, callback?: (err: NodeJS.ErrnoException, stats: Stats) => any): void; export function lstat(path: string, callback?: (err: NodeJS.ErrnoException, stats: Stats) => any): void; export function fstat(fd: number, callback?: (err: NodeJS.ErrnoException, stats: Stats) => any): void; export function statSync(path: string): Stats; export function lstatSync(path: string): Stats; export function fstatSync(fd: number): Stats; export function link(srcpath: string, dstpath: string, callback?: (err?: NodeJS.ErrnoException) => void): void; export function linkSync(srcpath: string, dstpath: string): void; export function symlink(srcpath: string, dstpath: string, type?: string, callback?: (err?: NodeJS.ErrnoException) => void): void; export function symlinkSync(srcpath: string, dstpath: string, type?: string): void; export function readlink(path: string, callback?: (err: NodeJS.ErrnoException, linkString: string) => any): void; export function readlinkSync(path: string): string; export function realpath(path: string, callback?: (err: NodeJS.ErrnoException, resolvedPath: string) => any): void; export function realpath(path: string, cache: {[path: string]: string}, callback: (err: NodeJS.ErrnoException, resolvedPath: string) =>any): void; export function realpathSync(path: string, cache?: { [path: string]: string }): string; /* * Asynchronous unlink - deletes the file specified in {path} * * @param path * @param callback No arguments other than a possible exception are given to the completion callback. */ export function unlink(path: string, callback?: (err?: NodeJS.ErrnoException) => void): void; /* * Synchronous unlink - deletes the file specified in {path} * * @param path */ export function unlinkSync(path: string): void; /* * Asynchronous rmdir - removes the directory specified in {path} * * @param path * @param callback No arguments other than a possible exception are given to the completion callback. */ export function rmdir(path: string, callback?: (err?: NodeJS.ErrnoException) => void): void; /* * Synchronous rmdir - removes the directory specified in {path} * * @param path */ export function rmdirSync(path: string): void; /* * Asynchronous mkdir - creates the directory specified in {path}. Parameter {mode} defaults to 0777. * * @param path * @param callback No arguments other than a possible exception are given to the completion callback. */ export function mkdir(path: string, callback?: (err?: NodeJS.ErrnoException) => void): void; /* * Asynchronous mkdir - creates the directory specified in {path}. Parameter {mode} defaults to 0777. * * @param path * @param mode * @param callback No arguments other than a possible exception are given to the completion callback. */ export function mkdir(path: string, mode: number, callback?: (err?: NodeJS.ErrnoException) => void): void; /* * Asynchronous mkdir - creates the directory specified in {path}. Parameter {mode} defaults to 0777. * * @param path * @param mode * @param callback No arguments other than a possible exception are given to the completion callback. */ export function mkdir(path: string, mode: string, callback?: (err?: NodeJS.ErrnoException) => void): void; /* * Synchronous mkdir - creates the directory specified in {path}. Parameter {mode} defaults to 0777. * * @param path * @param mode * @param callback No arguments other than a possible exception are given to the completion callback. */ export function mkdirSync(path: string, mode?: number): void; /* * Synchronous mkdir - creates the directory specified in {path}. Parameter {mode} defaults to 0777. * * @param path * @param mode * @param callback No arguments other than a possible exception are given to the completion callback. */ export function mkdirSync(path: string, mode?: string): void; export function readdir(path: string, callback?: (err: NodeJS.ErrnoException, files: string[]) => void): void; export function readdirSync(path: string): string[]; export function close(fd: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function closeSync(fd: number): void; export function open(path: string, flags: string, callback?: (err: NodeJS.ErrnoException, fd: number) => any): void; export function open(path: string, flags: string, mode: number, callback?: (err: NodeJS.ErrnoException, fd: number) => any): void; export function open(path: string, flags: string, mode: string, callback?: (err: NodeJS.ErrnoException, fd: number) => any): void; export function openSync(path: string, flags: string, mode?: number): number; export function openSync(path: string, flags: string, mode?: string): number; export function utimes(path: string, atime: number, mtime: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function utimes(path: string, atime: Date, mtime: Date, callback?: (err?: NodeJS.ErrnoException) => void): void; export function utimesSync(path: string, atime: number, mtime: number): void; export function utimesSync(path: string, atime: Date, mtime: Date): void; export function futimes(fd: number, atime: number, mtime: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function futimes(fd: number, atime: Date, mtime: Date, callback?: (err?: NodeJS.ErrnoException) => void): void; export function futimesSync(fd: number, atime: number, mtime: number): void; export function futimesSync(fd: number, atime: Date, mtime: Date): void; export function fsync(fd: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function fsyncSync(fd: number): void; export function write(fd: number, buffer: Buffer, offset: number, length: number, position: number, callback?: (err: NodeJS.ErrnoException, written: number, buffer: Buffer) => void): void; export function write(fd: number, buffer: Buffer, offset: number, length: number, callback?: (err: NodeJS.ErrnoException, written: number, buffer: Buffer) => void): void; export function write(fd: number, data: any, callback?: (err: NodeJS.ErrnoException, written: number, str: string) => void): void; export function write(fd: number, data: any, offset: number, callback?: (err: NodeJS.ErrnoException, written: number, str: string) => void): void; export function write(fd: number, data: any, offset: number, encoding: string, callback?: (err: NodeJS.ErrnoException, written: number, str: string) => void): void; export function writeSync(fd: number, buffer: Buffer, offset: number, length: number, position: number): number; export function read(fd: number, buffer: Buffer, offset: number, length: number, position: number, callback?: (err: NodeJS.ErrnoException, bytesRead: number, buffer: Buffer) => void): void; export function readSync(fd: number, buffer: Buffer, offset: number, length: number, position: number): number; /* * Asynchronous readFile - Asynchronously reads the entire contents of a file. * * @param fileName * @param encoding * @param callback - The callback is passed two arguments (err, data), where data is the contents of the file. */ export function readFile(filename: string, encoding: string, callback: (err: NodeJS.ErrnoException, data: string) => void): void; /* * Asynchronous readFile - Asynchronously reads the entire contents of a file. * * @param fileName * @param options An object with optional {encoding} and {flag} properties. If {encoding} is specified, readFile returns a string; otherwise it returns a Buffer. * @param callback - The callback is passed two arguments (err, data), where data is the contents of the file. */ export function readFile(filename: string, options: { encoding: string; flag?: string; }, callback: (err: NodeJS.ErrnoException, data: string) => void): void; /* * Asynchronous readFile - Asynchronously reads the entire contents of a file. * * @param fileName * @param options An object with optional {encoding} and {flag} properties. If {encoding} is specified, readFile returns a string; otherwise it returns a Buffer. * @param callback - The callback is passed two arguments (err, data), where data is the contents of the file. */ export function readFile(filename: string, options: { flag?: string; }, callback: (err: NodeJS.ErrnoException, data: Buffer) => void): void; /* * Asynchronous readFile - Asynchronously reads the entire contents of a file. * * @param fileName * @param callback - The callback is passed two arguments (err, data), where data is the contents of the file. */ export function readFile(filename: string, callback: (err: NodeJS.ErrnoException, data: Buffer) => void): void; /* * Synchronous readFile - Synchronously reads the entire contents of a file. * * @param fileName * @param encoding */ export function readFileSync(filename: string, encoding: string): string; /* * Synchronous readFile - Synchronously reads the entire contents of a file. * * @param fileName * @param options An object with optional {encoding} and {flag} properties. If {encoding} is specified, readFileSync returns a string; otherwise it returns a Buffer. */ export function readFileSync(filename: string, options: { encoding: string; flag?: string; }): string; /* * Synchronous readFile - Synchronously reads the entire contents of a file. * * @param fileName * @param options An object with optional {encoding} and {flag} properties. If {encoding} is specified, readFileSync returns a string; otherwise it returns a Buffer. */ export function readFileSync(filename: string, options?: { flag?: string; }): Buffer; export function writeFile(filename: string, data: any, callback?: (err: NodeJS.ErrnoException) => void): void; export function writeFile(filename: string, data: any, options: { encoding?: string; mode?: number; flag?: string; }, callback?: (err: NodeJS.ErrnoException) => void): void; export function writeFile(filename: string, data: any, options: { encoding?: string; mode?: string; flag?: string; }, callback?: (err: NodeJS.ErrnoException) => void): void; export function writeFileSync(filename: string, data: any, options?: { encoding?: string; mode?: number; flag?: string; }): void; export function writeFileSync(filename: string, data: any, options?: { encoding?: string; mode?: string; flag?: string; }): void; export function appendFile(filename: string, data: any, options: { encoding?: string; mode?: number; flag?: string; }, callback?: (err: NodeJS.ErrnoException) => void): void; export function appendFile(filename: string, data: any, options: { encoding?: string; mode?: string; flag?: string; }, callback?: (err: NodeJS.ErrnoException) => void): void; export function appendFile(filename: string, data: any, callback?: (err: NodeJS.ErrnoException) => void): void; export function appendFileSync(filename: string, data: any, options?: { encoding?: string; mode?: number; flag?: string; }): void; export function appendFileSync(filename: string, data: any, options?: { encoding?: string; mode?: string; flag?: string; }): void; export function watchFile(filename: string, listener: (curr: Stats, prev: Stats) => void): void; export function watchFile(filename: string, options: { persistent?: boolean; interval?: number; }, listener: (curr: Stats, prev: Stats) => void): void; export function unwatchFile(filename: string, listener?: (curr: Stats, prev: Stats) => void): void; export function watch(filename: string, listener?: (event: string, filename: string) => any): FSWatcher; export function watch(filename: string, options: { persistent?: boolean; }, listener?: (event: string, filename: string) => any): FSWatcher; export function exists(path: string, callback?: (exists: boolean) => void): void; export function existsSync(path: string): boolean; /** Constant for fs.access(). File is visible to the calling process. */ export var F_OK: number; /** Constant for fs.access(). File can be read by the calling process. */ export var R_OK: number; /** Constant for fs.access(). File can be written by the calling process. */ export var W_OK: number; /** Constant for fs.access(). File can be executed by the calling process. */ export var X_OK: number; /** Tests a user's permissions for the file specified by path. */ export function access(path: string, callback: (err: NodeJS.ErrnoException) => void): void; export function access(path: string, mode: number, callback: (err: NodeJS.ErrnoException) => void): void; /** Synchronous version of fs.access. This throws if any accessibility checks fail, and does nothing otherwise. */ export function accessSync(path: string, mode ?: number): void; export function createReadStream(path: string, options?: { flags?: string; encoding?: string; fd?: number; mode?: number; autoClose?: boolean; }): ReadStream; export function createWriteStream(path: string, options?: { flags?: string; encoding?: string; fd?: number; mode?: number; }): WriteStream; } declare module "path" { /** * A parsed path object generated by path.parse() or consumed by path.format(). */ export interface ParsedPath { /** * The root of the path such as '/' or 'c:\' */ root: string; /** * The full directory path such as '/home/user/dir' or 'c:\path\dir' */ dir: string; /** * The file name including extension (if any) such as 'index.html' */ base: string; /** * The file extension (if any) such as '.html' */ ext: string; /** * The file name without extension (if any) such as 'index' */ name: string; } /** * Normalize a string path, reducing '..' and '.' parts. * When multiple slashes are found, they're replaced by a single one; when the path contains a trailing slash, it is preserved. On Windows backslashes are used. * * @param p string path to normalize. */ export function normalize(p: string): string; /** * Join all arguments together and normalize the resulting path. * Arguments must be strings. In v0.8, non-string arguments were silently ignored. In v0.10 and up, an exception is thrown. * * @param paths string paths to join. */ export function join(...paths: any[]): string; /** * Join all arguments together and normalize the resulting path. * Arguments must be strings. In v0.8, non-string arguments were silently ignored. In v0.10 and up, an exception is thrown. * * @param paths string paths to join. */ export function join(...paths: string[]): string; /** * The right-most parameter is considered {to}. Other parameters are considered an array of {from}. * * Starting from leftmost {from} paramter, resolves {to} to an absolute path. * * If {to} isn't already absolute, {from} arguments are prepended in right to left order, until an absolute path is found. If after using all {from} paths still no absolute path is found, the current working directory is used as well. The resulting path is normalized, and trailing slashes are removed unless the path gets resolved to the root directory. * * @param pathSegments string paths to join. Non-string arguments are ignored. */ export function resolve(...pathSegments: any[]): string; /** * Determines whether {path} is an absolute path. An absolute path will always resolve to the same location, regardless of the working directory. * * @param path path to test. */ export function isAbsolute(path: string): boolean; /** * Solve the relative path from {from} to {to}. * At times we have two absolute paths, and we need to derive the relative path from one to the other. This is actually the reverse transform of path.resolve. * * @param from * @param to */ export function relative(from: string, to: string): string; /** * Return the directory name of a path. Similar to the Unix dirname command. * * @param p the path to evaluate. */ export function dirname(p: string): string; /** * Return the last portion of a path. Similar to the Unix basename command. * Often used to extract the file name from a fully qualified path. * * @param p the path to evaluate. * @param ext optionally, an extension to remove from the result. */ export function basename(p: string, ext?: string): string; /** * Return the extension of the path, from the last '.' to end of string in the last portion of the path. * If there is no '.' in the last portion of the path or the first character of it is '.', then it returns an empty string * * @param p the path to evaluate. */ export function extname(p: string): string; /** * The platform-specific file separator. '\\' or '/'. */ export var sep: string; /** * The platform-specific file delimiter. ';' or ':'. */ export var delimiter: string; /** * Returns an object from a path string - the opposite of format(). * * @param pathString path to evaluate. */ export function parse(pathString: string): ParsedPath; /** * Returns a path string from an object - the opposite of parse(). * * @param pathString path to evaluate. */ export function format(pathObject: ParsedPath): string; export module posix { export function normalize(p: string): string; export function join(...paths: any[]): string; export function resolve(...pathSegments: any[]): string; export function isAbsolute(p: string): boolean; export function relative(from: string, to: string): string; export function dirname(p: string): string; export function basename(p: string, ext?: string): string; export function extname(p: string): string; export var sep: string; export var delimiter: string; export function parse(p: string): ParsedPath; export function format(pP: ParsedPath): string; } export module win32 { export function normalize(p: string): string; export function join(...paths: any[]): string; export function resolve(...pathSegments: any[]): string; export function isAbsolute(p: string): boolean; export function relative(from: string, to: string): string; export function dirname(p: string): string; export function basename(p: string, ext?: string): string; export function extname(p: string): string; export var sep: string; export var delimiter: string; export function parse(p: string): ParsedPath; export function format(pP: ParsedPath): string; } } declare module "string_decoder" { export interface NodeStringDecoder { write(buffer: Buffer): string; detectIncompleteChar(buffer: Buffer): number; } export var StringDecoder: { new (encoding: string): NodeStringDecoder; }; } declare module "tls" { import * as crypto from "crypto"; import * as net from "net"; import * as stream from "stream"; var CLIENT_RENEG_LIMIT: number; var CLIENT_RENEG_WINDOW: number; export interface TlsOptions { host?: string; port?: number; pfx?: any; //string or buffer key?: any; //string or buffer passphrase?: string; cert?: any; ca?: any; //string or buffer crl?: any; //string or string array ciphers?: string; honorCipherOrder?: any; requestCert?: boolean; rejectUnauthorized?: boolean; NPNProtocols?: any; //array or Buffer; SNICallback?: (servername: string) => any; } export interface ConnectionOptions { host?: string; port?: number; socket?: net.Socket; pfx?: any; //string | Buffer key?: any; //string | Buffer passphrase?: string; cert?: any; //string | Buffer ca?: any; //Array of string | Buffer rejectUnauthorized?: boolean; NPNProtocols?: any; //Array of string | Buffer servername?: string; } export interface Server extends net.Server { // Extended base methods listen(port: number, host?: string, backlog?: number, listeningListener?: Function): Server; listen(path: string, listeningListener?: Function): Server; listen(handle: any, listeningListener?: Function): Server; listen(port: number, host?: string, callback?: Function): Server; close(): Server; address(): { port: number; family: string; address: string; }; addContext(hostName: string, credentials: { key: string; cert: string; ca: string; }): void; maxConnections: number; connections: number; } export interface ClearTextStream extends stream.Duplex { authorized: boolean; authorizationError: Error; getPeerCertificate(): any; getCipher: { name: string; version: string; }; address: { port: number; family: string; address: string; }; remoteAddress: string; remotePort: number; } export interface SecurePair { encrypted: any; cleartext: any; } export interface SecureContextOptions { pfx?: any; //string | buffer key?: any; //string | buffer passphrase?: string; cert?: any; // string | buffer ca?: any; // string | buffer crl?: any; // string | string[] ciphers?: string; honorCipherOrder?: boolean; } export interface SecureContext { context: any; } export function createServer(options: TlsOptions, secureConnectionListener?: (cleartextStream: ClearTextStream) =>void ): Server; export function connect(options: TlsOptions, secureConnectionListener?: () =>void ): ClearTextStream; export function connect(port: number, host?: string, options?: ConnectionOptions, secureConnectListener?: () =>void ): ClearTextStream; export function connect(port: number, options?: ConnectionOptions, secureConnectListener?: () =>void ): ClearTextStream; export function createSecurePair(credentials?: crypto.Credentials, isServer?: boolean, requestCert?: boolean, rejectUnauthorized?: boolean): SecurePair; export function createSecureContext(details: SecureContextOptions): SecureContext; } declare module "crypto" { export interface CredentialDetails { pfx: string; key: string; passphrase: string; cert: string; ca: any; //string | string array crl: any; //string | string array ciphers: string; } export interface Credentials { context?: any; } export function createCredentials(details: CredentialDetails): Credentials; export function createHash(algorithm: string): Hash; export function createHmac(algorithm: string, key: string): Hmac; export function createHmac(algorithm: string, key: Buffer): Hmac; export interface Hash { update(data: any, input_encoding?: string): Hash; digest(encoding: 'buffer'): Buffer; digest(encoding: string): any; digest(): Buffer; } export interface Hmac extends NodeJS.ReadWriteStream { update(data: any, input_encoding?: string): Hmac; digest(encoding: 'buffer'): Buffer; digest(encoding: string): any; digest(): Buffer; } export function createCipher(algorithm: string, password: any): Cipher; export function createCipheriv(algorithm: string, key: any, iv: any): Cipher; export interface Cipher { update(data: Buffer): Buffer; update(data: string, input_encoding?: string, output_encoding?: string): string; final(): Buffer; final(output_encoding: string): string; setAutoPadding(auto_padding: boolean): void; } export function createDecipher(algorithm: string, password: any): Decipher; export function createDecipheriv(algorithm: string, key: any, iv: any): Decipher; export interface Decipher { update(data: Buffer): Buffer; update(data: string, input_encoding?: string, output_encoding?: string): string; final(): Buffer; final(output_encoding: string): string; setAutoPadding(auto_padding: boolean): void; } export function createSign(algorithm: string): Signer; export interface Signer extends NodeJS.WritableStream { update(data: any): void; sign(private_key: string, output_format: string): string; } export function createVerify(algorith: string): Verify; export interface Verify extends NodeJS.WritableStream { update(data: any): void; verify(object: string, signature: string, signature_format?: string): boolean; } export function createDiffieHellman(prime_length: number): DiffieHellman; export function createDiffieHellman(prime: number, encoding?: string): DiffieHellman; export interface DiffieHellman { generateKeys(encoding?: string): string; computeSecret(other_public_key: string, input_encoding?: string, output_encoding?: string): string; getPrime(encoding?: string): string; getGenerator(encoding: string): string; getPublicKey(encoding?: string): string; getPrivateKey(encoding?: string): string; setPublicKey(public_key: string, encoding?: string): void; setPrivateKey(public_key: string, encoding?: string): void; } export function getDiffieHellman(group_name: string): DiffieHellman; export function pbkdf2(password: string|Buffer, salt: string|Buffer, iterations: number, keylen: number, callback: (err: Error, derivedKey: Buffer) => any): void; export function pbkdf2(password: string|Buffer, salt: string|Buffer, iterations: number, keylen: number, digest: string, callback: (err: Error, derivedKey: Buffer) => any): void; export function pbkdf2Sync(password: string|Buffer, salt: string|Buffer, iterations: number, keylen: number) : Buffer; export function pbkdf2Sync(password: string|Buffer, salt: string|Buffer, iterations: number, keylen: number, digest: string) : Buffer; export function randomBytes(size: number): Buffer; export function randomBytes(size: number, callback: (err: Error, buf: Buffer) =>void ): void; export function pseudoRandomBytes(size: number): Buffer; export function pseudoRandomBytes(size: number, callback: (err: Error, buf: Buffer) =>void ): void; } declare module "stream" { import * as events from "events"; export class Stream extends events.EventEmitter { pipe(destination: T, options?: { end?: boolean; }): T; } export interface ReadableOptions { highWaterMark?: number; encoding?: string; objectMode?: boolean; } export class Readable extends events.EventEmitter implements NodeJS.ReadableStream { readable: boolean; constructor(opts?: ReadableOptions); _read(size: number): void; read(size?: number): any; setEncoding(encoding: string): void; pause(): void; resume(): void; pipe(destination: T, options?: { end?: boolean; }): T; unpipe(destination?: T): void; unshift(chunk: any): void; wrap(oldStream: NodeJS.ReadableStream): NodeJS.ReadableStream; push(chunk: any, encoding?: string): boolean; } export interface WritableOptions { highWaterMark?: number; decodeStrings?: boolean; objectMode?: boolean; } export class Writable extends events.EventEmitter implements NodeJS.WritableStream { writable: boolean; constructor(opts?: WritableOptions); _write(chunk: any, encoding: string, callback: Function): void; write(chunk: any, cb?: Function): boolean; write(chunk: any, encoding?: string, cb?: Function): boolean; end(): void; end(chunk: any, cb?: Function): void; end(chunk: any, encoding?: string, cb?: Function): void; } export interface DuplexOptions extends ReadableOptions, WritableOptions { allowHalfOpen?: boolean; } // Note: Duplex extends both Readable and Writable. export class Duplex extends Readable implements NodeJS.ReadWriteStream { writable: boolean; constructor(opts?: DuplexOptions); _write(chunk: any, encoding: string, callback: Function): void; write(chunk: any, cb?: Function): boolean; write(chunk: any, encoding?: string, cb?: Function): boolean; end(): void; end(chunk: any, cb?: Function): void; end(chunk: any, encoding?: string, cb?: Function): void; } export interface TransformOptions extends ReadableOptions, WritableOptions {} // Note: Transform lacks the _read and _write methods of Readable/Writable. export class Transform extends events.EventEmitter implements NodeJS.ReadWriteStream { readable: boolean; writable: boolean; constructor(opts?: TransformOptions); _transform(chunk: any, encoding: string, callback: Function): void; _flush(callback: Function): void; read(size?: number): any; setEncoding(encoding: string): void; pause(): void; resume(): void; pipe(destination: T, options?: { end?: boolean; }): T; unpipe(destination?: T): void; unshift(chunk: any): void; wrap(oldStream: NodeJS.ReadableStream): NodeJS.ReadableStream; push(chunk: any, encoding?: string): boolean; write(chunk: any, cb?: Function): boolean; write(chunk: any, encoding?: string, cb?: Function): boolean; end(): void; end(chunk: any, cb?: Function): void; end(chunk: any, encoding?: string, cb?: Function): void; } export class PassThrough extends Transform {} } declare module "util" { export interface InspectOptions { showHidden?: boolean; depth?: number; colors?: boolean; customInspect?: boolean; } export function format(format: any, ...param: any[]): string; export function debug(string: string): void; export function error(...param: any[]): void; export function puts(...param: any[]): void; export function print(...param: any[]): void; export function log(string: string): void; export function inspect(object: any, showHidden?: boolean, depth?: number, color?: boolean): string; export function inspect(object: any, options: InspectOptions): string; export function isArray(object: any): boolean; export function isRegExp(object: any): boolean; export function isDate(object: any): boolean; export function isError(object: any): boolean; export function inherits(constructor: any, superConstructor: any): void; export function debuglog(key:string): (msg:string,...param: any[])=>void; } declare module "assert" { function internal (value: any, message?: string): void; module internal { export class AssertionError implements Error { name: string; message: string; actual: any; expected: any; operator: string; generatedMessage: boolean; constructor(options?: {message?: string; actual?: any; expected?: any; operator?: string; stackStartFunction?: Function}); } export function fail(actual?: any, expected?: any, message?: string, operator?: string): void; export function ok(value: any, message?: string): void; export function equal(actual: any, expected: any, message?: string): void; export function notEqual(actual: any, expected: any, message?: string): void; export function deepEqual(actual: any, expected: any, message?: string): void; export function notDeepEqual(acutal: any, expected: any, message?: string): void; export function strictEqual(actual: any, expected: any, message?: string): void; export function notStrictEqual(actual: any, expected: any, message?: string): void; export function deepStrictEqual(actual: any, expected: any, message?: string): void; export function notDeepStrictEqual(actual: any, expected: any, message?: string): void; export var throws: { (block: Function, message?: string): void; (block: Function, error: Function, message?: string): void; (block: Function, error: RegExp, message?: string): void; (block: Function, error: (err: any) => boolean, message?: string): void; }; export var doesNotThrow: { (block: Function, message?: string): void; (block: Function, error: Function, message?: string): void; (block: Function, error: RegExp, message?: string): void; (block: Function, error: (err: any) => boolean, message?: string): void; }; export function ifError(value: any): void; } export = internal; } declare module "tty" { import * as net from "net"; export function isatty(fd: number): boolean; export interface ReadStream extends net.Socket { isRaw: boolean; setRawMode(mode: boolean): void; isTTY: boolean; } export interface WriteStream extends net.Socket { columns: number; rows: number; isTTY: boolean; } } declare module "domain" { import * as events from "events"; export class Domain extends events.EventEmitter { run(fn: Function): void; add(emitter: events.EventEmitter): void; remove(emitter: events.EventEmitter): void; bind(cb: (err: Error, data: any) => any): any; intercept(cb: (data: any) => any): any; dispose(): void; addListener(event: string, listener: Function): Domain; on(event: string, listener: Function): Domain; once(event: string, listener: Function): Domain; removeListener(event: string, listener: Function): Domain; removeAllListeners(event?: string): Domain; } export function create(): Domain; } declare module "constants" { export var E2BIG: number; export var EACCES: number; export var EADDRINUSE: number; export var EADDRNOTAVAIL: number; export var EAFNOSUPPORT: number; export var EAGAIN: number; export var EALREADY: number; export var EBADF: number; export var EBADMSG: number; export var EBUSY: number; export var ECANCELED: number; export var ECHILD: number; export var ECONNABORTED: number; export var ECONNREFUSED: number; export var ECONNRESET: number; export var EDEADLK: number; export var EDESTADDRREQ: number; export var EDOM: number; export var EEXIST: number; export var EFAULT: number; export var EFBIG: number; export var EHOSTUNREACH: number; export var EIDRM: number; export var EILSEQ: number; export var EINPROGRESS: number; export var EINTR: number; export var EINVAL: number; export var EIO: number; export var EISCONN: number; export var EISDIR: number; export var ELOOP: number; export var EMFILE: number; export var EMLINK: number; export var EMSGSIZE: number; export var ENAMETOOLONG: number; export var ENETDOWN: number; export var ENETRESET: number; export var ENETUNREACH: number; export var ENFILE: number; export var ENOBUFS: number; export var ENODATA: number; export var ENODEV: number; export var ENOENT: number; export var ENOEXEC: number; export var ENOLCK: number; export var ENOLINK: number; export var ENOMEM: number; export var ENOMSG: number; export var ENOPROTOOPT: number; export var ENOSPC: number; export var ENOSR: number; export var ENOSTR: number; export var ENOSYS: number; export var ENOTCONN: number; export var ENOTDIR: number; export var ENOTEMPTY: number; export var ENOTSOCK: number; export var ENOTSUP: number; export var ENOTTY: number; export var ENXIO: number; export var EOPNOTSUPP: number; export var EOVERFLOW: number; export var EPERM: number; export var EPIPE: number; export var EPROTO: number; export var EPROTONOSUPPORT: number; export var EPROTOTYPE: number; export var ERANGE: number; export var EROFS: number; export var ESPIPE: number; export var ESRCH: number; export var ETIME: number; export var ETIMEDOUT: number; export var ETXTBSY: number; export var EWOULDBLOCK: number; export var EXDEV: number; export var WSAEINTR: number; export var WSAEBADF: number; export var WSAEACCES: number; export var WSAEFAULT: number; export var WSAEINVAL: number; export var WSAEMFILE: number; export var WSAEWOULDBLOCK: number; export var WSAEINPROGRESS: number; export var WSAEALREADY: number; export var WSAENOTSOCK: number; export var WSAEDESTADDRREQ: number; export var WSAEMSGSIZE: number; export var WSAEPROTOTYPE: number; export var WSAENOPROTOOPT: number; export var WSAEPROTONOSUPPORT: number; export var WSAESOCKTNOSUPPORT: number; export var WSAEOPNOTSUPP: number; export var WSAEPFNOSUPPORT: number; export var WSAEAFNOSUPPORT: number; export var WSAEADDRINUSE: number; export var WSAEADDRNOTAVAIL: number; export var WSAENETDOWN: number; export var WSAENETUNREACH: number; export var WSAENETRESET: number; export var WSAECONNABORTED: number; export var WSAECONNRESET: number; export var WSAENOBUFS: number; export var WSAEISCONN: number; export var WSAENOTCONN: number; export var WSAESHUTDOWN: number; export var WSAETOOMANYREFS: number; export var WSAETIMEDOUT: number; export var WSAECONNREFUSED: number; export var WSAELOOP: number; export var WSAENAMETOOLONG: number; export var WSAEHOSTDOWN: number; export var WSAEHOSTUNREACH: number; export var WSAENOTEMPTY: number; export var WSAEPROCLIM: number; export var WSAEUSERS: number; export var WSAEDQUOT: number; export var WSAESTALE: number; export var WSAEREMOTE: number; export var WSASYSNOTREADY: number; export var WSAVERNOTSUPPORTED: number; export var WSANOTINITIALISED: number; export var WSAEDISCON: number; export var WSAENOMORE: number; export var WSAECANCELLED: number; export var WSAEINVALIDPROCTABLE: number; export var WSAEINVALIDPROVIDER: number; export var WSAEPROVIDERFAILEDINIT: number; export var WSASYSCALLFAILURE: number; export var WSASERVICE_NOT_FOUND: number; export var WSATYPE_NOT_FOUND: number; export var WSA_E_NO_MORE: number; export var WSA_E_CANCELLED: number; export var WSAEREFUSED: number; export var SIGHUP: number; export var SIGINT: number; export var SIGILL: number; export var SIGABRT: number; export var SIGFPE: number; export var SIGKILL: number; export var SIGSEGV: number; export var SIGTERM: number; export var SIGBREAK: number; export var SIGWINCH: number; export var SSL_OP_ALL: number; export var SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION: number; export var SSL_OP_CIPHER_SERVER_PREFERENCE: number; export var SSL_OP_CISCO_ANYCONNECT: number; export var SSL_OP_COOKIE_EXCHANGE: number; export var SSL_OP_CRYPTOPRO_TLSEXT_BUG: number; export var SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS: number; export var SSL_OP_EPHEMERAL_RSA: number; export var SSL_OP_LEGACY_SERVER_CONNECT: number; export var SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER: number; export var SSL_OP_MICROSOFT_SESS_ID_BUG: number; export var SSL_OP_MSIE_SSLV2_RSA_PADDING: number; export var SSL_OP_NETSCAPE_CA_DN_BUG: number; export var SSL_OP_NETSCAPE_CHALLENGE_BUG: number; export var SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG: number; export var SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG: number; export var SSL_OP_NO_COMPRESSION: number; export var SSL_OP_NO_QUERY_MTU: number; export var SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION: number; export var SSL_OP_NO_SSLv2: number; export var SSL_OP_NO_SSLv3: number; export var SSL_OP_NO_TICKET: number; export var SSL_OP_NO_TLSv1: number; export var SSL_OP_NO_TLSv1_1: number; export var SSL_OP_NO_TLSv1_2: number; export var SSL_OP_PKCS1_CHECK_1: number; export var SSL_OP_PKCS1_CHECK_2: number; export var SSL_OP_SINGLE_DH_USE: number; export var SSL_OP_SINGLE_ECDH_USE: number; export var SSL_OP_SSLEAY_080_CLIENT_DH_BUG: number; export var SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG: number; export var SSL_OP_TLS_BLOCK_PADDING_BUG: number; export var SSL_OP_TLS_D5_BUG: number; export var SSL_OP_TLS_ROLLBACK_BUG: number; export var ENGINE_METHOD_DSA: number; export var ENGINE_METHOD_DH: number; export var ENGINE_METHOD_RAND: number; export var ENGINE_METHOD_ECDH: number; export var ENGINE_METHOD_ECDSA: number; export var ENGINE_METHOD_CIPHERS: number; export var ENGINE_METHOD_DIGESTS: number; export var ENGINE_METHOD_STORE: number; export var ENGINE_METHOD_PKEY_METHS: number; export var ENGINE_METHOD_PKEY_ASN1_METHS: number; export var ENGINE_METHOD_ALL: number; export var ENGINE_METHOD_NONE: number; export var DH_CHECK_P_NOT_SAFE_PRIME: number; export var DH_CHECK_P_NOT_PRIME: number; export var DH_UNABLE_TO_CHECK_GENERATOR: number; export var DH_NOT_SUITABLE_GENERATOR: number; export var NPN_ENABLED: number; export var RSA_PKCS1_PADDING: number; export var RSA_SSLV23_PADDING: number; export var RSA_NO_PADDING: number; export var RSA_PKCS1_OAEP_PADDING: number; export var RSA_X931_PADDING: number; export var RSA_PKCS1_PSS_PADDING: number; export var POINT_CONVERSION_COMPRESSED: number; export var POINT_CONVERSION_UNCOMPRESSED: number; export var POINT_CONVERSION_HYBRID: number; export var O_RDONLY: number; export var O_WRONLY: number; export var O_RDWR: number; export var S_IFMT: number; export var S_IFREG: number; export var S_IFDIR: number; export var S_IFCHR: number; export var S_IFLNK: number; export var O_CREAT: number; export var O_EXCL: number; export var O_TRUNC: number; export var O_APPEND: number; export var F_OK: number; export var R_OK: number; export var W_OK: number; export var X_OK: number; export var UV_UDP_REUSEADDR: number; } WebDevelopment-assignment-2/server/typings/serve-static/000077500000000000000000000000001266350324300237235ustar00rootroot00000000000000WebDevelopment-assignment-2/server/typings/serve-static/serve-static.d.ts000077500000000000000000000067001266350324300271340ustar00rootroot00000000000000// Type definitions for serve-static 1.7.1 // Project: https://github.com/expressjs/serve-static // Definitions by: Uros Smolnik // Definitions: https://github.com/borisyankov/DefinitelyTyped /* =================== USAGE =================== import * as serveStatic from "serve-static"; app.use(serveStatic("public/ftp", {"index": ["default.html", "default.htm"]})) =============================================== */ /// /// declare module "serve-static" { import * as express from "express"; /** * Create a new middleware function to serve files from within a given root directory. * The file to serve will be determined by combining req.url with the provided root directory. * When a file is not found, instead of sending a 404 response, this module will instead call next() to move on to the next middleware, allowing for stacking and fall-backs. */ function serveStatic(root: string, options?: { /** * Set how "dotfiles" are treated when encountered. A dotfile is a file or directory that begins with a dot ("."). * Note this check is done on the path itself without checking if the path actually exists on the disk. * If root is specified, only the dotfiles above the root are checked (i.e. the root itself can be within a dotfile when when set to "deny"). * The default value is 'ignore'. * 'allow' No special treatment for dotfiles * 'deny' Send a 403 for any request for a dotfile * 'ignore' Pretend like the dotfile does not exist and call next() */ dotfiles?: string; /** * Enable or disable etag generation, defaults to true. */ etag?: boolean; /** * Set file extension fallbacks. When set, if a file is not found, the given extensions will be added to the file name and search for. * The first that exists will be served. Example: ['html', 'htm']. * The default value is false. */ extensions?: string[]; /** * By default this module will send "index.html" files in response to a request on a directory. * To disable this set false or to supply a new index pass a string or an array in preferred order. */ index?: boolean|string|string[]; /** * Enable or disable Last-Modified header, defaults to true. Uses the file system's last modified value. */ lastModified?: boolean; /** * Provide a max-age in milliseconds for http caching, defaults to 0. This can also be a string accepted by the ms module. */ maxAge?: number|string; /** * Redirect to trailing "/" when the pathname is a dir. Defaults to true. */ redirect?: boolean; /** * Function to set custom headers on response. Alterations to the headers need to occur synchronously. * The function is called as fn(res, path, stat), where the arguments are: * res the response object * path the file path that is being sent * stat the stat object of the file that is being sent */ setHeaders?: (res: express.Response, path: string, stat: any) => any; }): express.Handler; import * as m from "mime"; module serveStatic { var mime: typeof m; } export = serveStatic; } WebDevelopment-assignment-2/server/typings/tsd.d.ts000077500000000000000000000002671266350324300227060ustar00rootroot00000000000000 /// /// /// /// WebDevelopment-assignment-2/tsconfig.json000066400000000000000000000004651266350324300210230ustar00rootroot00000000000000{ "compilerOptions": { "target": "ES5", "module": "commonjs", "sourceMap": true, "emitDecoratorMetadata": true, "experimentalDecorators": true, "removeComments": false, "noImplicitAny": false }, "files": [ "gulpfile.ts", "node_modules/typescript/lib/lib.es6.d.ts" ] }WebDevelopment-assignment-2/typings.json000066400000000000000000000017461266350324300207070ustar00rootroot00000000000000{ "ambientDependencies": { "del": "github:DefinitelyTyped/DefinitelyTyped/del/del.d.ts#9027703c0bd831319dcdf7f3169f7a468537f448", "glob": "github:DefinitelyTyped/DefinitelyTyped/glob/glob.d.ts#a14d724826174d1669d4df04c80f4838b7e71fdf", "gulp-sourcemaps": "github:DefinitelyTyped/DefinitelyTyped/gulp-sourcemaps/gulp-sourcemaps.d.ts#5d6c3bdb5d936b257f22961890141a999e19daef", "gulp-typescript": "github:DefinitelyTyped/DefinitelyTyped/gulp-typescript/gulp-typescript.d.ts#960fd659b456e2fb5d23c52794ffdc56b09796cf", "lodash": "github:DefinitelyTyped/DefinitelyTyped/lodash/lodash.d.ts#c22a5e55b062c7b2af9df92ea0820c2afa153b2a", "minimatch": "github:DefinitelyTyped/DefinitelyTyped/minimatch/minimatch.d.ts#a3900b896f7b3361b79f9b503224777619907d53", "node": "github:DefinitelyTyped/DefinitelyTyped/node/node.d.ts#20e1eb9616922d382d918cc5a21870a9dbe255f5" }, "dependencies": { "gulp": "github:typed-typings/npm-gulp#504da08753acdfe9dd2c415ab8fe36151e9645c1" } } WebDevelopment-assignment-2/typings/000077500000000000000000000000001266350324300200045ustar00rootroot00000000000000WebDevelopment-assignment-2/typings/browser.d.ts000066400000000000000000000011031266350324300222540ustar00rootroot00000000000000/// /// /// /// /// /// /// /// /// WebDevelopment-assignment-2/typings/browser/000077500000000000000000000000001266350324300214675ustar00rootroot00000000000000WebDevelopment-assignment-2/typings/browser/ambient/000077500000000000000000000000001266350324300231065ustar00rootroot00000000000000WebDevelopment-assignment-2/typings/browser/ambient/del/000077500000000000000000000000001266350324300236525ustar00rootroot00000000000000WebDevelopment-assignment-2/typings/browser/ambient/del/del.d.ts000066400000000000000000000020121266350324300252030ustar00rootroot00000000000000// Compiled using typings@0.6.8 // Source: https://raw.githubusercontent.com/DefinitelyTyped/DefinitelyTyped/9027703c0bd831319dcdf7f3169f7a468537f448/del/del.d.ts // Type definitions for del v2.2.0 // Project: https://github.com/sindresorhus/del // Definitions by: Asana , Aya Morisawa // Definitions: https://github.com/borisyankov/DefinitelyTyped declare module "del" { import glob = require("glob"); function Del(pattern: string): Promise; function Del(pattern: string, options: Del.Options): Promise; function Del(patterns: string[]): Promise; function Del(patterns: string[], options: Del.Options): Promise; module Del { function sync(pattern: string, options?: Options): string[]; function sync(patterns: string[], options?: Options): string[]; interface Options extends glob.IOptions { force?: boolean; dryRun?: boolean; } } export = Del; }WebDevelopment-assignment-2/typings/browser/ambient/glob/000077500000000000000000000000001266350324300240315ustar00rootroot00000000000000WebDevelopment-assignment-2/typings/browser/ambient/glob/glob.d.ts000066400000000000000000000056131266350324300255530ustar00rootroot00000000000000// Compiled using typings@0.6.8 // Source: https://raw.githubusercontent.com/DefinitelyTyped/DefinitelyTyped/a14d724826174d1669d4df04c80f4838b7e71fdf/glob/glob.d.ts // Type definitions for Glob 5.0.10 // Project: https://github.com/isaacs/node-glob // Definitions by: vvakame // Definitions: https://github.com/borisyankov/DefinitelyTyped declare module "glob" { import events = require("events"); import fs = require('fs'); import minimatch = require("minimatch"); function G(pattern: string, cb: (err: Error, matches: string[]) => void): void; function G(pattern: string, options: G.IOptions, cb: (err: Error, matches: string[]) => void): void; module G { function sync(pattern: string, options?: IOptions): string[]; function hasMagic(pattern: string, options?: IOptions): boolean; var Glob: IGlobStatic; var GlobSync: IGlobSyncStatic; interface IOptions extends minimatch.IOptions { cwd?: string; root?: string; dot?: boolean; nomount?: boolean; mark?: boolean; nosort?: boolean; stat?: boolean; silent?: boolean; strict?: boolean; cache?: { [path: string]: any /* boolean | string | string[] */ }; statCache?: { [path: string]: fs.Stats }; symlinks?: any; sync?: boolean; nounique?: boolean; nonull?: boolean; debug?: boolean; nobrace?: boolean; noglobstar?: boolean; noext?: boolean; nocase?: boolean; matchBase?: any; nodir?: boolean; ignore?: any; /* string | string[] */ follow?: boolean; realpath?: boolean; nonegate?: boolean; nocomment?: boolean; /** Deprecated. */ globDebug?: boolean; } interface IGlobStatic extends events.EventEmitter { new (pattern: string, cb?: (err: Error, matches: string[]) => void): IGlob; new (pattern: string, options: IOptions, cb?: (err: Error, matches: string[]) => void): IGlob; prototype: IGlob; } interface IGlobSyncStatic { new (pattern: string, options?: IOptions): IGlobBase prototype: IGlobBase; } interface IGlobBase { minimatch: minimatch.IMinimatch; options: IOptions; aborted: boolean; cache: { [path: string]: any /* boolean | string | string[] */ }; statCache: { [path: string]: fs.Stats }; symlinks: { [path: string]: boolean }; realpathCache: { [path: string]: string }; found: string[]; } interface IGlob extends IGlobBase, events.EventEmitter { pause(): void; resume(): void; abort(): void; /** Deprecated. */ EOF: any; /** Deprecated. */ paused: boolean; /** Deprecated. */ maxDepth: number; /** Deprecated. */ maxLength: number; /** Deprecated. */ changedCwd: boolean; /** Deprecated. */ cwd: string; /** Deprecated. */ root: string; /** Deprecated. */ error: any; /** Deprecated. */ matches: string[]; /** Deprecated. */ log(...args: any[]): void; /** Deprecated. */ emitMatch(m: any): void; } } export = G; }WebDevelopment-assignment-2/typings/browser/ambient/gulp-sourcemaps/000077500000000000000000000000001266350324300262345ustar00rootroot00000000000000WebDevelopment-assignment-2/typings/browser/ambient/gulp-sourcemaps/gulp-sourcemaps.d.ts000066400000000000000000000017631266350324300321630ustar00rootroot00000000000000// Compiled using typings@0.6.8 // Source: https://raw.githubusercontent.com/DefinitelyTyped/DefinitelyTyped/5d6c3bdb5d936b257f22961890141a999e19daef/gulp-sourcemaps/gulp-sourcemaps.d.ts // Type definitions for gulp-sourcemaps // Project: https://github.com/floridoo/gulp-sourcemaps // Definitions by: Asana // Definitions: https://github.com/borisyankov/DefinitelyTyped declare module "gulp-sourcemaps" { interface InitOptions { loadMaps?: boolean; debug?: boolean; } interface WriteMapper { (file: string): string; } interface WriteOptions { addComment?: boolean; includeContent?: boolean; sourceRoot?: string | WriteMapper; sourceMappingURLPrefix?: string | WriteMapper; } export function init(opts?: InitOptions): NodeJS.ReadWriteStream; export function write(path?: string, opts?: WriteOptions): NodeJS.ReadWriteStream; export function write(opts?: WriteOptions): NodeJS.ReadWriteStream; }WebDevelopment-assignment-2/typings/browser/ambient/gulp-typescript/000077500000000000000000000000001266350324300262615ustar00rootroot00000000000000WebDevelopment-assignment-2/typings/browser/ambient/gulp-typescript/gulp-typescript.d.ts000066400000000000000000000051041266350324300322260ustar00rootroot00000000000000// Compiled using typings@0.6.8 // Source: https://raw.githubusercontent.com/DefinitelyTyped/DefinitelyTyped/960fd659b456e2fb5d23c52794ffdc56b09796cf/gulp-typescript/gulp-typescript.d.ts // Type definitions for gulp-typescript // Project: https://github.com/ivogabe/gulp-typescript // Definitions by: Asana , Thomas Corbière // Definitions: https://github.com/borisyankov/DefinitelyTyped declare module "gulp-typescript" { function GulpTypescript(params?: GulpTypescript.Params, filters?: GulpTypescript.FilterSettings, reporter?: GulpTypescript.Reporter): GulpTypescript.CompilationStream; module GulpTypescript { export function createProject(params?: Params): Project; export function createProject(file: string, params?: Params): Project; export function filter(filters: FilterSettings): CompilationStream; interface Params { declarationFiles?: boolean; module?: string; noEmitOnError?: boolean; noExternalResolve?: boolean; noImplicitAny?: boolean; noLib?: boolean; removeComments?: boolean; sourceRoot?: string; // use gulp-sourcemaps instead sortOutput?: boolean; target?: string; typescript?: any; outFile?: string; outDir?: string; suppressImplicitAnyIndexErrors?: boolean; jsx?: string; declaration?: boolean; emitDecoratorMetadata?: boolean; experimentalDecorators?: boolean; experimentalAsyncFunctions?: boolean; moduleResolution?: string; noEmitHelpers?: boolean; preserveConstEnums?: boolean; isolatedModules?: boolean; } interface TsConfig { files?: string[]; exclude?: string[]; compilerOptions?: any; } interface Project { config: TsConfig; src(): NodeJS.ReadWriteStream; } interface FilterSettings { referencedFrom?: string[]; } interface Reporter { error(error: any): void; } interface CompilationStream extends NodeJS.ReadWriteStream { dts: NodeJS.ReadWriteStream; js: NodeJS.ReadWriteStream; } module reporter { function nullReporter(): Reporter; function defaultReporter(): Reporter; function fullReporter(showFullFilename?: boolean): Reporter; } } export = GulpTypescript; }WebDevelopment-assignment-2/typings/browser/ambient/lodash/000077500000000000000000000000001266350324300243605ustar00rootroot00000000000000WebDevelopment-assignment-2/typings/browser/ambient/lodash/lodash.d.ts000066400000000000000000017236711266350324300264450ustar00rootroot00000000000000// Compiled using typings@0.6.8 // Source: https://raw.githubusercontent.com/DefinitelyTyped/DefinitelyTyped/c22a5e55b062c7b2af9df92ea0820c2afa153b2a/lodash/lodash.d.ts // Type definitions for Lo-Dash // Project: http://lodash.com/ // Definitions by: Brian Zengel , Ilya Mochalov // Definitions: https://github.com/borisyankov/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 ** 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 flush method to debounced & throttled functions - [ ] 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; (value: string): LoDashImplicitStringWrapper; (value: boolean): LoDashImplicitWrapper; (value: Array): LoDashImplicitNumberArrayWrapper; (value: Array): LoDashImplicitArrayWrapper; (value: T): LoDashImplicitObjectWrapper; (value: any): LoDashImplicitWrapper; /** * 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; /** * 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; } interface LoDashWrapperBase { } interface LoDashImplicitWrapperBase extends LoDashWrapperBase { } interface LoDashExplicitWrapperBase extends LoDashWrapperBase { } interface LoDashImplicitWrapper extends LoDashImplicitWrapperBase> { } interface LoDashExplicitWrapper extends LoDashExplicitWrapperBase> { } interface LoDashImplicitStringWrapper extends LoDashImplicitWrapper { } interface LoDashExplicitStringWrapper extends LoDashExplicitWrapper { } interface LoDashImplicitObjectWrapper extends LoDashImplicitWrapperBase> { } interface LoDashExplicitObjectWrapper extends LoDashExplicitWrapperBase> { } interface LoDashImplicitArrayWrapper extends LoDashImplicitWrapperBase> { pop(): T; push(...items: T[]): LoDashImplicitArrayWrapper; shift(): T; sort(compareFn?: (a: T, b: T) => number): LoDashImplicitArrayWrapper; splice(start: number): LoDashImplicitArrayWrapper; splice(start: number, deleteCount: number, ...items: any[]): LoDashImplicitArrayWrapper; unshift(...items: T[]): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper extends LoDashExplicitWrapperBase> { } interface LoDashImplicitNumberArrayWrapper extends LoDashImplicitArrayWrapper { } interface LoDashExplicitNumberArrayWrapper extends LoDashExplicitArrayWrapper { } /********* * 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( array: List, size?: number ): T[][]; } interface LoDashImplicitArrayWrapper { /** * @see _.chunk */ chunk(size?: number): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.chunk */ chunk(size?: number): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.chunk */ chunk(size?: number): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.chunk */ chunk(size?: number): LoDashExplicitArrayWrapper; } //_.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(array?: List): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.compact */ compact(): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.compact */ compact(): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.compact */ compact(): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.compact */ compact(): LoDashExplicitArrayWrapper; } //_.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(...values: (T[]|List)[]) : 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( array: T[]|List, ...values: Array> ): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.difference */ difference(...values: (T[]|List)[]): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.difference */ difference(...values: (TValue[]|List)[]): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.difference */ difference(...values: (T[]|List)[]): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.difference */ difference(...values: (TValue[]|List)[]): LoDashExplicitArrayWrapper; } //_.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( array: T[]|List, values?: T[]|List, iteratee?: ((value: T) => any)|string ): T[]; /** * @see _.differenceBy */ differenceBy( array: T[]|List, values?: T[]|List, iteratee?: W ): T[]; /** * @see _.differenceBy */ differenceBy( array: T[]|List, values1?: T[]|List, values2?: T[]|List, iteratee?: ((value: T) => any)|string ): T[]; /** * @see _.differenceBy */ differenceBy( array: T[]|List, values1?: T[]|List, values2?: T[]|List, iteratee?: W ): T[]; /** * @see _.differenceBy */ differenceBy( array: T[]|List, values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, iteratee?: ((value: T) => any)|string ): T[]; /** * @see _.differenceBy */ differenceBy( array: T[]|List, values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, iteratee?: W ): T[]; /** * @see _.differenceBy */ differenceBy( array: T[]|List, values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, iteratee?: W ): T[]; /** * @see _.differenceBy */ differenceBy( array: T[]|List, values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, iteratee?: ((value: T) => any)|string ): T[]; /** * @see _.differenceBy */ differenceBy( array: T[]|List, values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, values5?: T[]|List, iteratee?: ((value: T) => any)|string ): T[]; /** * @see _.differenceBy */ differenceBy( array: T[]|List, values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, values5?: T[]|List, iteratee?: W ): T[]; /** * @see _.differenceBy */ differenceBy( array: T[]|List, ...values: any[] ): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.differenceBy */ differenceBy( values?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values?: T[]|List, iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, values5?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, values5?: T[]|List, iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( ...values: any[] ): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.differenceBy */ differenceBy( values?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values?: T[]|List, iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, values5?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, values5?: T[]|List, iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( ...values: any[] ): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.differenceBy */ differenceBy( values?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values?: T[]|List, iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, values5?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, values5?: T[]|List, iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( ...values: any[] ): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.differenceBy */ differenceBy( values?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values?: T[]|List, iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, values5?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, values5?: T[]|List, iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( ...values: any[] ): LoDashExplicitArrayWrapper; } //_.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, ...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(array: T[]|List, n?: number): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.drop */ drop(n?: number): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.drop */ drop(n?: number): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.drop */ drop(n?: number): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.drop */ drop(n?: number): LoDashExplicitArrayWrapper; } //_.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( array: List, n?: number ): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.dropRight */ dropRight(n?: number): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.dropRight */ dropRight(n?: number): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.dropRight */ dropRight(n?: number): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.dropRight */ dropRight(n?: number): LoDashExplicitArrayWrapper; } //_.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( array: List, predicate?: ListIterator, thisArg?: any ): TValue[]; /** * @see _.dropRightWhile */ dropRightWhile( array: List, predicate?: string, thisArg?: any ): TValue[]; /** * @see _.dropRightWhile */ dropRightWhile( array: List, predicate?: TWhere ): TValue[]; } interface LoDashImplicitArrayWrapper { /** * @see _.dropRightWhile */ dropRightWhile( predicate?: ListIterator, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.dropRightWhile */ dropRightWhile( predicate?: string, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.dropRightWhile */ dropRightWhile( predicate?: TWhere ): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.dropRightWhile */ dropRightWhile( predicate?: ListIterator, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.dropRightWhile */ dropRightWhile( predicate?: string, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.dropRightWhile */ dropRightWhile( predicate?: TWhere ): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.dropRightWhile */ dropRightWhile( predicate?: ListIterator, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.dropRightWhile */ dropRightWhile( predicate?: string, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.dropRightWhile */ dropRightWhile( predicate?: TWhere ): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.dropRightWhile */ dropRightWhile( predicate?: ListIterator, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.dropRightWhile */ dropRightWhile( predicate?: string, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.dropRightWhile */ dropRightWhile( predicate?: TWhere ): LoDashExplicitArrayWrapper; } //_.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( array: List, predicate?: ListIterator, thisArg?: any ): TValue[]; /** * @see _.dropWhile */ dropWhile( array: List, predicate?: string, thisArg?: any ): TValue[]; /** * @see _.dropWhile */ dropWhile( array: List, predicate?: TWhere ): TValue[]; } interface LoDashImplicitArrayWrapper { /** * @see _.dropWhile */ dropWhile( predicate?: ListIterator, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.dropWhile */ dropWhile( predicate?: string, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.dropWhile */ dropWhile( predicate?: TWhere ): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.dropWhile */ dropWhile( predicate?: ListIterator, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.dropWhile */ dropWhile( predicate?: string, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.dropWhile */ dropWhile( predicate?: TWhere ): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.dropWhile */ dropWhile( predicate?: ListIterator, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.dropWhile */ dropWhile( predicate?: string, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.dropWhile */ dropWhile( predicate?: TWhere ): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.dropWhile */ dropWhile( predicate?: ListIterator, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.dropWhile */ dropWhile( predicate?: string, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.dropWhile */ dropWhile( predicate?: TWhere ): LoDashExplicitArrayWrapper; } //_.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( array: any[], value: T, start?: number, end?: number ): T[]; /** * @see _.fill */ fill( array: List, value: T, start?: number, end?: number ): List; } interface LoDashImplicitArrayWrapper { /** * @see _.fill */ fill( value: T, start?: number, end?: number ): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.fill */ fill( value: T, start?: number, end?: number ): LoDashImplicitObjectWrapper>; } interface LoDashExplicitArrayWrapper { /** * @see _.fill */ fill( value: T, start?: number, end?: number ): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.fill */ fill( value: T, start?: number, end?: number ): LoDashExplicitObjectWrapper>; } //_.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 thisArg The this binding of predicate. * @return Returns the index of the found element, else -1. */ findIndex( array: List, predicate?: ListIterator, thisArg?: any ): number; /** * @see _.findIndex */ findIndex( array: List, predicate?: string, thisArg?: any ): number; /** * @see _.findIndex */ findIndex( array: List, predicate?: W ): number; } interface LoDashImplicitArrayWrapper { /** * @see _.findIndex */ findIndex( predicate?: ListIterator, thisArg?: any ): number; /** * @see _.findIndex */ findIndex( predicate?: string, thisArg?: any ): number; /** * @see _.findIndex */ findIndex( predicate?: W ): number; } interface LoDashImplicitObjectWrapper { /** * @see _.findIndex */ findIndex( predicate?: ListIterator, thisArg?: any ): number; /** * @see _.findIndex */ findIndex( predicate?: string, thisArg?: any ): number; /** * @see _.findIndex */ findIndex( predicate?: W ): number; } interface LoDashExplicitArrayWrapper { /** * @see _.findIndex */ findIndex( predicate?: ListIterator, thisArg?: any ): LoDashExplicitWrapper; /** * @see _.findIndex */ findIndex( predicate?: string, thisArg?: any ): LoDashExplicitWrapper; /** * @see _.findIndex */ findIndex( predicate?: W ): LoDashExplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.findIndex */ findIndex( predicate?: ListIterator, thisArg?: any ): LoDashExplicitWrapper; /** * @see _.findIndex */ findIndex( predicate?: string, thisArg?: any ): LoDashExplicitWrapper; /** * @see _.findIndex */ findIndex( predicate?: W ): LoDashExplicitWrapper; } //_.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 thisArg The function invoked per iteration. * @return Returns the index of the found element, else -1. */ findLastIndex( array: List, predicate?: ListIterator, thisArg?: any ): number; /** * @see _.findLastIndex */ findLastIndex( array: List, predicate?: string, thisArg?: any ): number; /** * @see _.findLastIndex */ findLastIndex( array: List, predicate?: W ): number; } interface LoDashImplicitArrayWrapper { /** * @see _.findLastIndex */ findLastIndex( predicate?: ListIterator, thisArg?: any ): number; /** * @see _.findLastIndex */ findLastIndex( predicate?: string, thisArg?: any ): number; /** * @see _.findLastIndex */ findLastIndex( predicate?: W ): number; } interface LoDashImplicitObjectWrapper { /** * @see _.findLastIndex */ findLastIndex( predicate?: ListIterator, thisArg?: any ): number; /** * @see _.findLastIndex */ findLastIndex( predicate?: string, thisArg?: any ): number; /** * @see _.findLastIndex */ findLastIndex( predicate?: W ): number; } interface LoDashExplicitArrayWrapper { /** * @see _.findLastIndex */ findLastIndex( predicate?: ListIterator, thisArg?: any ): LoDashExplicitWrapper; /** * @see _.findLastIndex */ findLastIndex( predicate?: string, thisArg?: any ): LoDashExplicitWrapper; /** * @see _.findLastIndex */ findLastIndex( predicate?: W ): LoDashExplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.findLastIndex */ findLastIndex( predicate?: ListIterator, thisArg?: any ): LoDashExplicitWrapper; /** * @see _.findLastIndex */ findLastIndex( predicate?: string, thisArg?: any ): LoDashExplicitWrapper; /** * @see _.findLastIndex */ findLastIndex( predicate?: W ): LoDashExplicitWrapper; } //_.first interface LoDashStatic { /** * @see _.head */ first(array: List): T; } interface LoDashImplicitArrayWrapper { /** * @see _.head */ first(): T; } interface LoDashImplicitObjectWrapper { /** * @see _.head */ first(): TResult; } interface RecursiveArray extends Array> {} interface ListOfRecursiveArraysOrValues extends List> {} //_.flatMap DUMMY interface LoDashStatic { /** * Creates an array of flattened values by running each element in `array` * through `iteratee` and concating its result to the other mapped values. * The iteratee is invoked with three arguments: (value, index|key, array). * * @static * @memberOf _ * @category Array * @param {Array} array The array to iterate over. * @param {Function|Object|string} [iteratee=_.identity] The function invoked per iteration. * @returns {Array} Returns the new array. * @example * * function duplicate(n) { * return [n, n]; * } * * _.flatMap([1, 2], duplicate); * // => [1, 1, 2, 2] */ flatMap( array: any[]|List, ...values: any[] ): any[]; } //_.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(array: ListOfRecursiveArraysOrValues, isDeep: boolean): T[]; /** * @see _.flatten */ flatten(array: List): T[]; /** * @see _.flatten */ flatten(array: ListOfRecursiveArraysOrValues): RecursiveArray; } interface LoDashImplicitWrapper { /** * @see _.flatten */ flatten(): LoDashImplicitArrayWrapper; } interface LoDashImplicitArrayWrapper { /** * @see _.flatten */ flatten(isDeep?: boolean): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.flatten */ flatten(isDeep?: boolean): LoDashImplicitArrayWrapper; } interface LoDashExplicitWrapper { /** * @see _.flatten */ flatten(): LoDashExplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.flatten */ flatten(isDeep?: boolean): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.flatten */ flatten(isDeep?: boolean): LoDashExplicitArrayWrapper; } //_.flattenDeep interface LoDashStatic { /** * Recursively flattens a nested array. * * @param array The array to recursively flatten. * @return Returns the new flattened array. */ flattenDeep(array: ListOfRecursiveArraysOrValues): T[]; } interface LoDashImplicitWrapper { /** * @see _.flattenDeep */ flattenDeep(): LoDashImplicitArrayWrapper; } interface LoDashImplicitArrayWrapper { /** * @see _.flattenDeep */ flattenDeep(): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.flattenDeep */ flattenDeep(): LoDashImplicitArrayWrapper; } interface LoDashExplicitWrapper { /** * @see _.flattenDeep */ flattenDeep(): LoDashExplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.flattenDeep */ flattenDeep(): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.flattenDeep */ flattenDeep(): LoDashExplicitArrayWrapper; } //_.fromPairs DUMMY 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( array: any[]|List ): 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(array: List): T; } interface LoDashImplicitArrayWrapper { /** * @see _.first */ head(): T; } interface LoDashImplicitObjectWrapper { /** * @see _.first */ head(): TResult; } //_.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( array: List, value: T, fromIndex?: boolean|number ): number; } interface LoDashImplicitArrayWrapper { /** * @see _.indexOf */ indexOf( value: T, fromIndex?: boolean|number ): number; } interface LoDashImplicitObjectWrapper { /** * @see _.indexOf */ indexOf( value: TValue, fromIndex?: boolean|number ): number; } interface LoDashExplicitArrayWrapper { /** * @see _.indexOf */ indexOf( value: T, fromIndex?: boolean|number ): LoDashExplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.indexOf */ indexOf( value: TValue, fromIndex?: boolean|number ): LoDashExplicitWrapper; } //_.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, ...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, ...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, separator?: string ): string; } interface LoDashImplicitWrapper { /** * @see _.join */ join(separator?: string): string; } interface LoDashImplicitArrayWrapper { /** * @see _.join */ join(separator?: string): string; } interface LoDashImplicitObjectWrapper { /** * @see _.join */ join(separator?: string): string; } interface LoDashExplicitWrapper { /** * @see _.join */ join(separator?: string): LoDashExplicitWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.join */ join(separator?: string): LoDashExplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.join */ join(separator?: string): LoDashExplicitWrapper; } //_.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, ...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, ...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, ...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( array: List, value: T ): number; } interface LoDashImplicitArrayWrapper { /** * @see _.sortedIndexOf */ sortedIndexOf( value: T ): number; } interface LoDashImplicitObjectWrapper { /** * @see _.sortedIndexOf */ sortedIndexOf( value: TValue ): number; } interface LoDashExplicitArrayWrapper { /** * @see _.sortedIndexOf */ sortedIndexOf( value: T ): LoDashExplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.sortedIndexOf */ sortedIndexOf( value: TValue ): LoDashExplicitWrapper; } //_.initial interface LoDashStatic { /** * Gets all but the last element of array. * * @param array The array to query. * @return Returns the slice of array. */ initial(array: List): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.initial */ initial(): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.initial */ initial(): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.initial */ initial(): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.initial */ initial(): LoDashExplicitArrayWrapper; } //_.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(...arrays: (T[]|List)[]): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.intersection */ intersection(...arrays: (TResult[]|List)[]): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.intersection */ intersection(...arrays: (TResult[]|List)[]): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.intersection */ intersection(...arrays: (TResult[]|List)[]): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.intersection */ intersection(...arrays: (TResult[]|List)[]): LoDashExplicitArrayWrapper; } //_.last interface LoDashStatic { /** * Gets the last element of array. * * @param array The array to query. * @return Returns the last element of array. */ last(array: List): T; } interface LoDashImplicitArrayWrapper { /** * @see _.last */ last(): T; } interface LoDashImplicitObjectWrapper { /** * @see _.last */ last(): T; } interface LoDashExplicitArrayWrapper { /** * @see _.last */ last(): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.last */ last(): LoDashExplicitObjectWrapper; } //_.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( array: List, value: T, fromIndex?: boolean|number ): number; } interface LoDashImplicitArrayWrapper { /** * @see _.lastIndexOf */ lastIndexOf( value: T, fromIndex?: boolean|number ): number; } interface LoDashImplicitObjectWrapper { /** * @see _.lastIndexOf */ lastIndexOf( value: TResult, fromIndex?: boolean|number ): number; } interface LoDashExplicitArrayWrapper { /** * @see _.lastIndexOf */ lastIndexOf( value: T, fromIndex?: boolean|number ): LoDashExplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.lastIndexOf */ lastIndexOf( value: TResult, fromIndex?: boolean|number ): LoDashExplicitWrapper; } //_.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( array: T[], ...values: T[] ): T[]; /** * @see _.pull */ pull( array: List, ...values: T[] ): List; } interface LoDashImplicitArrayWrapper { /** * @see _.pull */ pull(...values: T[]): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.pull */ pull(...values: TValue[]): LoDashImplicitObjectWrapper>; } interface LoDashExplicitArrayWrapper { /** * @see _.pull */ pull(...values: T[]): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.pull */ pull(...values: TValue[]): LoDashExplicitObjectWrapper>; } //_.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( array: List, ...indexes: (number|number[])[] ): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.pullAt */ pullAt(...indexes: (number|number[])[]): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.pullAt */ pullAt(...indexes: (number|number[])[]): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.pullAt */ pullAt(...indexes: (number|number[])[]): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.pullAt */ pullAt(...indexes: (number|number[])[]): LoDashExplicitArrayWrapper; } //_.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( array: List, predicate?: ListIterator, thisArg?: any ): T[]; /** * @see _.remove */ remove( array: List, predicate?: string, thisArg?: any ): T[]; /** * @see _.remove */ remove( array: List, predicate?: W ): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.remove */ remove( predicate?: ListIterator, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.remove */ remove( predicate?: string, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.remove */ remove( predicate?: W ): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.remove */ remove( predicate?: ListIterator, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.remove */ remove( predicate?: string, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.remove */ remove( predicate?: W ): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.remove */ remove( predicate?: ListIterator, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.remove */ remove( predicate?: string, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.remove */ remove( predicate?: W ): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.remove */ remove( predicate?: ListIterator, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.remove */ remove( predicate?: string, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.remove */ remove( predicate?: W ): LoDashExplicitArrayWrapper; } //_.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(array: List): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.tail */ tail(): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.tail */ tail(): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.tail */ tail(): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.tail */ tail(): LoDashExplicitArrayWrapper; } //_.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( array: T[], start?: number, end?: number ): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.slice */ slice( start?: number, end?: number ): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.slice */ slice( start?: number, end?: number ): LoDashExplicitArrayWrapper; } //_.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( array: List, value: T ): number; /** * @see _.sortedIndex */ sortedIndex( array: List, value: T ): number; /** * @see _.sortedIndex */ sortedIndex( array: List, value: T ): number; /** * @see _.sortedIndex */ sortedIndex( array: List, value: T ): number; /** * @see _.sortedIndex */ sortedIndex( array: List, value: T ): number; } interface LoDashImplicitWrapper { /** * @see _.sortedIndex */ sortedIndex( value: string ): number; } interface LoDashImplicitArrayWrapper { /** * @see _.sortedIndex */ sortedIndex( value: T ): number; /** * @see _.sortedIndex */ sortedIndex( value: T ): number; } interface LoDashImplicitObjectWrapper { /** * @see _.sortedIndex */ sortedIndex( value: T ): number; /** * @see _.sortedIndex */ sortedIndex( value: T ): number; /** * @see _.sortedIndex */ sortedIndex( value: T ): number; } interface LoDashExplicitWrapper { /** * @see _.sortedIndex */ sortedIndex( value: string ): LoDashExplicitWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.sortedIndex */ sortedIndex( value: T ): LoDashExplicitWrapper; /** * @see _.sortedIndex */ sortedIndex( value: T ): LoDashExplicitWrapper; /** * @see _.sortedIndex */ sortedIndex( value: T ): LoDashExplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.sortedIndex */ sortedIndex( value: T ): LoDashExplicitWrapper; /** * @see _.sortedIndex */ sortedIndex( value: T ): LoDashExplicitWrapper; /** * @see _.sortedIndex */ sortedIndex( value: T ): LoDashExplicitWrapper; } //_.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( array: List, value: T, iteratee: (x: T) => TSort ): number; /** * @see _.sortedIndexBy */ sortedIndexBy( array: List, value: T, iteratee: (x: T) => any ): number; /** * @see _.sortedIndexBy */ sortedIndexBy( array: List, value: T, iteratee: string ): number; /** * @see _.sortedIndexBy */ sortedIndexBy( array: List, value: T, iteratee: W ): number; /** * @see _.sortedIndexBy */ sortedIndexBy( array: List, value: T, iteratee: Object ): number; } interface LoDashImplicitWrapper { /** * @see _.sortedIndexBy */ sortedIndexBy( value: string, iteratee: (x: string) => TSort ): number; } interface LoDashImplicitArrayWrapper { /** * @see _.sortedIndexBy */ sortedIndexBy( value: T, iteratee: (x: T) => TSort ): number; /** * @see _.sortedIndexBy */ sortedIndexBy( value: T, iteratee: string ): number; /** * @see _.sortedIndexBy */ sortedIndexBy( value: T, iteratee: W ): number; } interface LoDashImplicitObjectWrapper { /** * @see _.sortedIndexBy */ sortedIndexBy( value: T, iteratee: (x: T) => TSort ): number; /** * @see _.sortedIndexBy */ sortedIndexBy( value: T, iteratee: (x: T) => any ): number; /** * @see _.sortedIndexBy */ sortedIndexBy( value: T, iteratee: string ): number; /** * @see _.sortedIndexBy */ sortedIndexBy( value: T, iteratee: W ): number; /** * @see _.sortedIndexBy */ sortedIndexBy( value: T, iteratee: Object ): number; } interface LoDashExplicitWrapper { /** * @see _.sortedIndexBy */ sortedIndexBy( value: string, iteratee: (x: string) => TSort ): LoDashExplicitWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.sortedIndexBy */ sortedIndexBy( value: T, iteratee: (x: T) => TSort ): LoDashExplicitWrapper; /** * @see _.sortedIndexBy */ sortedIndexBy( value: T, iteratee: string ): LoDashExplicitWrapper; /** * @see _.sortedIndexBy */ sortedIndexBy( value: T, iteratee: W ): LoDashExplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.sortedIndexBy */ sortedIndexBy( value: T, iteratee: (x: T) => TSort ): LoDashExplicitWrapper; /** * @see _.sortedIndexBy */ sortedIndexBy( value: T, iteratee: (x: T) => any ): LoDashExplicitWrapper; /** * @see _.sortedIndexBy */ sortedIndexBy( value: T, iteratee: string ): LoDashExplicitWrapper; /** * @see _.sortedIndexBy */ sortedIndexBy( value: T, iteratee: W ): LoDashExplicitWrapper; /** * @see _.sortedIndexBy */ sortedIndexBy( value: T, iteratee: Object ): LoDashExplicitWrapper; } //_.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( array: List, value: T ): number; /** * @see _.sortedLastIndex */ sortedLastIndex( array: List, value: T ): number; /** * @see _.sortedLastIndex */ sortedLastIndex( array: List, value: T ): number; /** * @see _.sortedLastIndex */ sortedLastIndex( array: List, value: T ): number; /** * @see _.sortedLastIndex */ sortedLastIndex( array: List, value: T ): number; } interface LoDashImplicitWrapper { /** * @see _.sortedLastIndex */ sortedLastIndex( value: string ): number; } interface LoDashImplicitArrayWrapper { /** * @see _.sortedLastIndex */ sortedLastIndex( value: T ): number; /** * @see _.sortedLastIndex */ sortedLastIndex( value: T ): number; /** * @see _.sortedLastIndex */ sortedLastIndex( value: T ): number; } interface LoDashImplicitObjectWrapper { /** * @see _.sortedLastIndex */ sortedLastIndex( value: T ): number; /** * @see _.sortedLastIndex */ sortedLastIndex( value: T ): number; /** * @see _.sortedLastIndex */ sortedLastIndex( value: T ): number; } interface LoDashExplicitWrapper { /** * @see _.sortedLastIndex */ sortedLastIndex( value: string ): LoDashExplicitWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.sortedLastIndex */ sortedLastIndex( value: T ): LoDashExplicitWrapper; /** * @see _.sortedLastIndex */ sortedLastIndex( value: T ): LoDashExplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.sortedLastIndex */ sortedLastIndex( value: T ): LoDashExplicitWrapper; /** * @see _.sortedLastIndex */ sortedLastIndex( value: T ): LoDashExplicitWrapper; /** * @see _.sortedLastIndex */ sortedLastIndex( value: T ): LoDashExplicitWrapper; } //_.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( array: List, value: T, iteratee: (x: T) => TSort ): number; /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( array: List, value: T, iteratee: (x: T) => any ): number; /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( array: List, value: T, iteratee: string ): number; /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( array: List, value: T, iteratee: W ): number; /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( array: List, value: T, iteratee: Object ): number; } interface LoDashImplicitWrapper { /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( value: string, iteratee: (x: string) => TSort ): number; } interface LoDashImplicitArrayWrapper { /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( value: T, iteratee: (x: T) => TSort ): number; /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( value: T, iteratee: string ): number; /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( value: T, iteratee: W ): number; } interface LoDashImplicitObjectWrapper { /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( value: T, iteratee: (x: T) => TSort ): number; /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( value: T, iteratee: (x: T) => any ): number; /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( value: T, iteratee: string ): number; /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( value: T, iteratee: W ): number; /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( value: T, iteratee: Object ): number; } interface LoDashExplicitWrapper { /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( value: string, iteratee: (x: string) => TSort ): LoDashExplicitWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( value: T, iteratee: (x: T) => TSort ): LoDashExplicitWrapper; /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( value: T, iteratee: string ): LoDashExplicitWrapper; /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( value: T, iteratee: W ): LoDashExplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( value: T, iteratee: (x: T) => TSort ): LoDashExplicitWrapper; /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( value: T, iteratee: (x: T) => any ): LoDashExplicitWrapper; /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( value: T, iteratee: string ): LoDashExplicitWrapper; /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( value: T, iteratee: W ): LoDashExplicitWrapper; /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( value: T, iteratee: Object ): LoDashExplicitWrapper; } //_.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, ...values: any[] ): any[]; } //_.tail interface LoDashStatic { /** * @see _.rest */ tail(array: List): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.rest */ tail(): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.rest */ tail(): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.rest */ tail(): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.rest */ tail(): LoDashExplicitArrayWrapper; } //_.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( array: List, n?: number ): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.take */ take(n?: number): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.take */ take(n?: number): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.take */ take(n?: number): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.take */ take(n?: number): LoDashExplicitArrayWrapper; } //_.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( array: List, n?: number ): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.takeRight */ takeRight(n?: number): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.takeRight */ takeRight(n?: number): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.takeRight */ takeRight(n?: number): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.takeRight */ takeRight(n?: number): LoDashExplicitArrayWrapper; } //_.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( array: List, predicate?: ListIterator, thisArg?: any ): TValue[]; /** * @see _.takeRightWhile */ takeRightWhile( array: List, predicate?: string, thisArg?: any ): TValue[]; /** * @see _.takeRightWhile */ takeRightWhile( array: List, predicate?: TWhere ): TValue[]; } interface LoDashImplicitArrayWrapper { /** * @see _.takeRightWhile */ takeRightWhile( predicate?: ListIterator, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.takeRightWhile */ takeRightWhile( predicate?: string, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.takeRightWhile */ takeRightWhile( predicate?: TWhere ): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.takeRightWhile */ takeRightWhile( predicate?: ListIterator, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.takeRightWhile */ takeRightWhile( predicate?: string, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.takeRightWhile */ takeRightWhile( predicate?: TWhere ): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.takeRightWhile */ takeRightWhile( predicate?: ListIterator, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.takeRightWhile */ takeRightWhile( predicate?: string, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.takeRightWhile */ takeRightWhile( predicate?: TWhere ): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.takeRightWhile */ takeRightWhile( predicate?: ListIterator, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.takeRightWhile */ takeRightWhile( predicate?: string, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.takeRightWhile */ takeRightWhile( predicate?: TWhere ): LoDashExplicitArrayWrapper; } //_.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( array: List, predicate?: ListIterator, thisArg?: any ): TValue[]; /** * @see _.takeWhile */ takeWhile( array: List, predicate?: string, thisArg?: any ): TValue[]; /** * @see _.takeWhile */ takeWhile( array: List, predicate?: TWhere ): TValue[]; } interface LoDashImplicitArrayWrapper { /** * @see _.takeWhile */ takeWhile( predicate?: ListIterator, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.takeWhile */ takeWhile( predicate?: string, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.takeWhile */ takeWhile( predicate?: TWhere ): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.takeWhile */ takeWhile( predicate?: ListIterator, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.takeWhile */ takeWhile( predicate?: string, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.takeWhile */ takeWhile( predicate?: TWhere ): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.takeWhile */ takeWhile( predicate?: ListIterator, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.takeWhile */ takeWhile( predicate?: string, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.takeWhile */ takeWhile( predicate?: TWhere ): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.takeWhile */ takeWhile( predicate?: ListIterator, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.takeWhile */ takeWhile( predicate?: string, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.takeWhile */ takeWhile( predicate?: TWhere ): LoDashExplicitArrayWrapper; } //_.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(...arrays: List[]): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.union */ union(...arrays: List[]): LoDashImplicitArrayWrapper; /** * @see _.union */ union(...arrays: List[]): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.union */ union(...arrays: List[]): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.union */ union(...arrays: List[]): LoDashExplicitArrayWrapper; /** * @see _.union */ union(...arrays: List[]): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.union */ union(...arrays: List[]): LoDashExplicitArrayWrapper; } //_.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( arrays: T[]|List, iteratee?: (value: T) => any ): T[]; /** * @see _.unionBy */ unionBy( arrays: T[]|List, iteratee?: W ): T[]; /** * @see _.unionBy */ unionBy( arrays1: T[]|List, arrays2: T[]|List, iteratee?: (value: T) => any ): T[]; /** * @see _.unionBy */ unionBy( arrays1: T[]|List, arrays2: T[]|List, iteratee?: W ): T[]; /** * @see _.unionBy */ unionBy( arrays1: T[]|List, arrays2: T[]|List, arrays3: T[]|List, iteratee?: (value: T) => any ): T[]; /** * @see _.unionBy */ unionBy( arrays1: T[]|List, arrays2: T[]|List, arrays3: T[]|List, iteratee?: W ): T[]; /** * @see _.unionBy */ unionBy( arrays1: T[]|List, arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, iteratee?: (value: T) => any ): T[]; /** * @see _.unionBy */ unionBy( arrays1: T[]|List, arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, iteratee?: W ): T[]; /** * @see _.unionBy */ unionBy( arrays1: T[]|List, arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, arrays5: T[]|List, iteratee?: (value: T) => any ): T[]; /** * @see _.unionBy */ unionBy( arrays1: T[]|List, arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, arrays5: T[]|List, iteratee?: W ): T[]; /** * @see _.unionBy */ unionBy( arrays: T[]|List, ...iteratee: any[] ): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.unionBy */ unionBy( iteratee?: (value: T) => any ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, iteratee?: (value: T) => any ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, iteratee?: (value: T) => any ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, iteratee?: (value: T) => any ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, arrays5: T[]|List, iteratee?: (value: T) => any ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, arrays5: T[]|List, iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( ...iteratee: any[] ): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.unionBy */ unionBy( iteratee?: (value: T) => any ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, iteratee?: (value: T) => any ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, iteratee?: (value: T) => any ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, iteratee?: (value: T) => any ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, arrays5: T[]|List, iteratee?: (value: T) => any ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, arrays5: T[]|List, iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( ...iteratee: any[] ): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.unionBy */ unionBy( iteratee?: (value: T) => any ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, iteratee?: (value: T) => any ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, iteratee?: (value: T) => any ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, iteratee?: (value: T) => any ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, arrays5: T[]|List, iteratee?: (value: T) => any ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, arrays5: T[]|List, iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( ...iteratee: any[] ): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.unionBy */ unionBy( iteratee?: (value: T) => any ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, iteratee?: (value: T) => any ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, iteratee?: (value: T) => any ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, iteratee?: (value: T) => any ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, arrays5: T[]|List, iteratee?: (value: T) => any ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, arrays5: T[]|List, iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( ...iteratee: any[] ): LoDashExplicitArrayWrapper; } //_.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( array: List ): T[]; /** * @see _.uniq */ uniq( array: List ): T[]; } interface LoDashImplicitWrapper { /** * @see _.uniq */ uniq(): LoDashImplicitArrayWrapper; } interface LoDashImplicitArrayWrapper { /** * @see _.uniq */ uniq(): LoDashImplicitArrayWrapper; /** * @see _.uniq */ uniq(): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { uniq(): LoDashImplicitArrayWrapper; /** * @see _.uniq */ uniq(): LoDashImplicitArrayWrapper; } interface LoDashExplicitWrapper { /** * @see _.uniq */ uniq(): LoDashExplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.uniq */ uniq(): LoDashExplicitArrayWrapper; /** * @see _.uniq */ uniq(): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.uniq */ uniq(): LoDashExplicitArrayWrapper; /** * @see _.uniq */ uniq(): LoDashExplicitArrayWrapper; } //_.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( array: List, iteratee: ListIterator ): T[]; /** * @see _.uniqBy */ uniqBy( array: List, iteratee: ListIterator ): T[]; /** * @see _.uniqBy */ uniqBy( array: List, iteratee: string ): T[]; /** * @see _.uniqBy */ uniqBy( array: List, iteratee: Object ): T[]; /** * @see _.uniqBy */ uniqBy( array: List, iteratee: TWhere ): T[]; } interface LoDashImplicitWrapper { /** * @see _.uniqBy */ uniqBy( iteratee: ListIterator ): LoDashImplicitArrayWrapper; } interface LoDashImplicitArrayWrapper { /** * @see _.uniqBy */ uniqBy( iteratee: ListIterator ): LoDashImplicitArrayWrapper; /** * @see _.uniqBy */ uniqBy( iteratee: string ): LoDashImplicitArrayWrapper; /** * @see _.uniqBy */ uniqBy( iteratee: TWhere ): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.uniqBy */ uniqBy( iteratee: ListIterator ): LoDashImplicitArrayWrapper; /** * @see _.uniqBy */ uniqBy( iteratee: ListIterator ): LoDashImplicitArrayWrapper; /** * @see _.uniqBy */ uniqBy( iteratee: string ): LoDashImplicitArrayWrapper; /** * @see _.uniqBy */ uniqBy( iteratee: Object ): LoDashImplicitArrayWrapper; /** * @see _.uniqBy */ uniqBy( iteratee: TWhere ): LoDashImplicitArrayWrapper; } interface LoDashExplicitWrapper { /** * @see _.uniqBy */ uniqBy( iteratee: ListIterator ): LoDashExplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.uniqBy */ uniqBy( iteratee: ListIterator ): LoDashExplicitArrayWrapper; /** * @see _.uniqBy */ uniqBy( iteratee: string ): LoDashExplicitArrayWrapper; /** * @see _.uniqBy */ uniqBy( iteratee: TWhere ): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.uniqBy */ uniqBy( iteratee: ListIterator ): LoDashExplicitArrayWrapper; /** * @see _.uniqBy */ uniqBy( iteratee: ListIterator ): LoDashExplicitArrayWrapper; /** * @see _.uniqBy */ uniqBy( iteratee: string ): LoDashExplicitArrayWrapper; /** * @see _.uniqBy */ uniqBy( iteratee: Object ): LoDashExplicitArrayWrapper; /** * @see _.uniqBy */ uniqBy( iteratee: TWhere ): LoDashExplicitArrayWrapper; } //_.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( array: List ): T[]; /** * @see _.sortedUniq */ sortedUniq( array: List ): T[]; } interface LoDashImplicitWrapper { /** * @see _.sortedUniq */ sortedUniq(): LoDashImplicitArrayWrapper; } interface LoDashImplicitArrayWrapper { /** * @see _.sortedUniq */ sortedUniq(): LoDashImplicitArrayWrapper; /** * @see _.sortedUniq */ sortedUniq(): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { sortedUniq(): LoDashImplicitArrayWrapper; /** * @see _.sortedUniq */ sortedUniq(): LoDashImplicitArrayWrapper; } interface LoDashExplicitWrapper { /** * @see _.sortedUniq */ sortedUniq(): LoDashExplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.sortedUniq */ sortedUniq(): LoDashExplicitArrayWrapper; /** * @see _.sortedUniq */ sortedUniq(): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.sortedUniq */ sortedUniq(): LoDashExplicitArrayWrapper; /** * @see _.sortedUniq */ sortedUniq(): LoDashExplicitArrayWrapper; } //_.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( array: List, iteratee: ListIterator ): T[]; /** * @see _.sortedUniqBy */ sortedUniqBy( array: List, iteratee: ListIterator ): T[]; /** * @see _.sortedUniqBy */ sortedUniqBy( array: List, iteratee: string ): T[]; /** * @see _.sortedUniqBy */ sortedUniqBy( array: List, iteratee: Object ): T[]; /** * @see _.sortedUniqBy */ sortedUniqBy( array: List, iteratee: TWhere ): T[]; } interface LoDashImplicitWrapper { /** * @see _.sortedUniqBy */ sortedUniqBy( iteratee: ListIterator ): LoDashImplicitArrayWrapper; } interface LoDashImplicitArrayWrapper { /** * @see _.sortedUniqBy */ sortedUniqBy( iteratee: ListIterator ): LoDashImplicitArrayWrapper; /** * @see _.sortedUniqBy */ sortedUniqBy( iteratee: string ): LoDashImplicitArrayWrapper; /** * @see _.sortedUniqBy */ sortedUniqBy( iteratee: TWhere ): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.sortedUniqBy */ sortedUniqBy( iteratee: ListIterator ): LoDashImplicitArrayWrapper; /** * @see _.sortedUniqBy */ sortedUniqBy( iteratee: ListIterator ): LoDashImplicitArrayWrapper; /** * @see _.sortedUniqBy */ sortedUniqBy( iteratee: string ): LoDashImplicitArrayWrapper; /** * @see _.sortedUniqBy */ sortedUniqBy( iteratee: Object ): LoDashImplicitArrayWrapper; /** * @see _.sortedUniqBy */ sortedUniqBy( iteratee: TWhere ): LoDashImplicitArrayWrapper; } interface LoDashExplicitWrapper { /** * @see _.sortedUniqBy */ sortedUniqBy( iteratee: ListIterator ): LoDashExplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.sortedUniqBy */ sortedUniqBy( iteratee: ListIterator ): LoDashExplicitArrayWrapper; /** * @see _.sortedUniqBy */ sortedUniqBy( iteratee: string ): LoDashExplicitArrayWrapper; /** * @see _.sortedUniqBy */ sortedUniqBy( iteratee: TWhere ): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.sortedUniqBy */ sortedUniqBy( iteratee: ListIterator ): LoDashExplicitArrayWrapper; /** * @see _.sortedUniqBy */ sortedUniqBy( iteratee: ListIterator ): LoDashExplicitArrayWrapper; /** * @see _.sortedUniqBy */ sortedUniqBy( iteratee: string ): LoDashExplicitArrayWrapper; /** * @see _.sortedUniqBy */ sortedUniqBy( iteratee: Object ): LoDashExplicitArrayWrapper; /** * @see _.sortedUniqBy */ sortedUniqBy( iteratee: TWhere ): LoDashExplicitArrayWrapper; } //_.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, ...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, ...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(array: List>): T[][]; } interface LoDashImplicitArrayWrapper { /** * @see _.unzip */ unzip(): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.unzip */ unzip(): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.unzip */ unzip(): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.unzip */ unzip(): LoDashExplicitArrayWrapper; } //_.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( array: List>, iteratee?: MemoIterator, thisArg?: any ): TResult[]; } interface LoDashImplicitArrayWrapper { /** * @see _.unzipWith */ unzipWith( iteratee?: MemoIterator, thisArg?: any ): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.unzipWith */ unzipWith( iteratee?: MemoIterator, thisArg?: any ): LoDashImplicitArrayWrapper; } //_.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( array: List, ...values: T[] ): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.without */ without(...values: T[]): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.without */ without(...values: T[]): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.without */ without(...values: T[]): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.without */ without(...values: T[]): LoDashExplicitArrayWrapper; } //_.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(...arrays: List[]): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.xor */ xor(...arrays: List[]): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.xor */ xor(...arrays: List[]): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.xor */ xor(...arrays: List[]): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.xor */ xor(...arrays: List[]): LoDashExplicitArrayWrapper; } //_.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, ...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, ...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(...arrays: List[]): T[][]; } interface LoDashImplicitArrayWrapper { /** * @see _.zip */ zip(...arrays: List[]): _.LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.zip */ zip(...arrays: List[]): _.LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.zip */ zip(...arrays: List[]): _.LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.zip */ zip(...arrays: List[]): _.LoDashExplicitArrayWrapper; } //_.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( props: List|List>, values?: List ): TResult; /** * @see _.zipObject */ zipObject( props: List|List>, values?: List ): TResult; /** * @see _.zipObject */ zipObject( props: List|List>, values?: List ): _.Dictionary; } interface LoDashImplicitArrayWrapper { /** * @see _.zipObject */ zipObject( values?: List ): _.LoDashImplicitObjectWrapper; /** * @see _.zipObject */ zipObject( values?: List ): _.LoDashImplicitObjectWrapper; /** * @see _.zipObject */ zipObject( values?: List ): _.LoDashImplicitObjectWrapper<_.Dictionary>; } interface LoDashImplicitObjectWrapper { /** * @see _.zipObject */ zipObject( values?: List ): _.LoDashImplicitObjectWrapper; /** * @see _.zipObject */ zipObject( values?: List ): _.LoDashImplicitObjectWrapper; /** * @see _.zipObject */ zipObject( values?: List ): _.LoDashImplicitObjectWrapper<_.Dictionary>; } interface LoDashExplicitArrayWrapper { /** * @see _.zipObject */ zipObject( values?: List ): _.LoDashExplicitObjectWrapper; /** * @see _.zipObject */ zipObject( values?: List ): _.LoDashExplicitObjectWrapper; /** * @see _.zipObject */ zipObject( values?: List ): _.LoDashExplicitObjectWrapper<_.Dictionary>; } interface LoDashExplicitObjectWrapper { /** * @see _.zipObject */ zipObject( values?: List ): _.LoDashExplicitObjectWrapper; /** * @see _.zipObject */ zipObject( values?: List ): _.LoDashExplicitObjectWrapper; /** * @see _.zipObject */ zipObject( values?: List ): _.LoDashExplicitObjectWrapper<_.Dictionary>; } //_.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(...args: any[]): TResult[]; } interface LoDashImplicitArrayWrapper { /** * @see _.zipWith */ zipWith(...args: any[]): LoDashImplicitArrayWrapper; } /********* * 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; chain(value: string): LoDashExplicitWrapper; chain(value: boolean): LoDashExplicitWrapper; chain(value: T[]): LoDashExplicitArrayWrapper; chain(value: T): LoDashExplicitObjectWrapper; chain(value: any): LoDashExplicitWrapper; } interface LoDashImplicitWrapper { /** * @see _.chain */ chain(): LoDashExplicitWrapper; } interface LoDashImplicitArrayWrapper { /** * @see _.chain */ chain(): LoDashExplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.chain */ chain(): LoDashExplicitObjectWrapper; } interface LoDashExplicitWrapperBase { /** * @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( value: T, interceptor: (value: T) => void, thisArg?: any ): T; } interface LoDashImplicitWrapperBase { /** * @see _.tap */ tap( interceptor: (value: T) => void, thisArg?: any ): TWrapper; } interface LoDashExplicitWrapperBase { /** * @see _.tap */ tap( interceptor: (value: T) => void, thisArg?: any ): 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( value: T, interceptor: (value: T) => TResult, thisArg?: any ): TResult; } interface LoDashImplicitWrapperBase { /** * @see _.thru */ thru( interceptor: (value: T) => TResult, thisArg?: any): LoDashImplicitWrapper; /** * @see _.thru */ thru( interceptor: (value: T) => TResult, thisArg?: any): LoDashImplicitWrapper; /** * @see _.thru */ thru( interceptor: (value: T) => TResult, thisArg?: any): LoDashImplicitWrapper; /** * @see _.thru */ thru( interceptor: (value: T) => TResult, thisArg?: any): LoDashImplicitObjectWrapper; /** * @see _.thru */ thru( interceptor: (value: T) => TResult[], thisArg?: any): LoDashImplicitArrayWrapper; } interface LoDashExplicitWrapperBase { /** * @see _.thru */ thru( interceptor: (value: T) => TResult, thisArg?: any ): LoDashExplicitWrapper; /** * @see _.thru */ thru( interceptor: (value: T) => TResult, thisArg?: any ): LoDashExplicitWrapper; /** * @see _.thru */ thru( interceptor: (value: T) => TResult, thisArg?: any ): LoDashExplicitWrapper; /** * @see _.thru */ thru( interceptor: (value: T) => TResult, thisArg?: any ): LoDashExplicitObjectWrapper; /** * @see _.thru */ thru( interceptor: (value: T) => TResult[], thisArg?: any ): LoDashExplicitArrayWrapper; } //_.prototype.commit interface LoDashImplicitWrapperBase { /** * Executes the chained sequence and returns the wrapped result. * * @return Returns the new lodash wrapper instance. */ commit(): TWrapper; } interface LoDashExplicitWrapperBase { /** * @see _.commit */ commit(): TWrapper; } //_.prototype.concat interface LoDashImplicitWrapperBase { /** * Creates a new array joining a wrapped array with any additional arrays and/or values. * * @param items * @return Returns the new concatenated array. */ concat(...items: Array>): LoDashImplicitArrayWrapper; /** * @see _.concat */ concat(...items: Array>): LoDashImplicitArrayWrapper; } interface LoDashExplicitWrapperBase { /** * @see _.concat */ concat(...items: Array>): LoDashExplicitArrayWrapper; /** * @see _.concat */ concat(...items: Array>): LoDashExplicitArrayWrapper; } //_.prototype.plant interface LoDashImplicitWrapperBase { /** * 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; /** * @see _.plant */ plant(value: string): LoDashImplicitStringWrapper; /** * @see _.plant */ plant(value: boolean): LoDashImplicitWrapper; /** * @see _.plant */ plant(value: number[]): LoDashImplicitNumberArrayWrapper; /** * @see _.plant */ plant(value: T[]): LoDashImplicitArrayWrapper; /** * @see _.plant */ plant(value: T): LoDashImplicitObjectWrapper; /** * @see _.plant */ plant(value: any): LoDashImplicitWrapper; } interface LoDashExplicitWrapperBase { /** * @see _.plant */ plant(value: number): LoDashExplicitWrapper; /** * @see _.plant */ plant(value: string): LoDashExplicitStringWrapper; /** * @see _.plant */ plant(value: boolean): LoDashExplicitWrapper; /** * @see _.plant */ plant(value: number[]): LoDashExplicitNumberArrayWrapper; /** * @see _.plant */ plant(value: T[]): LoDashExplicitArrayWrapper; /** * @see _.plant */ plant(value: T): LoDashExplicitObjectWrapper; /** * @see _.plant */ plant(value: any): LoDashExplicitWrapper; } //_.prototype.reverse interface LoDashImplicitArrayWrapper { /** * 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; } interface LoDashExplicitArrayWrapper { /** * @see _.reverse */ reverse(): LoDashExplicitArrayWrapper; } //_.prototype.toJSON interface LoDashWrapperBase { /** * @see _.value */ toJSON(): T; } //_.prototype.toString interface LoDashWrapperBase { /** * Produces the result of coercing the unwrapped value to a string. * * @return Returns the coerced string value. */ toString(): string; } //_.prototype.value interface LoDashWrapperBase { /** * Executes the chained sequence to extract the unwrapped value. * * @alias _.toJSON, _.valueOf * * @return Returns the resolved unwrapped value. */ value(): T; } //_.valueOf interface LoDashWrapperBase { /** * @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( collection: List|Dictionary, ...props: (number|string|(number|string)[])[] ): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.at */ at(...props: (number|string|(number|string)[])[]): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.at */ at(...props: (number|string|(number|string)[])[]): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.at */ at(...props: (number|string|(number|string)[])[]): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.at */ at(...props: (number|string|(number|string)[])[]): LoDashExplicitArrayWrapper; } //_.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( collection: List, iteratee?: ListIterator, thisArg?: any ): Dictionary; /** * @see _.countBy */ countBy( collection: Dictionary, iteratee?: DictionaryIterator, thisArg?: any ): Dictionary; /** * @see _.countBy */ countBy( collection: NumericDictionary, iteratee?: NumericDictionaryIterator, thisArg?: any ): Dictionary; /** * @see _.countBy */ countBy( collection: List|Dictionary|NumericDictionary, iteratee?: string, thisArg?: any ): Dictionary; /** * @see _.countBy */ countBy( collection: List|Dictionary|NumericDictionary, iteratee?: W ): Dictionary; /** * @see _.countBy */ countBy( collection: List|Dictionary|NumericDictionary, iteratee?: Object ): Dictionary; } interface LoDashImplicitWrapper { /** * @see _.countBy */ countBy( iteratee?: ListIterator, thisArg?: any ): LoDashImplicitObjectWrapper>; } interface LoDashImplicitArrayWrapper { /** * @see _.countBy */ countBy( iteratee?: ListIterator, thisArg?: any ): LoDashImplicitObjectWrapper>; /** * @see _.countBy */ countBy( iteratee?: string, thisArg?: any ): LoDashImplicitObjectWrapper>; /** * @see _.countBy */ countBy( iteratee?: W ): LoDashImplicitObjectWrapper>; } interface LoDashImplicitObjectWrapper { /** * @see _.countBy */ countBy( iteratee?: ListIterator|DictionaryIterator|NumericDictionaryIterator, thisArg?: any ): LoDashImplicitObjectWrapper>; /** * @see _.countBy */ countBy( iteratee?: string, thisArg?: any ): LoDashImplicitObjectWrapper>; /** * @see _.countBy */ countBy( iteratee?: W ): LoDashImplicitObjectWrapper>; } interface LoDashExplicitWrapper { /** * @see _.countBy */ countBy( iteratee?: ListIterator, thisArg?: any ): LoDashExplicitObjectWrapper>; } interface LoDashExplicitArrayWrapper { /** * @see _.countBy */ countBy( iteratee?: ListIterator, thisArg?: any ): LoDashExplicitObjectWrapper>; /** * @see _.countBy */ countBy( iteratee?: string, thisArg?: any ): LoDashExplicitObjectWrapper>; /** * @see _.countBy */ countBy( iteratee?: W ): LoDashExplicitObjectWrapper>; } interface LoDashExplicitObjectWrapper { /** * @see _.countBy */ countBy( iteratee?: ListIterator|DictionaryIterator|NumericDictionaryIterator, thisArg?: any ): LoDashExplicitObjectWrapper>; /** * @see _.countBy */ countBy( iteratee?: string, thisArg?: any ): LoDashExplicitObjectWrapper>; /** * @see _.countBy */ countBy( iteratee?: W ): LoDashExplicitObjectWrapper>; } //_.each interface LoDashStatic { /** * @see _.forEach */ each( collection: T[], iteratee?: ListIterator, thisArg?: any ): T[]; /** * @see _.forEach */ each( collection: List, iteratee?: ListIterator, thisArg?: any ): List; /** * @see _.forEach */ each( collection: Dictionary, iteratee?: DictionaryIterator, thisArg?: any ): Dictionary; /** * @see _.forEach */ each( collection: T, iteratee?: ObjectIterator, thisArgs?: any ): T; /** * @see _.forEach */ each( collection: T, iteratee?: ObjectIterator, thisArgs?: any ): T; } interface LoDashImplicitWrapper { /** * @see _.forEach */ each( iteratee: ListIterator, thisArg?: any ): LoDashImplicitWrapper; } interface LoDashImplicitArrayWrapper { /** * @see _.forEach */ each( iteratee: ListIterator, thisArg?: any ): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.forEach */ each( iteratee?: ListIterator|DictionaryIterator, thisArg?: any ): LoDashImplicitObjectWrapper; } interface LoDashExplicitWrapper { /** * @see _.forEach */ each( iteratee: ListIterator, thisArg?: any ): LoDashExplicitWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.forEach */ each( iteratee: ListIterator, thisArg?: any ): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.forEach */ each( iteratee?: ListIterator|DictionaryIterator, thisArg?: any ): LoDashExplicitObjectWrapper; } //_.eachRight interface LoDashStatic { /** * @see _.forEachRight */ eachRight( collection: T[], iteratee?: ListIterator, thisArg?: any ): T[]; /** * @see _.forEachRight */ eachRight( collection: List, iteratee?: ListIterator, thisArg?: any ): List; /** * @see _.forEachRight */ eachRight( collection: Dictionary, iteratee?: DictionaryIterator, thisArg?: any ): Dictionary; /** * @see _.forEachRight */ eachRight( collection: T, iteratee?: ObjectIterator, thisArgs?: any ): T; /** * @see _.forEachRight */ eachRight( collection: T, iteratee?: ObjectIterator, thisArgs?: any ): T; } interface LoDashImplicitWrapper { /** * @see _.forEachRight */ eachRight( iteratee: ListIterator, thisArg?: any ): LoDashImplicitWrapper; } interface LoDashImplicitArrayWrapper { /** * @see _.forEachRight */ eachRight( iteratee: ListIterator, thisArg?: any ): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.forEachRight */ eachRight( iteratee?: ListIterator|DictionaryIterator, thisArg?: any ): LoDashImplicitObjectWrapper; } interface LoDashExplicitWrapper { /** * @see _.forEachRight */ eachRight( iteratee: ListIterator, thisArg?: any ): LoDashExplicitWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.forEachRight */ eachRight( iteratee: ListIterator, thisArg?: any ): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.forEachRight */ eachRight( iteratee?: ListIterator|DictionaryIterator, thisArg?: any ): LoDashExplicitObjectWrapper; } //_.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( collection: List, predicate?: ListIterator ): boolean; /** * @see _.every */ every( collection: Dictionary, predicate?: DictionaryIterator ): boolean; /** * @see _.every */ every( collection: NumericDictionary, predicate?: NumericDictionaryIterator ): boolean; /** * @see _.every */ every( collection: List|Dictionary|NumericDictionary, predicate?: string|any[] ): boolean; /** * @see _.every */ every( collection: List|Dictionary|NumericDictionary, predicate?: TObject ): boolean; } interface LoDashImplicitArrayWrapper { /** * @see _.every */ every( predicate?: ListIterator|NumericDictionaryIterator ): boolean; /** * @see _.every */ every( predicate?: string|any[] ): boolean; /** * @see _.every */ every( predicate?: TObject ): boolean; } interface LoDashImplicitObjectWrapper { /** * @see _.every */ every( predicate?: ListIterator|DictionaryIterator|NumericDictionaryIterator ): boolean; /** * @see _.every */ every( predicate?: string|any[] ): boolean; /** * @see _.every */ every( predicate?: TObject ): boolean; } interface LoDashExplicitArrayWrapper { /** * @see _.every */ every( predicate?: ListIterator|NumericDictionaryIterator ): LoDashExplicitWrapper; /** * @see _.every */ every( predicate?: string|any[] ): LoDashExplicitWrapper; /** * @see _.every */ every( predicate?: TObject ): LoDashExplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.every */ every( predicate?: ListIterator|DictionaryIterator|NumericDictionaryIterator ): LoDashExplicitWrapper; /** * @see _.every */ every( predicate?: string|any[] ): LoDashExplicitWrapper; /** * @see _.every */ every( predicate?: TObject ): LoDashExplicitWrapper; } //_.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( collection: List, predicate?: ListIterator, thisArg?: any ): T[]; /** * @see _.filter */ filter( collection: Dictionary, predicate?: DictionaryIterator, thisArg?: any ): T[]; /** * @see _.filter */ filter( collection: string, predicate?: StringIterator, thisArg?: any ): string[]; /** * @see _.filter */ filter( collection: List|Dictionary, predicate: string, thisArg?: any ): T[]; /** * @see _.filter */ filter( collection: List|Dictionary, predicate: W ): T[]; } interface LoDashImplicitWrapper { /** * @see _.filter */ filter( predicate?: StringIterator, thisArg?: any ): LoDashImplicitArrayWrapper; } interface LoDashImplicitArrayWrapper { /** * @see _.filter */ filter( predicate: ListIterator, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.filter */ filter( predicate: string, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.filter */ filter(predicate: W): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.filter */ filter( predicate: ListIterator|DictionaryIterator, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.filter */ filter( predicate: string, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.filter */ filter(predicate: W): LoDashImplicitArrayWrapper; } interface LoDashExplicitWrapper { /** * @see _.filter */ filter( predicate?: StringIterator, thisArg?: any ): LoDashExplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.filter */ filter( predicate: ListIterator, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.filter */ filter( predicate: string, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.filter */ filter(predicate: W): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.filter */ filter( predicate: ListIterator|DictionaryIterator, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.filter */ filter( predicate: string, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.filter */ filter(predicate: W): LoDashExplicitArrayWrapper; } //_.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 thisArg The this binding of predicate. * @return Returns the matched element, else undefined. */ find( collection: List, predicate?: ListIterator, thisArg?: any ): T; /** * @see _.find */ find( collection: Dictionary, predicate?: DictionaryIterator, thisArg?: any ): T; /** * @see _.find */ find( collection: List|Dictionary, predicate?: string, thisArg?: any ): T; /** * @see _.find */ find( collection: List|Dictionary, predicate?: TObject ): T; } interface LoDashImplicitArrayWrapper { /** * @see _.find */ find( predicate?: ListIterator, thisArg?: any ): T; /** * @see _.find */ find( predicate?: string, thisArg?: any ): T; /** * @see _.find */ find( predicate?: TObject ): T; } interface LoDashImplicitObjectWrapper { /** * @see _.find */ find( predicate?: ListIterator|DictionaryIterator, thisArg?: any ): TResult; /** * @see _.find */ find( predicate?: string, thisArg?: any ): TResult; /** * @see _.find */ find( predicate?: TObject ): 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 thisArg The this binding of callback. * @return The found element, else undefined. **/ findLast( collection: Array, callback: ListIterator, thisArg?: any): T; /** * @see _.find **/ findLast( collection: List, callback: ListIterator, thisArg?: any): T; /** * @see _.find **/ findLast( collection: Dictionary, callback: DictionaryIterator, thisArg?: any): T; /** * @see _.find * @param _.pluck style callback **/ findLast( collection: Array, whereValue: W): T; /** * @see _.find * @param _.pluck style callback **/ findLast( collection: List, whereValue: W): T; /** * @see _.find * @param _.pluck style callback **/ findLast( collection: Dictionary, whereValue: W): T; /** * @see _.find * @param _.where style callback **/ findLast( collection: Array, pluckValue: string): T; /** * @see _.find * @param _.where style callback **/ findLast( collection: List, pluckValue: string): T; /** * @see _.find * @param _.where style callback **/ findLast( collection: Dictionary, pluckValue: string): T; } interface LoDashImplicitArrayWrapper { /** * @see _.findLast */ findLast( callback: ListIterator, thisArg?: any): T; /** * @see _.findLast * @param _.where style callback */ findLast( whereValue: W): T; /** * @see _.findLast * @param _.where style callback */ findLast( pluckValue: string): T; } //_.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( collection: T[], iteratee?: ListIterator, thisArg?: any ): T[]; /** * @see _.forEach */ forEach( collection: List, iteratee?: ListIterator, thisArg?: any ): List; /** * @see _.forEach */ forEach( collection: Dictionary, iteratee?: DictionaryIterator, thisArg?: any ): Dictionary; /** * @see _.forEach */ forEach( collection: T, iteratee?: ObjectIterator, thisArgs?: any ): T; /** * @see _.forEach */ forEach( collection: T, iteratee?: ObjectIterator, thisArgs?: any ): T; } interface LoDashImplicitWrapper { /** * @see _.forEach */ forEach( iteratee: ListIterator, thisArg?: any ): LoDashImplicitWrapper; } interface LoDashImplicitArrayWrapper { /** * @see _.forEach */ forEach( iteratee: ListIterator, thisArg?: any ): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.forEach */ forEach( iteratee?: ListIterator|DictionaryIterator, thisArg?: any ): LoDashImplicitObjectWrapper; } interface LoDashExplicitWrapper { /** * @see _.forEach */ forEach( iteratee: ListIterator, thisArg?: any ): LoDashExplicitWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.forEach */ forEach( iteratee: ListIterator, thisArg?: any ): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.forEach */ forEach( iteratee?: ListIterator|DictionaryIterator, thisArg?: any ): LoDashExplicitObjectWrapper; } //_.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( collection: T[], iteratee?: ListIterator, thisArg?: any ): T[]; /** * @see _.forEachRight */ forEachRight( collection: List, iteratee?: ListIterator, thisArg?: any ): List; /** * @see _.forEachRight */ forEachRight( collection: Dictionary, iteratee?: DictionaryIterator, thisArg?: any ): Dictionary; /** * @see _.forEachRight */ forEachRight( collection: T, iteratee?: ObjectIterator, thisArgs?: any ): T; /** * @see _.forEachRight */ forEachRight( collection: T, iteratee?: ObjectIterator, thisArgs?: any ): T; } interface LoDashImplicitWrapper { /** * @see _.forEachRight */ forEachRight( iteratee: ListIterator, thisArg?: any ): LoDashImplicitWrapper; } interface LoDashImplicitArrayWrapper { /** * @see _.forEachRight */ forEachRight( iteratee: ListIterator, thisArg?: any ): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.forEachRight */ forEachRight( iteratee?: ListIterator|DictionaryIterator, thisArg?: any ): LoDashImplicitObjectWrapper; } interface LoDashExplicitWrapper { /** * @see _.forEachRight */ forEachRight( iteratee: ListIterator, thisArg?: any ): LoDashExplicitWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.forEachRight */ forEachRight( iteratee: ListIterator, thisArg?: any ): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.forEachRight */ forEachRight( iteratee?: ListIterator|DictionaryIterator, thisArg?: any ): LoDashExplicitObjectWrapper; } //_.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( collection: List, iteratee?: ListIterator, thisArg?: any ): Dictionary; /** * @see _.groupBy */ groupBy( collection: List, iteratee?: ListIterator, thisArg?: any ): Dictionary; /** * @see _.groupBy */ groupBy( collection: Dictionary, iteratee?: DictionaryIterator, thisArg?: any ): Dictionary; /** * @see _.groupBy */ groupBy( collection: Dictionary, iteratee?: DictionaryIterator, thisArg?: any ): Dictionary; /** * @see _.groupBy */ groupBy( collection: List|Dictionary, iteratee?: string, thisArg?: TValue ): Dictionary; /** * @see _.groupBy */ groupBy( collection: List|Dictionary, iteratee?: string, thisArg?: any ): Dictionary; /** * @see _.groupBy */ groupBy( collection: List|Dictionary, iteratee?: TWhere ): Dictionary; /** * @see _.groupBy */ groupBy( collection: List|Dictionary, iteratee?: Object ): Dictionary; } interface LoDashImplicitWrapper { /** * @see _.groupBy */ groupBy( iteratee?: ListIterator, thisArg?: any ): LoDashImplicitObjectWrapper>; } interface LoDashImplicitArrayWrapper { /** * @see _.groupBy */ groupBy( iteratee?: ListIterator, thisArg?: any ): LoDashImplicitObjectWrapper>; /** * @see _.groupBy */ groupBy( iteratee?: string, thisArg?: TValue ): LoDashImplicitObjectWrapper>; /** * @see _.groupBy */ groupBy( iteratee?: TWhere ): LoDashImplicitObjectWrapper>; } interface LoDashImplicitObjectWrapper { /** * @see _.groupBy */ groupBy( iteratee?: ListIterator|DictionaryIterator, thisArg?: any ): LoDashImplicitObjectWrapper>; /** * @see _.groupBy */ groupBy( iteratee?: ListIterator|DictionaryIterator, thisArg?: any ): LoDashImplicitObjectWrapper>; /** * @see _.groupBy */ groupBy( iteratee?: string, thisArg?: TValue ): LoDashImplicitObjectWrapper>; /** * @see _.groupBy */ groupBy( iteratee?: string, thisArg?: any ): LoDashImplicitObjectWrapper>; /** * @see _.groupBy */ groupBy( iteratee?: TWhere ): LoDashImplicitObjectWrapper>; /** * @see _.groupBy */ groupBy( iteratee?: Object ): LoDashImplicitObjectWrapper>; } interface LoDashExplicitWrapper { /** * @see _.groupBy */ groupBy( iteratee?: ListIterator, thisArg?: any ): LoDashExplicitObjectWrapper>; } interface LoDashExplicitArrayWrapper { /** * @see _.groupBy */ groupBy( iteratee?: ListIterator, thisArg?: any ): LoDashExplicitObjectWrapper>; /** * @see _.groupBy */ groupBy( iteratee?: string, thisArg?: TValue ): LoDashExplicitObjectWrapper>; /** * @see _.groupBy */ groupBy( iteratee?: TWhere ): LoDashExplicitObjectWrapper>; } interface LoDashExplicitObjectWrapper { /** * @see _.groupBy */ groupBy( iteratee?: ListIterator|DictionaryIterator, thisArg?: any ): LoDashExplicitObjectWrapper>; /** * @see _.groupBy */ groupBy( iteratee?: ListIterator|DictionaryIterator, thisArg?: any ): LoDashExplicitObjectWrapper>; /** * @see _.groupBy */ groupBy( iteratee?: string, thisArg?: TValue ): LoDashExplicitObjectWrapper>; /** * @see _.groupBy */ groupBy( iteratee?: string, thisArg?: any ): LoDashExplicitObjectWrapper>; /** * @see _.groupBy */ groupBy( iteratee?: TWhere ): LoDashExplicitObjectWrapper>; /** * @see _.groupBy */ groupBy( iteratee?: Object ): LoDashExplicitObjectWrapper>; } //_.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( collection: List|Dictionary, target: T, fromIndex?: number ): boolean; /** * @see _.includes */ includes( collection: string, target: string, fromIndex?: number ): boolean; } interface LoDashImplicitArrayWrapper { /** * @see _.includes */ includes( target: T, fromIndex?: number ): boolean; } interface LoDashImplicitObjectWrapper { /** * @see _.includes */ includes( target: TValue, fromIndex?: number ): boolean; } interface LoDashImplicitWrapper { /** * @see _.includes */ includes( target: string, fromIndex?: number ): boolean; } interface LoDashExplicitArrayWrapper { /** * @see _.includes */ includes( target: T, fromIndex?: number ): LoDashExplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.includes */ includes( target: TValue, fromIndex?: number ): LoDashExplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.includes */ includes( target: string, fromIndex?: number ): LoDashExplicitWrapper; } //_.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( collection: List, iteratee?: ListIterator, thisArg?: any ): Dictionary; /** * @see _.keyBy */ keyBy( collection: NumericDictionary, iteratee?: NumericDictionaryIterator, thisArg?: any ): Dictionary; /** * @see _.keyBy */ keyBy( collection: Dictionary, iteratee?: DictionaryIterator, thisArg?: any ): Dictionary; /** * @see _.keyBy */ keyBy( collection: List|NumericDictionary|Dictionary, iteratee?: string, thisArg?: any ): Dictionary; /** * @see _.keyBy */ keyBy( collection: List|NumericDictionary|Dictionary, iteratee?: W ): Dictionary; /** * @see _.keyBy */ keyBy( collection: List|NumericDictionary|Dictionary, iteratee?: Object ): Dictionary; } interface LoDashImplicitWrapper { /** * @see _.keyBy */ keyBy( iteratee?: ListIterator, thisArg?: any ): LoDashImplicitObjectWrapper>; } interface LoDashImplicitArrayWrapper { /** * @see _.keyBy */ keyBy( iteratee?: ListIterator, thisArg?: any ): LoDashImplicitObjectWrapper>; /** * @see _.keyBy */ keyBy( iteratee?: string, thisArg?: any ): LoDashImplicitObjectWrapper>; /** * @see _.keyBy */ keyBy( iteratee?: W ): LoDashImplicitObjectWrapper>; } interface LoDashImplicitObjectWrapper { /** * @see _.keyBy */ keyBy( iteratee?: ListIterator|NumericDictionaryIterator|DictionaryIterator, thisArg?: any ): LoDashImplicitObjectWrapper>; /** * @see _.keyBy */ keyBy( iteratee?: string, thisArg?: any ): LoDashImplicitObjectWrapper>; /** * @see _.keyBy */ keyBy( iteratee?: W ): LoDashImplicitObjectWrapper>; /** * @see _.keyBy */ keyBy( iteratee?: Object ): LoDashImplicitObjectWrapper>; } interface LoDashExplicitWrapper { /** * @see _.keyBy */ keyBy( iteratee?: ListIterator, thisArg?: any ): LoDashExplicitObjectWrapper>; } interface LoDashExplicitArrayWrapper { /** * @see _.keyBy */ keyBy( iteratee?: ListIterator, thisArg?: any ): LoDashExplicitObjectWrapper>; /** * @see _.keyBy */ keyBy( iteratee?: string, thisArg?: any ): LoDashExplicitObjectWrapper>; /** * @see _.keyBy */ keyBy( iteratee?: W ): LoDashExplicitObjectWrapper>; } interface LoDashExplicitObjectWrapper { /** * @see _.keyBy */ keyBy( iteratee?: ListIterator|NumericDictionaryIterator|DictionaryIterator, thisArg?: any ): LoDashExplicitObjectWrapper>; /** * @see _.keyBy */ keyBy( iteratee?: string, thisArg?: any ): LoDashExplicitObjectWrapper>; /** * @see _.keyBy */ keyBy( iteratee?: W ): LoDashExplicitObjectWrapper>; /** * @see _.keyBy */ keyBy( iteratee?: Object ): LoDashExplicitObjectWrapper>; } //_.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( collection: TValue[], methodName: string, ...args: any[]): TResult[]; /** * @see _.invokeMap **/ invokeMap( collection: Dictionary, methodName: string, ...args: any[]): TResult[]; /** * @see _.invokeMap **/ invokeMap( collection: {}[], methodName: string, ...args: any[]): TResult[]; /** * @see _.invokeMap **/ invokeMap( collection: Dictionary<{}>, methodName: string, ...args: any[]): TResult[]; /** * @see _.invokeMap **/ invokeMap( collection: TValue[], method: (...args: any[]) => TResult, ...args: any[]): TResult[]; /** * @see _.invokeMap **/ invokeMap( collection: Dictionary, method: (...args: any[]) => TResult, ...args: any[]): TResult[]; /** * @see _.invokeMap **/ invokeMap( collection: {}[], method: (...args: any[]) => TResult, ...args: any[]): TResult[]; /** * @see _.invokeMap **/ invokeMap( collection: Dictionary<{}>, method: (...args: any[]) => TResult, ...args: any[]): TResult[]; } interface LoDashImplicitArrayWrapper { /** * @see _.invokeMap **/ invokeMap( methodName: string, ...args: any[]): LoDashImplicitArrayWrapper; /** * @see _.invokeMap **/ invokeMap( method: (...args: any[]) => TResult, ...args: any[]): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.invokeMap **/ invokeMap( methodName: string, ...args: any[]): LoDashImplicitArrayWrapper; /** * @see _.invokeMap **/ invokeMap( method: (...args: any[]) => TResult, ...args: any[]): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.invokeMap **/ invokeMap( methodName: string, ...args: any[]): LoDashExplicitArrayWrapper; /** * @see _.invokeMap **/ invokeMap( method: (...args: any[]) => TResult, ...args: any[]): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.invokeMap **/ invokeMap( methodName: string, ...args: any[]): LoDashExplicitArrayWrapper; /** * @see _.invokeMap **/ invokeMap( method: (...args: any[]) => TResult, ...args: any[]): LoDashExplicitArrayWrapper; } //_.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( collection: List, iteratee?: ListIterator, thisArg?: any ): TResult[]; /** * @see _.map */ map( collection: Dictionary, iteratee?: DictionaryIterator, thisArg?: any ): TResult[]; /** * @see _.map */ map( collection: List|Dictionary, iteratee?: string ): TResult[]; /** * @see _.map */ map( collection: List|Dictionary, iteratee?: TObject ): boolean[]; } interface LoDashImplicitArrayWrapper { /** * @see _.map */ map( iteratee?: ListIterator, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.map */ map( iteratee?: string ): LoDashImplicitArrayWrapper; /** * @see _.map */ map( iteratee?: TObject ): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.map */ map( iteratee?: ListIterator|DictionaryIterator, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.map */ map( iteratee?: string ): LoDashImplicitArrayWrapper; /** * @see _.map */ map( iteratee?: TObject ): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.map */ map( iteratee?: ListIterator, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.map */ map( iteratee?: string ): LoDashExplicitArrayWrapper; /** * @see _.map */ map( iteratee?: TObject ): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.map */ map( iteratee?: ListIterator|DictionaryIterator, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.map */ map( iteratee?: string ): LoDashExplicitArrayWrapper; /** * @see _.map */ map( iteratee?: TObject ): LoDashExplicitArrayWrapper; } //_.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( collection: List, callback: ListIterator, thisArg?: any): T[][]; /** * @see _.partition **/ partition( collection: Dictionary, callback: DictionaryIterator, thisArg?: any): T[][]; /** * @see _.partition **/ partition( collection: List, whereValue: W): T[][]; /** * @see _.partition **/ partition( collection: Dictionary, whereValue: W): T[][]; /** * @see _.partition **/ partition( collection: List, path: string, srcValue: any): T[][]; /** * @see _.partition **/ partition( collection: Dictionary, path: string, srcValue: any): T[][]; /** * @see _.partition **/ partition( collection: List, pluckValue: string): T[][]; /** * @see _.partition **/ partition( collection: Dictionary, pluckValue: string): T[][]; } interface LoDashImplicitStringWrapper { /** * @see _.partition */ partition( callback: ListIterator, thisArg?: any): LoDashImplicitArrayWrapper; } interface LoDashImplicitArrayWrapper { /** * @see _.partition */ partition( callback: ListIterator, thisArg?: any): LoDashImplicitArrayWrapper; /** * @see _.partition */ partition( whereValue: W): LoDashImplicitArrayWrapper; /** * @see _.partition */ partition( path: string, srcValue: any): LoDashImplicitArrayWrapper; /** * @see _.partition */ partition( pluckValue: string): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.partition */ partition( callback: ListIterator, thisArg?: any): LoDashImplicitArrayWrapper; /** * @see _.partition */ partition( callback: DictionaryIterator, thisArg?: any): LoDashImplicitArrayWrapper; /** * @see _.partition */ partition( whereValue: W): LoDashImplicitArrayWrapper; /** * @see _.partition */ partition( path: string, srcValue: any): LoDashImplicitArrayWrapper; /** * @see _.partition */ partition( pluckValue: string): LoDashImplicitArrayWrapper; } //_.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( collection: Array, callback: MemoIterator, accumulator: TResult, thisArg?: any): TResult; /** * @see _.reduce **/ reduce( collection: List, callback: MemoIterator, accumulator: TResult, thisArg?: any): TResult; /** * @see _.reduce **/ reduce( collection: Dictionary, callback: MemoIterator, accumulator: TResult, thisArg?: any): TResult; /** * @see _.reduce **/ reduce( collection: Array, callback: MemoIterator, thisArg?: any): TResult; /** * @see _.reduce **/ reduce( collection: List, callback: MemoIterator, thisArg?: any): TResult; /** * @see _.reduce **/ reduce( collection: Dictionary, callback: MemoIterator, thisArg?: any): TResult; } interface LoDashImplicitArrayWrapper { /** * @see _.reduce **/ reduce( callback: MemoIterator, accumulator: TResult, thisArg?: any): TResult; /** * @see _.reduce **/ reduce( callback: MemoIterator, thisArg?: any): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.reduce **/ reduce( callback: MemoIterator, accumulator: TResult, thisArg?: any): TResult; /** * @see _.reduce **/ reduce( callback: MemoIterator, thisArg?: any): 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( collection: Array, callback: MemoIterator, accumulator: TResult, thisArg?: any): TResult; /** * @see _.reduceRight **/ reduceRight( collection: List, callback: MemoIterator, accumulator: TResult, thisArg?: any): TResult; /** * @see _.reduceRight **/ reduceRight( collection: Dictionary, callback: MemoIterator, accumulator: TResult, thisArg?: any): TResult; /** * @see _.reduceRight **/ reduceRight( collection: Array, callback: MemoIterator, thisArg?: any): TResult; /** * @see _.reduceRight **/ reduceRight( collection: List, callback: MemoIterator, thisArg?: any): TResult; /** * @see _.reduceRight **/ reduceRight( collection: Dictionary, callback: MemoIterator, thisArg?: any): 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( collection: List, predicate?: ListIterator, thisArg?: any ): T[]; /** * @see _.reject */ reject( collection: Dictionary, predicate?: DictionaryIterator, thisArg?: any ): T[]; /** * @see _.reject */ reject( collection: string, predicate?: StringIterator, thisArg?: any ): string[]; /** * @see _.reject */ reject( collection: List|Dictionary, predicate: string, thisArg?: any ): T[]; /** * @see _.reject */ reject( collection: List|Dictionary, predicate: W ): T[]; } interface LoDashImplicitWrapper { /** * @see _.reject */ reject( predicate?: StringIterator, thisArg?: any ): LoDashImplicitArrayWrapper; } interface LoDashImplicitArrayWrapper { /** * @see _.reject */ reject( predicate: ListIterator, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.reject */ reject( predicate: string, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.reject */ reject(predicate: W): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.reject */ reject( predicate: ListIterator|DictionaryIterator, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.reject */ reject( predicate: string, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.reject */ reject(predicate: W): LoDashImplicitArrayWrapper; } interface LoDashExplicitWrapper { /** * @see _.reject */ reject( predicate?: StringIterator, thisArg?: any ): LoDashExplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.reject */ reject( predicate: ListIterator, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.reject */ reject( predicate: string, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.reject */ reject(predicate: W): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.reject */ reject( predicate: ListIterator|DictionaryIterator, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.reject */ reject( predicate: string, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.reject */ reject(predicate: W): LoDashExplicitArrayWrapper; } //_.sample interface LoDashStatic { /** * Gets a random element from `collection`. * * @static * @memberOf _ * @category Collection * @param {Array|Object} collection The collection to sample. * @returns {*} Returns the random element. * @example * * _.sample([1, 2, 3, 4]); * // => 2 */ sample(collection: Array): T; /** * @see _.sample **/ sample(collection: List): T; /** * @see _.sample **/ sample(collection: Dictionary): T; } interface LoDashImplicitArrayWrapper { /** * @see _.sample **/ sample(): LoDashImplicitWrapper; } //_.sampleSize interface LoDashStatic { /** * Gets `n` random elements from `collection`. * * @static * @memberOf _ * @category Collection * @param {Array|Object} collection The collection to sample. * @param {number} [n=0] The number of elements to sample. * @returns {Array} Returns the random elements. * @example * * _.sampleSize([1, 2, 3, 4], 2); * // => [3, 1] */ sampleSize(collection: Array, n: number): T[]; /** * @see _.sampleSize **/ sampleSize(collection: List, n: number): T[]; /** * @see _.sampleSize **/ sampleSize(collection: Dictionary, n: number): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.sampleSize **/ sampleSize(n: number): LoDashImplicitArrayWrapper; /** * @see _.sampleSize **/ sampleSize(): LoDashImplicitWrapper; } //_.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(collection: List|Dictionary): T[]; /** * @see _.shuffle */ shuffle(collection: string): string[]; } interface LoDashImplicitWrapper { /** * @see _.shuffle */ shuffle(): LoDashImplicitArrayWrapper; } interface LoDashImplicitArrayWrapper { /** * @see _.shuffle */ shuffle(): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.shuffle */ shuffle(): LoDashImplicitArrayWrapper; } interface LoDashExplicitWrapper { /** * @see _.shuffle */ shuffle(): LoDashExplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.shuffle */ shuffle(): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.shuffle */ shuffle(): LoDashExplicitArrayWrapper; } //_.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(collection: List|Dictionary): number; /** * @see _.size */ size(collection: string): number; } interface LoDashImplicitWrapper { /** * @see _.size */ size(): number; } interface LoDashImplicitArrayWrapper { /** * @see _.size */ size(): number; } interface LoDashImplicitObjectWrapper { /** * @see _.size */ size(): number; } interface LoDashExplicitWrapper { /** * @see _.size */ size(): LoDashExplicitWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.size */ size(): LoDashExplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.size */ size(): LoDashExplicitWrapper; } //_.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( collection: List, predicate?: ListIterator ): boolean; /** * @see _.some */ some( collection: Dictionary, predicate?: DictionaryIterator ): boolean; /** * @see _.some */ some( collection: NumericDictionary, predicate?: NumericDictionaryIterator ): boolean; /** * @see _.some */ some( collection: List|Dictionary|NumericDictionary, predicate?: string|any[] ): boolean; /** * @see _.some */ some( collection: List|Dictionary|NumericDictionary, predicate?: TObject ): boolean; } interface LoDashImplicitArrayWrapper { /** * @see _.some */ some( predicate?: ListIterator|NumericDictionaryIterator ): boolean; /** * @see _.some */ some( predicate?: string|any[] ): boolean; /** * @see _.some */ some( predicate?: TObject ): boolean; } interface LoDashImplicitObjectWrapper { /** * @see _.some */ some( predicate?: ListIterator|DictionaryIterator|NumericDictionaryIterator ): boolean; /** * @see _.some */ some( predicate?: string|any[] ): boolean; /** * @see _.some */ some( predicate?: TObject ): boolean; } interface LoDashExplicitArrayWrapper { /** * @see _.some */ some( predicate?: ListIterator|NumericDictionaryIterator ): LoDashExplicitWrapper; /** * @see _.some */ some( predicate?: string|any[] ): LoDashExplicitWrapper; /** * @see _.some */ some( predicate?: TObject ): LoDashExplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.some */ some( predicate?: ListIterator|DictionaryIterator|NumericDictionaryIterator ): LoDashExplicitWrapper; /** * @see _.some */ some( predicate?: string|any[] ): LoDashExplicitWrapper; /** * @see _.some */ some( predicate?: TObject ): LoDashExplicitWrapper; } //_.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( collection: List, iteratee?: ListIterator ): T[]; /** * @see _.sortBy */ sortBy( collection: Dictionary, iteratee?: DictionaryIterator ): T[]; /** * @see _.sortBy */ sortBy( collection: List|Dictionary, iteratee: string ): T[]; /** * @see _.sortBy */ sortBy( collection: List|Dictionary, whereValue: W ): T[]; /** * @see _.sortBy */ sortBy( collection: List|Dictionary ): T[]; /** * @see _.sortBy */ sortBy( collection: (Array|List), iteratees: (ListIterator|string|Object)[]): T[]; /** * @see _.sortBy */ sortBy( collection: (Array|List), ...iteratees: (ListIterator|Object|string)[]): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.sortBy */ sortBy( iteratee?: ListIterator ): LoDashImplicitArrayWrapper; /** * @see _.sortBy */ sortBy(iteratee: string): LoDashImplicitArrayWrapper; /** * @see _.sortBy */ sortBy(whereValue: W): LoDashImplicitArrayWrapper; /** * @see _.sortBy */ sortBy(): LoDashImplicitArrayWrapper; /** * @see _.sortBy */ sortBy(...iteratees: (ListIterator|Object|string)[]): LoDashImplicitArrayWrapper; /** * @see _.sortBy **/ sortBy(iteratees: (ListIterator|string|Object)[]): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.sortBy */ sortBy( iteratee?: ListIterator|DictionaryIterator ): LoDashImplicitArrayWrapper; /** * @see _.sortBy */ sortBy(iteratee: string): LoDashImplicitArrayWrapper; /** * @see _.sortBy */ sortBy(whereValue: W): LoDashImplicitArrayWrapper; /** * @see _.sortBy */ sortBy(): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.sortBy */ sortBy( iteratee?: ListIterator ): LoDashExplicitArrayWrapper; /** * @see _.sortBy */ sortBy(iteratee: string): LoDashExplicitArrayWrapper; /** * @see _.sortBy */ sortBy(whereValue: W): LoDashExplicitArrayWrapper; /** * @see _.sortBy */ sortBy(): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.sortBy */ sortBy( iteratee?: ListIterator|DictionaryIterator ): LoDashExplicitArrayWrapper; /** * @see _.sortBy */ sortBy(iteratee: string): LoDashExplicitArrayWrapper; /** * @see _.sortBy */ sortBy(whereValue: W): LoDashExplicitArrayWrapper; /** * @see _.sortBy */ sortBy(): LoDashExplicitArrayWrapper; } //_.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( collection: List, iteratees: ListIterator|string|W|(ListIterator|string|W)[], orders?: boolean|string|(boolean|string)[] ): T[]; /** * @see _.orderBy */ orderBy( collection: List, iteratees: ListIterator|string|Object|(ListIterator|string|Object)[], orders?: boolean|string|(boolean|string)[] ): T[]; /** * @see _.orderBy */ orderBy( collection: NumericDictionary, iteratees: NumericDictionaryIterator|string|W|(NumericDictionaryIterator|string|W)[], orders?: boolean|string|(boolean|string)[] ): T[]; /** * @see _.orderBy */ orderBy( collection: NumericDictionary, iteratees: NumericDictionaryIterator|string|Object|(NumericDictionaryIterator|string|Object)[], orders?: boolean|string|(boolean|string)[] ): T[]; /** * @see _.orderBy */ orderBy( collection: Dictionary, iteratees: DictionaryIterator|string|W|(DictionaryIterator|string|W)[], orders?: boolean|string|(boolean|string)[] ): T[]; /** * @see _.orderBy */ orderBy( collection: Dictionary, iteratees: DictionaryIterator|string|Object|(DictionaryIterator|string|Object)[], orders?: boolean|string|(boolean|string)[] ): T[]; } interface LoDashImplicitWrapper { /** * @see _.orderBy */ orderBy( iteratees: ListIterator|string|(ListIterator|string)[], orders?: boolean|string|(boolean|string)[] ): LoDashImplicitArrayWrapper; } interface LoDashImplicitArrayWrapper { /** * @see _.orderBy */ orderBy( iteratees: ListIterator|string|W|(ListIterator|string|W)[], orders?: boolean|string|(boolean|string)[] ): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.orderBy */ orderBy( iteratees: ListIterator|string|W|(ListIterator|string|W)[], orders?: boolean|string|(boolean|string)[] ): LoDashImplicitArrayWrapper; /** * @see _.orderBy */ orderBy( iteratees: ListIterator|string|Object|(ListIterator|string|Object)[], orders?: boolean|string|(boolean|string)[] ): LoDashImplicitArrayWrapper; /** * @see _.orderBy */ orderBy( iteratees: NumericDictionaryIterator|string|W|(NumericDictionaryIterator|string|W)[], orders?: boolean|string|(boolean|string)[] ): LoDashImplicitArrayWrapper; /** * @see _.orderBy */ orderBy( iteratees: NumericDictionaryIterator|string|Object|(NumericDictionaryIterator|string|Object)[], orders?: boolean|string|(boolean|string)[] ): LoDashImplicitArrayWrapper; /** * @see _.orderBy */ orderBy( iteratees: DictionaryIterator|string|W|(DictionaryIterator|string|W)[], orders?: boolean|string|(boolean|string)[] ): LoDashImplicitArrayWrapper; /** * @see _.orderBy */ orderBy( iteratees: DictionaryIterator|string|Object|(DictionaryIterator|string|Object)[], orders?: boolean|string|(boolean|string)[] ): LoDashImplicitArrayWrapper; } interface LoDashExplicitWrapper { /** * @see _.orderBy */ orderBy( iteratees: ListIterator|string|(ListIterator|string)[], orders?: boolean|string|(boolean|string)[] ): LoDashExplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.orderBy */ orderBy( iteratees: ListIterator|string|W|(ListIterator|string|W)[], orders?: boolean|string|(boolean|string)[] ): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.orderBy */ orderBy( iteratees: ListIterator|string|W|(ListIterator|string|W)[], orders?: boolean|string|(boolean|string)[] ): LoDashExplicitArrayWrapper; /** * @see _.orderBy */ orderBy( iteratees: ListIterator|string|Object|(ListIterator|string|Object)[], orders?: boolean|string|(boolean|string)[] ): LoDashExplicitArrayWrapper; /** * @see _.orderBy */ orderBy( iteratees: NumericDictionaryIterator|string|W|(NumericDictionaryIterator|string|W)[], orders?: boolean|string|(boolean|string)[] ): LoDashExplicitArrayWrapper; /** * @see _.orderBy */ orderBy( iteratees: NumericDictionaryIterator|string|Object|(NumericDictionaryIterator|string|Object)[], orders?: boolean|string|(boolean|string)[] ): LoDashExplicitArrayWrapper; /** * @see _.orderBy */ orderBy( iteratees: DictionaryIterator|string|W|(DictionaryIterator|string|W)[], orders?: boolean|string|(boolean|string)[] ): LoDashExplicitArrayWrapper; /** * @see _.orderBy */ orderBy( iteratees: DictionaryIterator|string|Object|(DictionaryIterator|string|Object)[], orders?: boolean|string|(boolean|string)[] ): LoDashExplicitArrayWrapper; } /******** * 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 { /** * @see _.now */ now(): number; } interface LoDashExplicitWrapperBase { /** * @see _.now */ now(): LoDashExplicitWrapper; } /************* * 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( n: number, func: TFunc ): TFunc; } interface LoDashImplicitWrapper { /** * @see _.after **/ after(func: TFunc): LoDashImplicitObjectWrapper; } interface LoDashExplicitWrapper { /** * @see _.after **/ after(func: TFunc): LoDashExplicitObjectWrapper; } //_.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( func: Function, n?: number ): TResult; ary( func: T, n?: number ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.ary */ ary(n?: number): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.ary */ ary(n?: number): LoDashExplicitObjectWrapper; } //_.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( n: number, func: TFunc ): TFunc; } interface LoDashImplicitWrapper { /** * @see _.before **/ before(func: TFunc): LoDashImplicitObjectWrapper; } interface LoDashExplicitWrapper { /** * @see _.before **/ before(func: TFunc): LoDashExplicitObjectWrapper; } //_.bind interface FunctionBind { placeholder: any; ( func: T, thisArg: any, ...partials: any[] ): TResult; ( 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 { /** * @see _.bind */ bind( thisArg: any, ...partials: any[] ): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.bind */ bind( thisArg: any, ...partials: any[] ): LoDashExplicitObjectWrapper; } //_.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( object: T, ...methodNames: (string|string[])[] ): T; } interface LoDashImplicitObjectWrapper { /** * @see _.bindAll */ bindAll(...methodNames: (string|string[])[]): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.bindAll */ bindAll(...methodNames: (string|string[])[]): LoDashExplicitObjectWrapper; } //_.bindKey interface FunctionBindKey { placeholder: any; ( object: T, key: any, ...partials: any[] ): TResult; ( 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 { /** * @see _.bindKey */ bindKey( key: any, ...partials: any[] ): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.bindKey */ bindKey( key: any, ...partials: any[] ): LoDashExplicitObjectWrapper; } //_.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, thisArg?: any, argCount?: number): () => any; /** * @see _.createCallback **/ createCallback( func: Dictionary, thisArg?: any, argCount?: number): () => boolean; } interface LoDashImplicitWrapper { /** * @see _.createCallback **/ createCallback( thisArg?: any, argCount?: number): LoDashImplicitObjectWrapper<() => any>; } interface LoDashImplicitObjectWrapper { /** * @see _.createCallback **/ createCallback( thisArg?: any, 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(func: (t1: T1) => R): CurriedFunction1; /** * 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(func: (t1: T1, t2: T2) => R): CurriedFunction2; /** * 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(func: (t1: T1, t2: T2, t3: T3) => R): CurriedFunction3; /** * 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(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R): CurriedFunction4; /** * 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(func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R): CurriedFunction5; /** * 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( func: Function, arity?: number): TResult; } interface CurriedFunction1 { (): CurriedFunction1; (t1: T1): R; } interface CurriedFunction2 { (): CurriedFunction2; (t1: T1): CurriedFunction1; (t1: T1, t2: T2): R; } interface CurriedFunction3 { (): CurriedFunction3; (t1: T1): CurriedFunction2; (t1: T1, t2: T2): CurriedFunction1; (t1: T1, t2: T2, t3: T3): R; } interface CurriedFunction4 { (): CurriedFunction4; (t1: T1): CurriedFunction3; (t1: T1, t2: T2): CurriedFunction2; (t1: T1, t2: T2, t3: T3): CurriedFunction1; (t1: T1, t2: T2, t3: T3, t4: T4): R; } interface CurriedFunction5 { (): CurriedFunction5; (t1: T1): CurriedFunction4; (t1: T1, t2: T2): CurriedFunction3; (t1: T1, t2: T2, t3: T3): CurriedFunction2; (t1: T1, t2: T2, t3: T3, t4: T4): CurriedFunction1; (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5): R; } interface LoDashImplicitObjectWrapper { /** * @see _.curry **/ curry(arity?: number): LoDashImplicitObjectWrapper; } //_.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(func: (t1: T1) => R): CurriedFunction1; /** * 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(func: (t1: T1, t2: T2) => R): CurriedFunction2; /** * 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(func: (t1: T1, t2: T2, t3: T3) => R): CurriedFunction3; /** * 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(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R): CurriedFunction4; /** * 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(func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R): CurriedFunction5; /** * 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( func: Function, arity?: number): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.curryRight **/ curryRight(arity?: number): LoDashImplicitObjectWrapper; } //_.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. 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( func: T, wait?: number, options?: DebounceSettings ): T & Cancelable; } interface LoDashImplicitObjectWrapper { /** * @see _.debounce */ debounce( wait?: number, options?: DebounceSettings ): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.debounce */ debounce( wait?: number, options?: DebounceSettings ): LoDashExplicitObjectWrapper; } //_.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( func: T, ...args: any[] ): number; } interface LoDashImplicitObjectWrapper { /** * @see _.defer */ defer(...args: any[]): LoDashImplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.defer */ defer(...args: any[]): LoDashExplicitWrapper; } //_.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( func: T, wait: number, ...args: any[] ): number; } interface LoDashImplicitObjectWrapper { /** * @see _.delay */ delay( wait: number, ...args: any[] ): LoDashImplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.delay */ delay( wait: number, ...args: any[] ): LoDashExplicitWrapper; } 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(func: T): T; } interface LoDashImplicitObjectWrapper { /** * @see _.flip */ flip(): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.flip */ flip(): LoDashExplicitObjectWrapper; } //_.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. */ flow(...funcs: Function[]): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.flow */ flow(...funcs: Function[]): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.flow */ flow(...funcs: Function[]): LoDashExplicitObjectWrapper; } //_.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(...funcs: Function[]): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.flowRight */ flowRight(...funcs: Function[]): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.flowRight */ flowRight(...funcs: Function[]): LoDashExplicitObjectWrapper; } //_.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: { (func: T, resolver?: Function): T & MemoizedFunction; Cache: MapCache; } } interface LoDashImplicitObjectWrapper { /** * @see _.memoize */ memoize(resolver?: Function): LoDashImplicitObjectWrapper; } //_.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( func: T, ...transforms: Function[] ): TResult; /** * @see _.overArgs */ overArgs( func: T, transforms: Function[] ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.overArgs */ overArgs(...transforms: Function[]): LoDashImplicitObjectWrapper; /** * @see _.overArgs */ overArgs(transforms: Function[]): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.overArgs */ overArgs(...transforms: Function[]): LoDashExplicitObjectWrapper; /** * @see _.overArgs */ overArgs(transforms: Function[]): LoDashExplicitObjectWrapper; } //_.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(predicate: T): (...args: any[]) => boolean; /** * @see _.negate */ negate(predicate: T): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.negate */ negate(): LoDashImplicitObjectWrapper<(...args: any[]) => boolean>; /** * @see _.negate */ negate(): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.negate */ negate(): LoDashExplicitObjectWrapper<(...args: any[]) => boolean>; /** * @see _.negate */ negate(): LoDashExplicitObjectWrapper; } //_.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(func: T): T; } interface LoDashImplicitObjectWrapper { /** * @see _.once */ once(): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.once */ once(): LoDashExplicitObjectWrapper; } //_.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; } interface Function1 { (t1: T1): R; } interface Function2 { (t1: T1, t2: T2): R; } interface Function3 { (t1: T1, t2: T2, t3: T3): R; } interface Function4 { (t1: T1, t2: T2, t3: T3, t4: T4): R; } interface Partial { // arity 0 (func: Function0): Function0; // arity 1 (func: Function1): Function1; (func: Function1, arg1: T1): Function0; // arity 2 (func: Function2): Function2; (func: Function2, arg1: T1): Function1< T2, R>; (func: Function2, plc1: PH, arg2: T2): Function1; (func: Function2, arg1: T1, arg2: T2): Function0< R>; // arity 3 (func: Function3): Function3; (func: Function3, arg1: T1): Function2< T2, T3, R>; (func: Function3, plc1: PH, arg2: T2): Function2; (func: Function3, arg1: T1, arg2: T2): Function1< T3, R>; (func: Function3, plc1: PH, plc2: PH, arg3: T3): Function2; (func: Function3, arg1: T1, plc2: PH, arg3: T3): Function1< T2, R>; (func: Function3, plc1: PH, arg2: T2, arg3: T3): Function1; (func: Function3, arg1: T1, arg2: T2, arg3: T3): Function0< R>; // arity 4 (func: Function4): Function4; (func: Function4, arg1: T1): Function3< T2, T3, T4, R>; (func: Function4, plc1: PH, arg2: T2): Function3; (func: Function4, arg1: T1, arg2: T2): Function2< T3, T4, R>; (func: Function4, plc1: PH, plc2: PH, arg3: T3): Function3; (func: Function4, arg1: T1, plc2: PH, arg3: T3): Function2< T2, T4, R>; (func: Function4, plc1: PH, arg2: T2, arg3: T3): Function2; (func: Function4, arg1: T1, arg2: T2, arg3: T3): Function1< T4, R>; (func: Function4, plc1: PH, plc2: PH, plc3: PH, arg4: T4): Function3; (func: Function4, arg1: T1, plc2: PH, plc3: PH, arg4: T4): Function2< T2, T3, R>; (func: Function4, plc1: PH, arg2: T2, plc3: PH, arg4: T4): Function2; (func: Function4, arg1: T1, arg2: T2, plc3: PH, arg4: T4): Function1< T3, R>; (func: Function4, plc1: PH, plc2: PH, arg3: T3, arg4: T4): Function2; (func: Function4, arg1: T1, plc2: PH, arg3: T3, arg4: T4): Function1< T2, R>; (func: Function4, plc1: PH, arg2: T2, arg3: T3, arg4: T4): Function1; (func: Function4, 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 (func: Function0): Function0; // arity 1 (func: Function1): Function1; (func: Function1, arg1: T1): Function0; // arity 2 (func: Function2): Function2; (func: Function2, arg1: T1, plc2: PH): Function1< T2, R>; (func: Function2, arg2: T2): Function1; (func: Function2, arg1: T1, arg2: T2): Function0< R>; // arity 3 (func: Function3): Function3; (func: Function3, arg1: T1, plc2: PH, plc3: PH): Function2< T2, T3, R>; (func: Function3, arg2: T2, plc3: PH): Function2; (func: Function3, arg1: T1, arg2: T2, plc3: PH): Function1< T3, R>; (func: Function3, arg3: T3): Function2; (func: Function3, arg1: T1, plc2: PH, arg3: T3): Function1< T2, R>; (func: Function3, arg2: T2, arg3: T3): Function1; (func: Function3, arg1: T1, arg2: T2, arg3: T3): Function0< R>; // arity 4 (func: Function4): Function4; (func: Function4, arg1: T1, plc2: PH, plc3: PH, plc4: PH): Function3< T2, T3, T4, R>; (func: Function4, arg2: T2, plc3: PH, plc4: PH): Function3; (func: Function4, arg1: T1, arg2: T2, plc3: PH, plc4: PH): Function2< T3, T4, R>; (func: Function4, arg3: T3, plc4: PH): Function3; (func: Function4, arg1: T1, plc2: PH, arg3: T3, plc4: PH): Function2< T2, T4, R>; (func: Function4, arg2: T2, arg3: T3, plc4: PH): Function2; (func: Function4, arg1: T1, arg2: T2, arg3: T3, plc4: PH): Function1< T4, R>; (func: Function4, arg4: T4): Function3; (func: Function4, arg1: T1, plc2: PH, plc3: PH, arg4: T4): Function2< T2, T3, R>; (func: Function4, arg2: T2, plc3: PH, arg4: T4): Function2; (func: Function4, arg1: T1, arg2: T2, plc3: PH, arg4: T4): Function1< T3, R>; (func: Function4, arg3: T3, arg4: T4): Function2; (func: Function4, arg1: T1, plc2: PH, arg3: T3, arg4: T4): Function1< T2, R>; (func: Function4, arg2: T2, arg3: T3, arg4: T4): Function1; (func: Function4, 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(func: Function, indexes: number[]): TResult; /** * @see _.rearg */ rearg(func: Function, ...indexes: number[]): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.rearg */ rearg(indexes: number[]): LoDashImplicitObjectWrapper; /** * @see _.rearg */ rearg(...indexes: number[]): LoDashImplicitObjectWrapper; } //_.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( func: Function, start?: number ): TResult; /** * @see _.rest */ rest( func: TFunc, start?: number ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.rest */ rest(start?: number): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.rest */ rest(start?: number): LoDashExplicitObjectWrapper; } //_.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(func: F): T; /** * @see _.spread */ spread(func: Function): T; } interface LoDashImplicitObjectWrapper { /** * @see _.spread */ spread(): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.spread */ spread(): LoDashExplicitObjectWrapper; } //_.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. 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( func: T, wait?: number, options?: ThrottleSettings ): T & Cancelable; } interface LoDashImplicitObjectWrapper { /** * @see _.throttle */ throttle( wait?: number, options?: ThrottleSettings ): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.throttle */ throttle( wait?: number, options?: ThrottleSettings ): LoDashExplicitObjectWrapper; } //_.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(func: T): T; } interface LoDashImplicitObjectWrapper { /** * @see _.unary */ unary(): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.unary */ unary(): LoDashExplicitObjectWrapper; } //_.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( value: V, wrapper: W ): R; /** * @see _.wrap */ wrap( value: V, wrapper: Function ): R; /** * @see _.wrap */ wrap( value: any, wrapper: Function ): R; } interface LoDashImplicitWrapper { /** * @see _.wrap */ wrap(wrapper: W): LoDashImplicitObjectWrapper; /** * @see _.wrap */ wrap(wrapper: Function): LoDashImplicitObjectWrapper; } interface LoDashImplicitArrayWrapper { /** * @see _.wrap */ wrap(wrapper: W): LoDashImplicitObjectWrapper; /** * @see _.wrap */ wrap(wrapper: Function): LoDashImplicitObjectWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.wrap */ wrap(wrapper: W): LoDashImplicitObjectWrapper; /** * @see _.wrap */ wrap(wrapper: Function): LoDashImplicitObjectWrapper; } interface LoDashExplicitWrapper { /** * @see _.wrap */ wrap(wrapper: W): LoDashExplicitObjectWrapper; /** * @see _.wrap */ wrap(wrapper: Function): LoDashExplicitObjectWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.wrap */ wrap(wrapper: W): LoDashExplicitObjectWrapper; /** * @see _.wrap */ wrap(wrapper: Function): LoDashExplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.wrap */ wrap(wrapper: W): LoDashExplicitObjectWrapper; /** * @see _.wrap */ wrap(wrapper: Function): LoDashExplicitObjectWrapper; } /******** * Lang * ********/ //_.clone interface LoDashStatic { /** * Creates a shallow clone of `value`. * * **Note:** This method is loosely based on the * [structured clone algorithm](https://mdn.io/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. * * @static * @memberOf _ * @category Lang * @param {*} value The value to clone. * @returns {*} Returns the cloned value. * @example * * var objects = [{ 'a': 1 }, { 'b': 2 }]; * * var shallow = _.clone(objects); * console.log(shallow[0] === objects[0]); * // => true */ clone(value: T): T; } interface LoDashImplicitWrapper { /** * @see _.clone */ clone(): T; } interface LoDashImplicitArrayWrapper { /** * @see _.clone */ clone(): T[]; } interface LoDashImplicitObjectWrapper { /** * @see _.clone */ clone(): T; } //_.cloneDeep interface LoDashStatic { /** * This method is like `_.clone` except that it recursively clones `value`. * * @static * @memberOf _ * @category Lang * @param {*} value The value to recursively clone. * @returns {*} Returns the deep cloned value. * @example * * var objects = [{ 'a': 1 }, { 'b': 2 }]; * * var deep = _.cloneDeep(objects); * console.log(deep[0] === objects[0]); * // => false */ cloneDeep(value: T): T; } interface LoDashImplicitWrapper { /** * @see _.cloneDeep */ cloneDeep(): T; } interface LoDashImplicitArrayWrapper { /** * @see _.cloneDeep */ cloneDeep(): T[]; } interface LoDashImplicitObjectWrapper { /** * @see _.cloneDeep */ cloneDeep(): T; } //_.cloneWith interface LoDashStatic { /** * Creates a shallow clone of `value`. * * **Note:** This method is loosely based on the * [structured clone algorithm](https://mdn.io/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. * * @static * @memberOf _ * @category Lang * @param {*} value The value to clone. * @returns {*} Returns the cloned value. * @example * * var objects = [{ 'a': 1 }, { 'b': 2 }]; * * var shallow = _.clone(objects); * console.log(shallow[0] === objects[0]); * // => true */ clone( value: T, customizer: (value: any) => any): T; } interface LoDashImplicitWrapper { /** * @see _.clone */ clone(customizer: (value: any) => any): T; } interface LoDashImplicitArrayWrapper { /** * @see _.clone */ clone(customizer: (value: any) => any): T[]; } interface LoDashImplicitObjectWrapper { /** * @see _.clone */ clone(customizer: (value: any) => any): T; } //_.cloneDeepWith interface LoDashStatic { /** * Creates a deep clone of value. If customizer is provided it’s invoked to produce the cloned values. If * customizer returns undefined cloning is handled by the method instead. The customizer is bound to thisArg * and invoked with up to three argument; (value [, index|key, object]). * Note: This method is loosely based on the structured clone algorithm. The enumerable properties of arguments * objects and objects created by constructors other than Object are cloned to plain Object objects. An empty * object is returned for uncloneable values such as functions, DOM nodes, Maps, Sets, and WeakMaps. * @param value The value to deep clone. * @param customizer The function to customize cloning values. * @param thisArg The this binding of customizer. * @return Returns the deep cloned value. */ cloneDeep( value: T, customizer: (value: any) => any): T; } interface LoDashImplicitWrapper { /** * @see _.cloneDeep */ cloneDeep(customizer: (value: any) => any): T; } interface LoDashImplicitArrayWrapper { /** * @see _.cloneDeep */ cloneDeep(customizer: (value: any) => any): T[]; } interface LoDashImplicitObjectWrapper { /** * @see _.cloneDeep */ cloneDeep(customizer: (value: any) => any): T; } //_.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 { /** * @see _.isEqual */ eq( other: any ): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.isEqual */ eq( other: any ): LoDashExplicitWrapper; } //_.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 { /** * @see _.gt */ gt(other: any): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.gt */ gt(other: any): LoDashExplicitWrapper; } //_.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 { /** * @see _.gte */ gte(other: any): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.gte */ gte(other: any): LoDashExplicitWrapper; } //_.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 { /** * @see _.isArguments */ isArguments(): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.isArguments */ isArguments(): LoDashExplicitWrapper; } //_.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(value?: any): value is T[]; } interface LoDashImplicitWrapperBase { /** * @see _.isArray */ isArray(): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.isArray */ isArray(): LoDashExplicitWrapper; } //_.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(value?: any): value is T[]; } interface LoDashImplicitWrapperBase { /** * @see _.isArrayLike */ isArrayLike(): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.isArrayLike */ isArrayLike(): LoDashExplicitWrapper; } //_.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(value?: any): value is T[]; } interface LoDashImplicitWrapperBase { /** * @see _.isArrayLikeObject */ isArrayLikeObject(): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.isArrayLikeObject */ isArrayLikeObject(): LoDashExplicitWrapper; } //_.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 { /** * @see _.isBoolean */ isBoolean(): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.isBoolean */ isBoolean(): LoDashExplicitWrapper; } //_.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 { /** * @see _.isDate */ isDate(): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.isDate */ isDate(): LoDashExplicitWrapper; } //_.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 { /** * @see _.isElement */ isElement(): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.isElement */ isElement(): LoDashExplicitWrapper; } //_.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 { /** * @see _.isEmpty */ isEmpty(): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.isEmpty */ isEmpty(): LoDashExplicitWrapper; } //_.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 { /** * @see _.isEqual */ isEqual( other: any ): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.isEqual */ isEqual( other: any ): LoDashExplicitWrapper; } // _.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 { /** * @see _.isEqualWith */ isEqualWith( other: any, customizer: IsEqualCustomizer ): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.isEqualWith */ isEqualWith( other: any, customizer: IsEqualCustomizer ): LoDashExplicitWrapper; } //_.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 { /** * @see _.isError */ isError(): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.isError */ isError(): LoDashExplicitWrapper; } //_.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 { /** * @see _.isFinite */ isFinite(): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.isFinite */ isFinite(): LoDashExplicitWrapper; } //_.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 { /** * @see _.isFunction */ isFunction(): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.isFunction */ isFunction(): LoDashExplicitWrapper; } //_.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 { /** * @see _.isInteger */ isInteger(): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.isInteger */ isInteger(): LoDashExplicitWrapper; } //_.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 { /** * @see _.isLength */ isLength(): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.isLength */ isLength(): LoDashExplicitWrapper; } //_.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 { /** * @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 { /** * @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 { /** * @see _.isNaN */ isNaN(): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.isNaN */ isNaN(): LoDashExplicitWrapper; } //_.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 { /** * see _.isNative */ isNative(): boolean; } interface LoDashExplicitWrapperBase { /** * see _.isNative */ isNative(): LoDashExplicitWrapper; } //_.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 { /** * see _.isNil */ isNil(): boolean; } interface LoDashExplicitWrapperBase { /** * see _.isNil */ isNil(): LoDashExplicitWrapper; } //_.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 { /** * see _.isNull */ isNull(): boolean; } interface LoDashExplicitWrapperBase { /** * see _.isNull */ isNull(): LoDashExplicitWrapper; } //_.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 { /** * see _.isNumber */ isNumber(): boolean; } interface LoDashExplicitWrapperBase { /** * see _.isNumber */ isNumber(): LoDashExplicitWrapper; } //_.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 { /** * see _.isObject */ isObject(): boolean; } interface LoDashExplicitWrapperBase { /** * see _.isObject */ isObject(): LoDashExplicitWrapper; } //_.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 { /** * see _.isObjectLike */ isObjectLike(): boolean; } interface LoDashExplicitWrapperBase { /** * see _.isObjectLike */ isObjectLike(): LoDashExplicitWrapper; } //_.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 { /** * see _.isPlainObject */ isPlainObject(): boolean; } interface LoDashExplicitWrapperBase { /** * see _.isPlainObject */ isPlainObject(): LoDashExplicitWrapper; } //_.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 { /** * see _.isRegExp */ isRegExp(): boolean; } interface LoDashExplicitWrapperBase { /** * see _.isRegExp */ isRegExp(): LoDashExplicitWrapper; } //_.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 { /** * see _.isSafeInteger */ isSafeInteger(): boolean; } interface LoDashExplicitWrapperBase { /** * see _.isSafeInteger */ isSafeInteger(): LoDashExplicitWrapper; } //_.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 { /** * see _.isString */ isString(): boolean; } interface LoDashExplicitWrapperBase { /** * see _.isString */ isString(): LoDashExplicitWrapper; } //_.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 { /** * see _.isSymbol */ isSymbol(): boolean; } interface LoDashExplicitWrapperBase { /** * see _.isSymbol */ isSymbol(): LoDashExplicitWrapper; } //_.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 { /** * see _.isTypedArray */ isTypedArray(): boolean; } interface LoDashExplicitWrapperBase { /** * see _.isTypedArray */ isTypedArray(): LoDashExplicitWrapper; } //_.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 { /** * see _.isUndefined */ isUndefined(): boolean; } interface LoDashExplicitWrapperBase { /** * see _.isUndefined */ isUndefined(): LoDashExplicitWrapper; } //_.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 { /** * @see _.lt */ lt(other: any): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.lt */ lt(other: any): LoDashExplicitWrapper; } //_.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 { /** * @see _.lte */ lte(other: any): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.lte */ lte(other: any): LoDashExplicitWrapper; } //_.toArray interface LoDashStatic { /** * Converts value to an array. * * @param value The value to convert. * @return Returns the converted array. */ toArray(value: List|Dictionary|NumericDictionary): T[]; /** * @see _.toArray */ toArray(value: TValue): TResult[]; /** * @see _.toArray */ toArray(value?: any): TResult[]; } interface LoDashImplicitWrapper { /** * @see _.toArray */ toArray(): LoDashImplicitArrayWrapper; } interface LoDashImplicitArrayWrapper { /** * @see _.toArray */ toArray(): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.toArray */ toArray(): LoDashImplicitArrayWrapper; } interface LoDashExplicitWrapper { /** * @see _.toArray */ toArray(): LoDashExplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.toArray */ toArray(): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.toArray */ toArray(): LoDashExplicitArrayWrapper; } //_.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(value?: any): TResult; } interface LoDashImplicitWrapperBase { /** * @see _.toPlainObject */ toPlainObject(): LoDashImplicitObjectWrapper; } //_.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 { /** * @see _.toInteger */ toInteger(): LoDashImplicitWrapper; } interface LoDashExplicitWrapperBase { /** * @see _.toInteger */ toInteger(): LoDashExplicitWrapper; } //_.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 { /** * @see _.toLength */ toLength(): LoDashImplicitWrapper; } interface LoDashExplicitWrapperBase { /** * @see _.toLength */ toLength(): LoDashExplicitWrapper; } //_.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 { /** * @see _.toNumber */ toNumber(): LoDashImplicitWrapper; } interface LoDashExplicitWrapperBase { /** * @see _.toNumber */ toNumber(): LoDashExplicitWrapper; } //_.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 { /** * @see _.toSafeInteger */ toSafeInteger(): LoDashImplicitWrapper; } interface LoDashExplicitWrapperBase { /** * @see _.toSafeInteger */ toSafeInteger(): LoDashExplicitWrapper; } //_.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 { /** * @see _.add */ add(addend: number): number; } interface LoDashExplicitWrapper { /** * @see _.add */ add(addend: number): LoDashExplicitWrapper; } //_.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 { /** * @see _.ceil */ ceil(precision?: number): number; } interface LoDashExplicitWrapper { /** * @see _.ceil */ ceil(precision?: number): LoDashExplicitWrapper; } //_.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 { /** * @see _.floor */ floor(precision?: number): number; } interface LoDashExplicitWrapper { /** * @see _.floor */ floor(precision?: number): LoDashExplicitWrapper; } //_.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( collection: List ): T; } interface LoDashImplicitArrayWrapper { /** * @see _.max */ max(): T; } interface LoDashImplicitObjectWrapper { /** * @see _.max */ max(): 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( collection: List, iteratee?: ListIterator ): T; /** * @see _.maxBy */ maxBy( collection: Dictionary, iteratee?: DictionaryIterator ): T; /** * @see _.maxBy */ maxBy( collection: List|Dictionary, iteratee?: string ): T; /** * @see _.maxBy */ maxBy( collection: List|Dictionary, whereValue?: TObject ): T; } interface LoDashImplicitArrayWrapper { /** * @see _.maxBy */ maxBy( iteratee?: ListIterator ): T; /** * @see _.maxBy */ maxBy( iteratee?: string ): T; /** * @see _.maxBy */ maxBy( whereValue?: TObject ): T; } interface LoDashImplicitObjectWrapper { /** * @see _.maxBy */ maxBy( iteratee?: ListIterator|DictionaryIterator, thisArg?: any ): T; /** * @see _.maxBy */ maxBy( iteratee?: string, thisArg?: any ): T; /** * @see _.maxBy */ maxBy( 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( collection: List ): number; } interface LoDashImplicitArrayWrapper { /** * @see _.mean */ mean(): 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( collection: List ): T; } interface LoDashImplicitArrayWrapper { /** * @see _.min */ min(): T; } interface LoDashImplicitObjectWrapper { /** * @see _.min */ min(): 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( collection: List, iteratee?: ListIterator ): T; /** * @see _.minBy */ minBy( collection: Dictionary, iteratee?: DictionaryIterator ): T; /** * @see _.minBy */ minBy( collection: List|Dictionary, iteratee?: string ): T; /** * @see _.minBy */ minBy( collection: List|Dictionary, whereValue?: TObject ): T; } interface LoDashImplicitArrayWrapper { /** * @see _.minBy */ minBy( iteratee?: ListIterator ): T; /** * @see _.minBy */ minBy( iteratee?: string ): T; /** * @see _.minBy */ minBy( whereValue?: TObject ): T; } interface LoDashImplicitObjectWrapper { /** * @see _.minBy */ minBy( iteratee?: ListIterator|DictionaryIterator, thisArg?: any ): T; /** * @see _.minBy */ minBy( iteratee?: string, thisArg?: any ): T; /** * @see _.minBy */ minBy( 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 { /** * @see _.round */ round(precision?: number): number; } interface LoDashExplicitWrapper { /** * @see _.round */ round(precision?: number): LoDashExplicitWrapper; } //_.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(collection: List): number; /** * @see _.sum */ sum(collection: List|Dictionary): number; } interface LoDashImplicitArrayWrapper { /** * @see _.sum */ sum(): number; } interface LoDashImplicitObjectWrapper { /** * @see _.sum **/ sum(): number; /** * @see _.sum */ sum(): number; } interface LoDashExplicitArrayWrapper { /** * @see _.sum */ sum(): LoDashExplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.sum */ sum(): LoDashExplicitWrapper; /** * @see _.sum */ sum(): LoDashExplicitWrapper; } //_.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( collection: List, iteratee: ListIterator ): number; /** * @see _.sumBy **/ sumBy( collection: Dictionary, iteratee: DictionaryIterator ): number; /** * @see _.sumBy */ sumBy( collection: List|Dictionary, iteratee: string ): number; /** * @see _.sumBy */ sumBy(collection: List|Dictionary): number; /** * @see _.sumBy */ sumBy(collection: List|Dictionary): number; } interface LoDashImplicitArrayWrapper { /** * @see _.sumBy */ sumBy( iteratee: ListIterator ): number; /** * @see _.sumBy */ sumBy(iteratee: string): number; /** * @see _.sumBy */ sumBy(): number; } interface LoDashImplicitObjectWrapper { /** * @see _.sumBy **/ sumBy( iteratee: ListIterator|DictionaryIterator ): number; /** * @see _.sumBy */ sumBy(iteratee: string): number; /** * @see _.sumBy */ sumBy(): number; } interface LoDashExplicitArrayWrapper { /** * @see _.sumBy */ sumBy( iteratee: ListIterator ): LoDashExplicitWrapper; /** * @see _.sumBy */ sumBy(iteratee: string): LoDashExplicitWrapper; /** * @see _.sumBy */ sumBy(): LoDashExplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.sumBy */ sumBy( iteratee: ListIterator|DictionaryIterator ): LoDashExplicitWrapper; /** * @see _.sumBy */ sumBy(iteratee: string): LoDashExplicitWrapper; /** * @see _.sumBy */ sumBy(): LoDashExplicitWrapper; } /********** * 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 { /** * @see _.subtract */ subtract( subtrahend: number ): number; } interface LoDashExplicitWrapper { /** * @see _.subtract */ subtract( subtrahend: number ): LoDashExplicitWrapper; } //_.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 { /** * @see _.clamp */ clamp( lower: number, upper: number ): number; } interface LoDashExplicitWrapper { /** * @see _.clamp */ clamp( lower: number, upper: number ): LoDashExplicitWrapper; } //_.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 { /** * @see _.inRange */ inRange( start: number, end: number ): boolean; /** * @see _.inRange */ inRange(end: number): boolean; } interface LoDashExplicitWrapper { /** * @see _.inRange */ inRange( start: number, end: number ): LoDashExplicitWrapper; /** * @see _.inRange */ inRange(end: number): LoDashExplicitWrapper; } //_.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 { /** * @see _.random */ random( max?: number, floating?: boolean ): number; /** * @see _.random */ random(floating?: boolean): number; } interface LoDashExplicitWrapper { /** * @see _.random */ random( max?: number, floating?: boolean ): LoDashExplicitWrapper; /** * @see _.random */ random(floating?: boolean): LoDashExplicitWrapper; } /********** * 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( object: TObject, source: TSource ): TResult; /** * @see assign */ assign( object: TObject, source1: TSource1, source2: TSource2 ): TResult; /** * @see assign */ assign( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3 ): TResult; /** * @see assign */ assign ( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4 ): TResult; /** * @see _.assign */ assign(object: TObject): TObject; /** * @see _.assign */ assign( object: TObject, ...otherArgs: any[] ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.assign */ assign( source: TSource ): LoDashImplicitObjectWrapper; /** * @see assign */ assign( source1: TSource1, source2: TSource2 ): LoDashImplicitObjectWrapper; /** * @see assign */ assign( source1: TSource1, source2: TSource2, source3: TSource3 ): LoDashImplicitObjectWrapper; /** * @see assign */ assign( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4 ): LoDashImplicitObjectWrapper; /** * @see _.assign */ assign(): LoDashImplicitObjectWrapper; /** * @see _.assign */ assign(...otherArgs: any[]): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.assign */ assign( source: TSource ): LoDashExplicitObjectWrapper; /** * @see assign */ assign( source1: TSource1, source2: TSource2 ): LoDashExplicitObjectWrapper; /** * @see assign */ assign( source1: TSource1, source2: TSource2, source3: TSource3 ): LoDashExplicitObjectWrapper; /** * @see assign */ assign( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4 ): LoDashExplicitObjectWrapper; /** * @see _.assign */ assign(): LoDashExplicitObjectWrapper; /** * @see _.assign */ assign(...otherArgs: any[]): LoDashExplicitObjectWrapper; } //_.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( object: TObject, source: TSource, customizer: AssignCustomizer ): TResult; /** * @see assignWith */ assignWith( object: TObject, source1: TSource1, source2: TSource2, customizer: AssignCustomizer ): TResult; /** * @see assignWith */ assignWith( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, customizer: AssignCustomizer ): TResult; /** * @see assignWith */ assignWith ( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: AssignCustomizer ): TResult; /** * @see _.assignWith */ assignWith(object: TObject): TObject; /** * @see _.assignWith */ assignWith( object: TObject, ...otherArgs: any[] ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.assignWith */ assignWith( source: TSource, customizer: AssignCustomizer ): LoDashImplicitObjectWrapper; /** * @see assignWith */ assignWith( source1: TSource1, source2: TSource2, customizer: AssignCustomizer ): LoDashImplicitObjectWrapper; /** * @see assignWith */ assignWith( source1: TSource1, source2: TSource2, source3: TSource3, customizer: AssignCustomizer ): LoDashImplicitObjectWrapper; /** * @see assignWith */ assignWith( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: AssignCustomizer ): LoDashImplicitObjectWrapper; /** * @see _.assignWith */ assignWith(): LoDashImplicitObjectWrapper; /** * @see _.assignWith */ assignWith(...otherArgs: any[]): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.assignWith */ assignWith( source: TSource, customizer: AssignCustomizer ): LoDashExplicitObjectWrapper; /** * @see assignWith */ assignWith( source1: TSource1, source2: TSource2, customizer: AssignCustomizer ): LoDashExplicitObjectWrapper; /** * @see assignWith */ assignWith( source1: TSource1, source2: TSource2, source3: TSource3, customizer: AssignCustomizer ): LoDashExplicitObjectWrapper; /** * @see assignWith */ assignWith( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: AssignCustomizer ): LoDashExplicitObjectWrapper; /** * @see _.assignWith */ assignWith(): LoDashExplicitObjectWrapper; /** * @see _.assignWith */ assignWith(...otherArgs: any[]): LoDashExplicitObjectWrapper; } //_.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( object: TObject, source: TSource ): TResult; /** * @see assignIn */ assignIn( object: TObject, source1: TSource1, source2: TSource2 ): TResult; /** * @see assignIn */ assignIn( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3 ): TResult; /** * @see assignIn */ assignIn ( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4 ): TResult; /** * @see _.assignIn */ assignIn(object: TObject): TObject; /** * @see _.assignIn */ assignIn( object: TObject, ...otherArgs: any[] ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.assignIn */ assignIn( source: TSource ): LoDashImplicitObjectWrapper; /** * @see assignIn */ assignIn( source1: TSource1, source2: TSource2 ): LoDashImplicitObjectWrapper; /** * @see assignIn */ assignIn( source1: TSource1, source2: TSource2, source3: TSource3 ): LoDashImplicitObjectWrapper; /** * @see assignIn */ assignIn( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4 ): LoDashImplicitObjectWrapper; /** * @see _.assignIn */ assignIn(): LoDashImplicitObjectWrapper; /** * @see _.assignIn */ assignIn(...otherArgs: any[]): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.assignIn */ assignIn( source: TSource ): LoDashExplicitObjectWrapper; /** * @see assignIn */ assignIn( source1: TSource1, source2: TSource2 ): LoDashExplicitObjectWrapper; /** * @see assignIn */ assignIn( source1: TSource1, source2: TSource2, source3: TSource3 ): LoDashExplicitObjectWrapper; /** * @see assignIn */ assignIn( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4 ): LoDashExplicitObjectWrapper; /** * @see _.assignIn */ assignIn(): LoDashExplicitObjectWrapper; /** * @see _.assignIn */ assignIn(...otherArgs: any[]): LoDashExplicitObjectWrapper; } //_.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( object: TObject, source: TSource, customizer: AssignCustomizer ): TResult; /** * @see assignInWith */ assignInWith( object: TObject, source1: TSource1, source2: TSource2, customizer: AssignCustomizer ): TResult; /** * @see assignInWith */ assignInWith( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, customizer: AssignCustomizer ): TResult; /** * @see assignInWith */ assignInWith ( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: AssignCustomizer ): TResult; /** * @see _.assignInWith */ assignInWith(object: TObject): TObject; /** * @see _.assignInWith */ assignInWith( object: TObject, ...otherArgs: any[] ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.assignInWith */ assignInWith( source: TSource, customizer: AssignCustomizer ): LoDashImplicitObjectWrapper; /** * @see assignInWith */ assignInWith( source1: TSource1, source2: TSource2, customizer: AssignCustomizer ): LoDashImplicitObjectWrapper; /** * @see assignInWith */ assignInWith( source1: TSource1, source2: TSource2, source3: TSource3, customizer: AssignCustomizer ): LoDashImplicitObjectWrapper; /** * @see assignInWith */ assignInWith( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: AssignCustomizer ): LoDashImplicitObjectWrapper; /** * @see _.assignInWith */ assignInWith(): LoDashImplicitObjectWrapper; /** * @see _.assignInWith */ assignInWith(...otherArgs: any[]): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.assignInWith */ assignInWith( source: TSource, customizer: AssignCustomizer ): LoDashExplicitObjectWrapper; /** * @see assignInWith */ assignInWith( source1: TSource1, source2: TSource2, customizer: AssignCustomizer ): LoDashExplicitObjectWrapper; /** * @see assignInWith */ assignInWith( source1: TSource1, source2: TSource2, source3: TSource3, customizer: AssignCustomizer ): LoDashExplicitObjectWrapper; /** * @see assignInWith */ assignInWith( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: AssignCustomizer ): LoDashExplicitObjectWrapper; /** * @see _.assignInWith */ assignInWith(): LoDashExplicitObjectWrapper; /** * @see _.assignInWith */ assignInWith(...otherArgs: any[]): LoDashExplicitObjectWrapper; } //_.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( prototype: T, properties?: U ): T & U; } interface LoDashImplicitObjectWrapper { /** * @see _.create */ create(properties?: U): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.create */ create(properties?: U): LoDashExplicitObjectWrapper; } //_.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( object: Obj, ...sources: {}[] ): TResult; /** * @see _.defaults */ defaults( object: Obj, source1: S1, ...sources: {}[] ): TResult; /** * @see _.defaults */ defaults( object: Obj, source1: S1, source2: S2, ...sources: {}[] ): TResult; /** * @see _.defaults */ defaults( object: Obj, source1: S1, source2: S2, source3: S3, ...sources: {}[] ): TResult; /** * @see _.defaults */ defaults( object: Obj, source1: S1, source2: S2, source3: S3, source4: S4, ...sources: {}[] ): TResult; /** * @see _.defaults */ defaults( object: {}, ...sources: {}[] ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.defaults */ defaults( source1: S1, ...sources: {}[] ): LoDashImplicitObjectWrapper; /** * @see _.defaults */ defaults( source1: S1, source2: S2, ...sources: {}[] ): LoDashImplicitObjectWrapper; /** * @see _.defaults */ defaults( source1: S1, source2: S2, source3: S3, ...sources: {}[] ): LoDashImplicitObjectWrapper; /** * @see _.defaults */ defaults( source1: S1, source2: S2, source3: S3, source4: S4, ...sources: {}[] ): LoDashImplicitObjectWrapper; /** * @see _.defaults */ defaults(): LoDashImplicitObjectWrapper; /** * @see _.defaults */ defaults(...sources: {}[]): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.defaults */ defaults( source1: S1, ...sources: {}[] ): LoDashExplicitObjectWrapper; /** * @see _.defaults */ defaults( source1: S1, source2: S2, ...sources: {}[] ): LoDashExplicitObjectWrapper; /** * @see _.defaults */ defaults( source1: S1, source2: S2, source3: S3, ...sources: {}[] ): LoDashExplicitObjectWrapper; /** * @see _.defaults */ defaults( source1: S1, source2: S2, source3: S3, source4: S4, ...sources: {}[] ): LoDashExplicitObjectWrapper; /** * @see _.defaults */ defaults(): LoDashExplicitObjectWrapper; /** * @see _.defaults */ defaults(...sources: {}[]): LoDashExplicitObjectWrapper; } //_.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( object: T, ...sources: any[]): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.defaultsDeep **/ defaultsDeep(...sources: any[]): LoDashImplicitObjectWrapper } //_.extend interface LoDashStatic { /** * @see assign */ extend( object: TObject, source: TSource, customizer?: AssignCustomizer, thisArg?: any ): TResult; /** * @see assign */ extend( object: TObject, source1: TSource1, source2: TSource2, customizer?: AssignCustomizer, thisArg?: any ): TResult; /** * @see assign */ extend( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, customizer?: AssignCustomizer, thisArg?: any ): TResult; /** * @see assign */ extend ( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer?: AssignCustomizer, thisArg?: any ): TResult; /** * @see _.assign */ extend(object: TObject): TObject; /** * @see _.assign */ extend( object: TObject, ...otherArgs: any[] ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.assign */ extend( source: TSource, customizer?: AssignCustomizer, thisArg?: any ): LoDashImplicitObjectWrapper; /** * @see assign */ extend( source1: TSource1, source2: TSource2, customizer?: AssignCustomizer, thisArg?: any ): LoDashImplicitObjectWrapper; /** * @see assign */ extend( source1: TSource1, source2: TSource2, source3: TSource3, customizer?: AssignCustomizer, thisArg?: any ): LoDashImplicitObjectWrapper; /** * @see assign */ extend( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer?: AssignCustomizer, thisArg?: any ): LoDashImplicitObjectWrapper; /** * @see _.assign */ extend(): LoDashImplicitObjectWrapper; /** * @see _.assign */ extend(...otherArgs: any[]): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.assign */ extend( source: TSource, customizer?: AssignCustomizer, thisArg?: any ): LoDashExplicitObjectWrapper; /** * @see assign */ extend( source1: TSource1, source2: TSource2, customizer?: AssignCustomizer, thisArg?: any ): LoDashExplicitObjectWrapper; /** * @see assign */ extend( source1: TSource1, source2: TSource2, source3: TSource3, customizer?: AssignCustomizer, thisArg?: any ): LoDashExplicitObjectWrapper; /** * @see assign */ extend( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer?: AssignCustomizer, thisArg?: any ): LoDashExplicitObjectWrapper; /** * @see _.assign */ extend(): LoDashExplicitObjectWrapper; /** * @see _.assign */ extend(...otherArgs: any[]): LoDashExplicitObjectWrapper; } //_.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( object: TObject, predicate?: DictionaryIterator, thisArg?: any ): string; /** * @see _.findKey */ findKey( object: TObject, predicate?: ObjectIterator, thisArg?: any ): string; /** * @see _.findKey */ findKey( object: TObject, predicate?: string, thisArg?: any ): string; /** * @see _.findKey */ findKey, TObject>( object: TObject, predicate?: TWhere ): string; } interface LoDashImplicitObjectWrapper { /** * @see _.findKey */ findKey( predicate?: DictionaryIterator, thisArg?: any ): string; /** * @see _.findKey */ findKey( predicate?: ObjectIterator, thisArg?: any ): string; /** * @see _.findKey */ findKey( predicate?: string, thisArg?: any ): string; /** * @see _.findKey */ findKey>( predicate?: TWhere ): string; } interface LoDashExplicitObjectWrapper { /** * @see _.findKey */ findKey( predicate?: DictionaryIterator, thisArg?: any ): LoDashExplicitWrapper; /** * @see _.findKey */ findKey( predicate?: ObjectIterator, thisArg?: any ): LoDashExplicitWrapper; /** * @see _.findKey */ findKey( predicate?: string, thisArg?: any ): LoDashExplicitWrapper; /** * @see _.findKey */ findKey>( predicate?: TWhere ): LoDashExplicitWrapper; } //_.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( object: TObject, predicate?: DictionaryIterator, thisArg?: any ): string; /** * @see _.findLastKey */ findLastKey( object: TObject, predicate?: ObjectIterator, thisArg?: any ): string; /** * @see _.findLastKey */ findLastKey( object: TObject, predicate?: string, thisArg?: any ): string; /** * @see _.findLastKey */ findLastKey, TObject>( object: TObject, predicate?: TWhere ): string; } interface LoDashImplicitObjectWrapper { /** * @see _.findLastKey */ findLastKey( predicate?: DictionaryIterator, thisArg?: any ): string; /** * @see _.findLastKey */ findLastKey( predicate?: ObjectIterator, thisArg?: any ): string; /** * @see _.findLastKey */ findLastKey( predicate?: string, thisArg?: any ): string; /** * @see _.findLastKey */ findLastKey>( predicate?: TWhere ): string; } interface LoDashExplicitObjectWrapper { /** * @see _.findLastKey */ findLastKey( predicate?: DictionaryIterator, thisArg?: any ): LoDashExplicitWrapper; /** * @see _.findLastKey */ findLastKey( predicate?: ObjectIterator, thisArg?: any ): LoDashExplicitWrapper; /** * @see _.findLastKey */ findLastKey( predicate?: string, thisArg?: any ): LoDashExplicitWrapper; /** * @see _.findLastKey */ findLastKey>( predicate?: TWhere ): LoDashExplicitWrapper; } //_.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( object: Dictionary, iteratee?: DictionaryIterator, thisArg?: any ): Dictionary; /** * @see _.forIn */ forIn( object: T, iteratee?: ObjectIterator, thisArg?: any ): T; } interface LoDashImplicitObjectWrapper { /** * @see _.forIn */ forIn( iteratee?: DictionaryIterator, thisArg?: any ): _.LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.forIn */ forIn( iteratee?: DictionaryIterator, thisArg?: any ): _.LoDashExplicitObjectWrapper; } //_.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( object: Dictionary, iteratee?: DictionaryIterator, thisArg?: any ): Dictionary; /** * @see _.forInRight */ forInRight( object: T, iteratee?: ObjectIterator, thisArg?: any ): T; } interface LoDashImplicitObjectWrapper { /** * @see _.forInRight */ forInRight( iteratee?: DictionaryIterator, thisArg?: any ): _.LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.forInRight */ forInRight( iteratee?: DictionaryIterator, thisArg?: any ): _.LoDashExplicitObjectWrapper; } //_.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( object: Dictionary, iteratee?: DictionaryIterator, thisArg?: any ): Dictionary; /** * @see _.forOwn */ forOwn( object: T, iteratee?: ObjectIterator, thisArg?: any ): T; } interface LoDashImplicitObjectWrapper { /** * @see _.forOwn */ forOwn( iteratee?: DictionaryIterator, thisArg?: any ): _.LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.forOwn */ forOwn( iteratee?: DictionaryIterator, thisArg?: any ): _.LoDashExplicitObjectWrapper; } //_.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( object: Dictionary, iteratee?: DictionaryIterator, thisArg?: any ): Dictionary; /** * @see _.forOwnRight */ forOwnRight( object: T, iteratee?: ObjectIterator, thisArg?: any ): T; } interface LoDashImplicitObjectWrapper { /** * @see _.forOwnRight */ forOwnRight( iteratee?: DictionaryIterator, thisArg?: any ): _.LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.forOwnRight */ forOwnRight( iteratee?: DictionaryIterator, thisArg?: any ): _.LoDashExplicitObjectWrapper; } //_.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(object: any): string[]; } interface LoDashImplicitObjectWrapper { /** * @see _.functions */ functions(): _.LoDashImplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.functions */ functions(): _.LoDashExplicitArrayWrapper; } //_.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(object: any): string[]; } interface LoDashImplicitObjectWrapper { /** * @see _.functionsIn */ functionsIn(): _.LoDashImplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.functionsIn */ functionsIn(): _.LoDashExplicitArrayWrapper; } //_.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(object: Object, path: string|number|boolean|Array, defaultValue?:TResult ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.get **/ get(path: string|number|boolean|Array, defaultValue?: TResult ): TResult; } //_.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( object: T, path: StringRepresentable|StringRepresentable[] ): boolean; } interface LoDashImplicitObjectWrapper { /** * @see _.has */ has(path: StringRepresentable|StringRepresentable[]): boolean; } interface LoDashExplicitObjectWrapper { /** * @see _.has */ has(path: StringRepresentable|StringRepresentable[]): LoDashExplicitWrapper; } //_.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( object: T, path: StringRepresentable|StringRepresentable[] ): boolean; } interface LoDashImplicitObjectWrapper { /** * @see _.hasIn */ hasIn(path: StringRepresentable|StringRepresentable[]): boolean; } interface LoDashExplicitObjectWrapper { /** * @see _.hasIn */ hasIn(path: StringRepresentable|StringRepresentable[]): LoDashExplicitWrapper; } //_.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( object: T, multiValue?: boolean ): TResult; /** * @see _.invert */ invert( object: Object, multiValue?: boolean ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.invert */ invert(multiValue?: boolean): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.invert */ invert(multiValue?: boolean): LoDashExplicitObjectWrapper; } //_.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 { /** * @see _.keys */ keys(): LoDashImplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.keys */ keys(): LoDashExplicitArrayWrapper; } //_.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 { /** * @see _.keysIn */ keysIn(): LoDashImplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.keysIn */ keysIn(): LoDashExplicitArrayWrapper; } //_.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( object: List, iteratee?: ListIterator, thisArg?: any ): Dictionary; /** * @see _.mapKeys */ mapKeys( object: Dictionary, iteratee?: DictionaryIterator, thisArg?: any ): Dictionary; /** * @see _.mapKeys */ mapKeys( object: List|Dictionary, iteratee?: TObject ): Dictionary; /** * @see _.mapKeys */ mapKeys( object: List|Dictionary, iteratee?: string, thisArg?: any ): Dictionary; } interface LoDashImplicitArrayWrapper { /** * @see _.mapKeys */ mapKeys( iteratee?: ListIterator, thisArg?: any ): LoDashImplicitObjectWrapper>; /** * @see _.mapKeys */ mapKeys( iteratee?: TObject ): LoDashImplicitObjectWrapper>; /** * @see _.mapKeys */ mapKeys( iteratee?: string, thisArg?: any ): LoDashImplicitObjectWrapper>; } interface LoDashImplicitObjectWrapper { /** * @see _.mapKeys */ mapKeys( iteratee?: ListIterator|DictionaryIterator, thisArg?: any ): LoDashImplicitObjectWrapper>; /** * @see _.mapKeys */ mapKeys( iteratee?: TObject ): LoDashImplicitObjectWrapper>; /** * @see _.mapKeys */ mapKeys( iteratee?: string, thisArg?: any ): LoDashImplicitObjectWrapper>; } interface LoDashExplicitArrayWrapper { /** * @see _.mapKeys */ mapKeys( iteratee?: ListIterator, thisArg?: any ): LoDashExplicitObjectWrapper>; /** * @see _.mapKeys */ mapKeys( iteratee?: TObject ): LoDashExplicitObjectWrapper>; /** * @see _.mapKeys */ mapKeys( iteratee?: string, thisArg?: any ): LoDashExplicitObjectWrapper>; } interface LoDashExplicitObjectWrapper { /** * @see _.mapKeys */ mapKeys( iteratee?: ListIterator|DictionaryIterator, thisArg?: any ): LoDashExplicitObjectWrapper>; /** * @see _.mapKeys */ mapKeys( iteratee?: TObject ): LoDashExplicitObjectWrapper>; /** * @see _.mapKeys */ mapKeys( iteratee?: string, thisArg?: any ): LoDashExplicitObjectWrapper>; } //_.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(obj: Dictionary, callback: ObjectIterator, thisArg?: any): Dictionary; mapValues(obj: Dictionary, where: Dictionary): Dictionary; mapValues(obj: T, pluck: string): TMapped; mapValues(obj: T, callback: ObjectIterator, thisArg?: any): T; } interface LoDashImplicitObjectWrapper { /** * @see _.mapValues * TValue is the type of the property values of T. * TResult is the type output by the ObjectIterator function */ mapValues(callback: ObjectIterator, thisArg?: any): LoDashImplicitObjectWrapper>; /** * @see _.mapValues * TResult is the type of the property specified by pluck. * T should be a Dictionary> */ mapValues(pluck: string): LoDashImplicitObjectWrapper>; /** * @see _.mapValues * TResult is the type of the properties on the object specified by pluck. * T should be a Dictionary>> */ mapValues(pluck: string, where: Dictionary): LoDashImplicitArrayWrapper>; /** * @see _.mapValues * TResult is the type of the properties of each object in the values of T * T should be a Dictionary> */ mapValues(where: Dictionary): LoDashImplicitArrayWrapper; } //_.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( object: TObject, source: TSource ): TObject & TSource; /** * @see _.merge */ merge( object: TObject, source1: TSource1, source2: TSource2 ): TObject & TSource1 & TSource2; /** * @see _.merge */ merge( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3 ): TObject & TSource1 & TSource2 & TSource3; /** * @see _.merge */ merge( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4 ): TObject & TSource1 & TSource2 & TSource3 & TSource4; /** * @see _.merge */ merge( object: any, ...otherArgs: any[] ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.merge */ merge( source: TSource ): LoDashImplicitObjectWrapper; /** * @see _.merge */ merge( source1: TSource1, source2: TSource2 ): LoDashImplicitObjectWrapper; /** * @see _.merge */ merge( source1: TSource1, source2: TSource2, source3: TSource3 ): LoDashImplicitObjectWrapper; /** * @see _.merge */ merge( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4 ): LoDashImplicitObjectWrapper; /** * @see _.merge */ merge( ...otherArgs: any[] ): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.merge */ merge( source: TSource ): LoDashExplicitObjectWrapper; /** * @see _.merge */ merge( source1: TSource1, source2: TSource2 ): LoDashExplicitObjectWrapper; /** * @see _.merge */ merge( source1: TSource1, source2: TSource2, source3: TSource3 ): LoDashExplicitObjectWrapper; /** * @see _.merge */ merge( ): LoDashExplicitObjectWrapper; /** * @see _.merge */ merge( ...otherArgs: any[] ): LoDashExplicitObjectWrapper; } //_.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( object: TObject, source: TSource, customizer: MergeWithCustomizer ): TObject & TSource; /** * @see _.mergeWith */ mergeWith( object: TObject, source1: TSource1, source2: TSource2, customizer: MergeWithCustomizer ): TObject & TSource1 & TSource2; /** * @see _.mergeWith */ mergeWith( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, customizer: MergeWithCustomizer ): TObject & TSource1 & TSource2 & TSource3; /** * @see _.mergeWith */ mergeWith( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: MergeWithCustomizer ): TObject & TSource1 & TSource2 & TSource3 & TSource4; /** * @see _.mergeWith */ mergeWith( object: any, ...otherArgs: any[] ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.mergeWith */ mergeWith( source: TSource, customizer: MergeWithCustomizer ): LoDashImplicitObjectWrapper; /** * @see _.mergeWith */ mergeWith( source1: TSource1, source2: TSource2, customizer: MergeWithCustomizer ): LoDashImplicitObjectWrapper; /** * @see _.mergeWith */ mergeWith( source1: TSource1, source2: TSource2, source3: TSource3, customizer: MergeWithCustomizer ): LoDashImplicitObjectWrapper; /** * @see _.mergeWith */ mergeWith( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: MergeWithCustomizer ): LoDashImplicitObjectWrapper; /** * @see _.mergeWith */ mergeWith( ...otherArgs: any[] ): LoDashImplicitObjectWrapper; } //_.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( object: T, ...predicate: (StringRepresentable|StringRepresentable[])[] ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.omit */ omit( ...predicate: (StringRepresentable|StringRepresentable[])[] ): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.omit */ omit( ...predicate: (StringRepresentable|StringRepresentable[])[] ): LoDashExplicitObjectWrapper; } //_.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( object: T, predicate: ObjectIterator ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.omitBy */ omitBy( predicate: ObjectIterator ): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.omitBy */ omitBy( predicate: ObjectIterator ): LoDashExplicitObjectWrapper; } //_.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( object: T, ...predicate: (StringRepresentable|StringRepresentable[])[] ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.pick */ pick( ...predicate: (StringRepresentable|StringRepresentable[])[] ): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.pick */ pick( ...predicate: (StringRepresentable|StringRepresentable[])[] ): LoDashExplicitObjectWrapper; } //_.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( object: T, predicate: ObjectIterator ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.pickBy */ pickBy( predicate: ObjectIterator ): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.pickBy */ pickBy( predicate: ObjectIterator ): LoDashExplicitObjectWrapper; } //_.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( object: TObject, path: number|string|boolean|Array, defaultValue?: TResult ): TResult; } interface LoDashImplicitWrapperBase { /** * @see _.result */ result( path: number|string|boolean|Array, defaultValue?: TResult ): TResult; } //_.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( object: Object, path: StringRepresentable|StringRepresentable[], value: any ): TResult; /** * @see _.set */ set( object: Object, path: StringRepresentable|StringRepresentable[], value: V ): TResult; /** * @see _.set */ set( object: O, path: StringRepresentable|StringRepresentable[], value: V ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.set */ set( path: StringRepresentable|StringRepresentable[], value: any ): LoDashImplicitObjectWrapper; /** * @see _.set */ set( path: StringRepresentable|StringRepresentable[], value: V ): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.set */ set( path: StringRepresentable|StringRepresentable[], value: any ): LoDashExplicitObjectWrapper; /** * @see _.set */ set( path: StringRepresentable|StringRepresentable[], value: V ): LoDashExplicitObjectWrapper; } //_.setWith interface SetWithCustomizer { (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( object: Object, path: StringRepresentable|StringRepresentable[], value: any, customizer?: SetWithCustomizer ): TResult; /** * @see _.setWith */ setWith( object: Object, path: StringRepresentable|StringRepresentable[], value: V, customizer?: SetWithCustomizer ): TResult; /** * @see _.setWith */ setWith( object: O, path: StringRepresentable|StringRepresentable[], value: V, customizer?: SetWithCustomizer ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.setWith */ setWith( path: StringRepresentable|StringRepresentable[], value: any, customizer?: SetWithCustomizer ): LoDashImplicitObjectWrapper; /** * @see _.setWith */ setWith( path: StringRepresentable|StringRepresentable[], value: V, customizer?: SetWithCustomizer ): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.setWith */ setWith( path: StringRepresentable|StringRepresentable[], value: any, customizer?: SetWithCustomizer ): LoDashExplicitObjectWrapper; /** * @see _.setWith */ setWith( path: StringRepresentable|StringRepresentable[], value: V, customizer?: SetWithCustomizer ): LoDashExplicitObjectWrapper; } //_.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(object?: T): any[][]; toPairs(object?: T): TResult[][]; } interface LoDashImplicitObjectWrapper { /** * @see _.toPairs */ toPairs(): LoDashImplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.toPairs */ toPairs(): LoDashExplicitArrayWrapper; } //_.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(object?: T): any[][]; toPairsIn(object?: T): TResult[][]; } interface LoDashImplicitObjectWrapper { /** * @see _.toPairsIn */ toPairsIn(): LoDashImplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.toPairsIn */ toPairsIn(): LoDashExplicitArrayWrapper; } //_.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( object: T[], iteratee?: MemoVoidArrayIterator, accumulator?: TResult[], thisArg?: any ): TResult[]; /** * @see _.transform */ transform( object: T[], iteratee?: MemoVoidArrayIterator>, accumulator?: Dictionary, thisArg?: any ): Dictionary; /** * @see _.transform */ transform( object: Dictionary, iteratee?: MemoVoidDictionaryIterator>, accumulator?: Dictionary, thisArg?: any ): Dictionary; /** * @see _.transform */ transform( object: Dictionary, iteratee?: MemoVoidDictionaryIterator, accumulator?: TResult[], thisArg?: any ): TResult[]; } interface LoDashImplicitArrayWrapper { /** * @see _.transform */ transform( iteratee?: MemoVoidArrayIterator, accumulator?: TResult[], thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.transform */ transform( iteratee?: MemoVoidArrayIterator>, accumulator?: Dictionary, thisArg?: any ): LoDashImplicitObjectWrapper>; } interface LoDashImplicitObjectWrapper { /** * @see _.transform */ transform( iteratee?: MemoVoidDictionaryIterator>, accumulator?: Dictionary, thisArg?: any ): LoDashImplicitObjectWrapper>; /** * @see _.transform */ transform( iteratee?: MemoVoidDictionaryIterator, accumulator?: TResult[], thisArg?: any ): LoDashImplicitArrayWrapper; } //_.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( object: T, path: StringRepresentable|StringRepresentable[] ): boolean; } interface LoDashImplicitObjectWrapper { /** * @see _.unset */ unset(path: StringRepresentable|StringRepresentable[]): LoDashImplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.unset */ unset(path: StringRepresentable|StringRepresentable[]): LoDashExplicitWrapper; } //_.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(object?: any): T[]; } interface LoDashImplicitObjectWrapper { /** * @see _.values */ values(): LoDashImplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.values */ values(): LoDashExplicitArrayWrapper; } //_.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(object?: any): T[]; } interface LoDashImplicitObjectWrapper { /** * @see _.valuesIn */ valuesIn(): LoDashImplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.valuesIn */ valuesIn(): LoDashExplicitArrayWrapper; } /********** * 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 { /** * @see _.camelCase */ camelCase(): string; } interface LoDashExplicitWrapper { /** * @see _.camelCase */ camelCase(): LoDashExplicitWrapper; } //_.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 { /** * @see _.capitalize */ capitalize(): string; } interface LoDashExplicitWrapper { /** * @see _.capitalize */ capitalize(): LoDashExplicitWrapper; } //_.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 { /** * @see _.deburr */ deburr(): string; } interface LoDashExplicitWrapper { /** * @see _.deburr */ deburr(): LoDashExplicitWrapper; } //_.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 { /** * @see _.endsWith */ endsWith( target?: string, position?: number ): boolean; } interface LoDashExplicitWrapper { /** * @see _.endsWith */ endsWith( target?: string, position?: number ): LoDashExplicitWrapper; } // _.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 { /** * @see _.escape */ escape(): string; } interface LoDashExplicitWrapper { /** * @see _.escape */ escape(): LoDashExplicitWrapper; } // _.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 { /** * @see _.escapeRegExp */ escapeRegExp(): string; } interface LoDashExplicitWrapper { /** * @see _.escapeRegExp */ escapeRegExp(): LoDashExplicitWrapper; } //_.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 { /** * @see _.kebabCase */ kebabCase(): string; } interface LoDashExplicitWrapper { /** * @see _.kebabCase */ kebabCase(): LoDashExplicitWrapper; } //_.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 { /** * @see _.lowerCase */ lowerCase(): string; } interface LoDashExplicitWrapper { /** * @see _.lowerCase */ lowerCase(): LoDashExplicitWrapper; } //_.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 { /** * @see _.lowerFirst */ lowerFirst(): string; } interface LoDashExplicitWrapper { /** * @see _.lowerFirst */ lowerFirst(): LoDashExplicitWrapper; } //_.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 { /** * @see _.pad */ pad( length?: number, chars?: string ): string; } interface LoDashExplicitWrapper { /** * @see _.pad */ pad( length?: number, chars?: string ): LoDashExplicitWrapper; } //_.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 { /** * @see _.padEnd */ padEnd( length?: number, chars?: string ): string; } interface LoDashExplicitWrapper { /** * @see _.padEnd */ padEnd( length?: number, chars?: string ): LoDashExplicitWrapper; } //_.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 { /** * @see _.padStart */ padStart( length?: number, chars?: string ): string; } interface LoDashExplicitWrapper { /** * @see _.padStart */ padStart( length?: number, chars?: string ): LoDashExplicitWrapper; } //_.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 { /** * @see _.parseInt */ parseInt(radix?: number): number; } interface LoDashExplicitWrapper { /** * @see _.parseInt */ parseInt(radix?: number): LoDashExplicitWrapper; } //_.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 { /** * @see _.repeat */ repeat(n?: number): string; } interface LoDashExplicitWrapper { /** * @see _.repeat */ repeat(n?: number): LoDashExplicitWrapper; } //_.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 { /** * @see _.replace */ replace( pattern?: RegExp|string, replacement?: Function|string ): string; /** * @see _.replace */ replace( replacement?: Function|string ): string; } interface LoDashImplicitObjectWrapper { /** * @see _.replace */ replace( pattern?: RegExp|string, replacement?: Function|string ): string; /** * @see _.replace */ replace( replacement?: Function|string ): string; } interface LoDashExplicitWrapper { /** * @see _.replace */ replace( pattern?: RegExp|string, replacement?: Function|string ): LoDashExplicitWrapper; /** * @see _.replace */ replace( replacement?: Function|string ): LoDashExplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.replace */ replace( pattern?: RegExp|string, replacement?: Function|string ): LoDashExplicitWrapper; /** * @see _.replace */ replace( replacement?: Function|string ): LoDashExplicitWrapper; } //_.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 { /** * @see _.snakeCase */ snakeCase(): string; } interface LoDashExplicitWrapper { /** * @see _.snakeCase */ snakeCase(): LoDashExplicitWrapper; } //_.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 { /** * @see _.split */ split( separator?: RegExp|string, limit?: number ): LoDashImplicitArrayWrapper; } interface LoDashExplicitWrapper { /** * @see _.split */ split( separator?: RegExp|string, limit?: number ): LoDashExplicitArrayWrapper; } //_.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 { /** * @see _.startCase */ startCase(): string; } interface LoDashExplicitWrapper { /** * @see _.startCase */ startCase(): LoDashExplicitWrapper; } //_.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 { /** * @see _.startsWith */ startsWith( target?: string, position?: number ): boolean; } interface LoDashExplicitWrapper { /** * @see _.startsWith */ startsWith( target?: string, position?: number ): LoDashExplicitWrapper; } //_.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 { /** * @see _.template */ template(options?: TemplateOptions): TemplateExecutor; } interface LoDashExplicitWrapper { /** * @see _.template */ template(options?: TemplateOptions): LoDashExplicitObjectWrapper; } //_.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 { /** * @see _.toLower */ toLower(): string; } interface LoDashExplicitWrapper { /** * @see _.toLower */ toLower(): LoDashExplicitWrapper; } //_.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 { /** * @see _.toUpper */ toUpper(): string; } interface LoDashExplicitWrapper { /** * @see _.toUpper */ toUpper(): LoDashExplicitWrapper; } //_.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 { /** * @see _.trim */ trim(chars?: string): string; } interface LoDashExplicitWrapper { /** * @see _.trim */ trim(chars?: string): LoDashExplicitWrapper; } //_.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 { /** * @see _.trimEnd */ trimEnd(chars?: string): string; } interface LoDashExplicitWrapper { /** * @see _.trimEnd */ trimEnd(chars?: string): LoDashExplicitWrapper; } //_.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 { /** * @see _.trimStart */ trimStart(chars?: string): string; } interface LoDashExplicitWrapper { /** * @see _.trimStart */ trimStart(chars?: string): LoDashExplicitWrapper; } //_.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 { /** * @see _.truncate */ truncate(options?: TruncateOptions): string; } interface LoDashExplicitWrapper { /** * @see _.truncate */ truncate(options?: TruncateOptions): LoDashExplicitWrapper; } //_.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 { /** * @see _.unescape */ unescape(): string; } interface LoDashExplicitWrapper { /** * @see _.unescape */ unescape(): LoDashExplicitWrapper; } //_.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 { /** * @see _.upperCase */ upperCase(): string; } interface LoDashExplicitWrapper { /** * @see _.upperCase */ upperCase(): LoDashExplicitWrapper; } //_.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 { /** * @see _.upperFirst */ upperFirst(): string; } interface LoDashExplicitWrapper { /** * @see _.upperFirst */ upperFirst(): LoDashExplicitWrapper; } //_.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 { /** * @see _.words */ words(pattern?: string|RegExp): string[]; } interface LoDashExplicitWrapper { /** * @see _.words */ words(pattern?: string|RegExp): LoDashExplicitArrayWrapper; } /*********** * 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(func: (...args: any[]) => TResult, ...args: any[]): TResult|Error; } interface LoDashImplicitObjectWrapper { /** * @see _.attempt */ attempt(...args: any[]): TResult|Error; } interface LoDashExplicitObjectWrapper { /** * @see _.attempt */ attempt(...args: any[]): LoDashExplicitObjectWrapper; } //_.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(value: T): () => T; } interface LoDashImplicitWrapperBase { /** * @see _.constant */ constant(): LoDashImplicitObjectWrapper<() => TResult>; } interface LoDashExplicitWrapperBase { /** * @see _.constant */ constant(): LoDashExplicitObjectWrapper<() => TResult>; } //_.identity interface LoDashStatic { /** * This method returns the first argument provided to it. * @param value Any value. * @return Returns value. */ identity(value?: T): T; } interface LoDashImplicitWrapper { /** * @see _.identity */ identity(): T; } interface LoDashImplicitArrayWrapper { /** * @see _.identity */ identity(): T[]; } interface LoDashImplicitObjectWrapper { /** * @see _.identity */ identity(): 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( func: Function, thisArg?: any ): (...args: any[]) => TResult; /** * @see _.iteratee */ iteratee( func: string, thisArg?: any ): (object: any) => TResult; /** * @see _.iteratee */ iteratee( func: Object, thisArg?: any ): (object: any) => boolean; /** * @see _.iteratee */ iteratee(): (value: TResult) => TResult; } interface LoDashImplicitWrapper { /** * @see _.iteratee */ iteratee(thisArg?: any): LoDashImplicitObjectWrapper<(object: any) => TResult>; } interface LoDashImplicitObjectWrapper { /** * @see _.iteratee */ iteratee(thisArg?: any): LoDashImplicitObjectWrapper<(object: any) => boolean>; /** * @see _.iteratee */ iteratee(thisArg?: any): LoDashImplicitObjectWrapper<(...args: any[]) => TResult>; } interface LoDashExplicitWrapper { /** * @see _.iteratee */ iteratee(thisArg?: any): LoDashExplicitObjectWrapper<(object: any) => TResult>; } interface LoDashExplicitObjectWrapper { /** * @see _.iteratee */ iteratee(thisArg?: any): LoDashExplicitObjectWrapper<(object: any) => boolean>; /** * @see _.iteratee */ iteratee(thisArg?: any): 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(source: T): (value: any) => boolean; /** * @see _.matches */ matches(source: T): (value: V) => boolean; } interface LoDashImplicitWrapperBase { /** * @see _.matches */ matches(): LoDashImplicitObjectWrapper<(value: V) => boolean>; } interface LoDashExplicitWrapperBase { /** * @see _.matches */ matches(): 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( path: StringRepresentable|StringRepresentable[], srcValue: T ): (value: any) => boolean; /** * @see _.matchesProperty */ matchesProperty( path: StringRepresentable|StringRepresentable[], srcValue: T ): (value: V) => boolean; } interface LoDashImplicitWrapperBase { /** * @see _.matchesProperty */ matchesProperty( srcValue: SrcValue ): LoDashImplicitObjectWrapper<(value: any) => boolean>; /** * @see _.matchesProperty */ matchesProperty( srcValue: SrcValue ): LoDashImplicitObjectWrapper<(value: Value) => boolean>; } interface LoDashExplicitWrapperBase { /** * @see _.matchesProperty */ matchesProperty( srcValue: SrcValue ): LoDashExplicitObjectWrapper<(value: any) => boolean>; /** * @see _.matchesProperty */ matchesProperty( 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( path: string|StringRepresentable[], ...args: any[] ): (object: TObject) => TResult; /** * @see _.method */ method( path: string|StringRepresentable[], ...args: any[] ): (object: any) => TResult; } interface LoDashImplicitWrapper { /** * @see _.method */ method(...args: any[]): LoDashImplicitObjectWrapper<(object: TObject) => TResult>; /** * @see _.method */ method(...args: any[]): LoDashImplicitObjectWrapper<(object: any) => TResult>; } interface LoDashImplicitArrayWrapper { /** * @see _.method */ method(...args: any[]): LoDashImplicitObjectWrapper<(object: TObject) => TResult>; /** * @see _.method */ method(...args: any[]): LoDashImplicitObjectWrapper<(object: any) => TResult>; } interface LoDashExplicitWrapper { /** * @see _.method */ method(...args: any[]): LoDashExplicitObjectWrapper<(object: TObject) => TResult>; /** * @see _.method */ method(...args: any[]): LoDashExplicitObjectWrapper<(object: any) => TResult>; } interface LoDashExplicitArrayWrapper { /** * @see _.method */ method(...args: any[]): LoDashExplicitObjectWrapper<(object: TObject) => TResult>; /** * @see _.method */ method(...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( object: TObject, ...args: any[] ): (path: StringRepresentable|StringRepresentable[]) => TResult; /** * @see _.methodOf */ methodOf( object: {}, ...args: any[] ): (path: StringRepresentable|StringRepresentable[]) => TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.methodOf */ methodOf( ...args: any[] ): LoDashImplicitObjectWrapper<(path: StringRepresentable|StringRepresentable[]) => TResult>; } interface LoDashExplicitObjectWrapper { /** * @see _.methodOf */ methodOf( ...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( object: TObject, source: Dictionary, options?: MixinOptions ): TResult; /** * @see _.mixin */ mixin( source: Dictionary, options?: MixinOptions ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.mixin */ mixin( source: Dictionary, options?: MixinOptions ): LoDashImplicitObjectWrapper; /** * @see _.mixin */ mixin( options?: MixinOptions ): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.mixin */ mixin( source: Dictionary, options?: MixinOptions ): LoDashExplicitObjectWrapper; /** * @see _.mixin */ mixin( options?: MixinOptions ): LoDashExplicitObjectWrapper; } //_.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 { /** * @see _.noConflict */ noConflict(): 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 { /** * @see _.noop */ noop(...args: any[]): void; } interface LoDashExplicitWrapperBase { /** * @see _.noop */ noop(...args: any[]): _.LoDashExplicitWrapper; } //_.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(n?: number): TResult; } interface LoDashImplicitWrapper { /** * @see _.nthArg */ nthArg(): LoDashImplicitObjectWrapper; } interface LoDashExplicitWrapper { /** * @see _.nthArg */ nthArg(): LoDashExplicitObjectWrapper; } //_.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(...iteratees: (Function|Function[])[]): (...args: any[]) => TResult[]; } interface LoDashImplicitArrayWrapper { /** * @see _.over */ over(...iteratees: (Function|Function[])[]): LoDashImplicitObjectWrapper<(...args: any[]) => TResult[]>; } interface LoDashImplicitObjectWrapper { /** * @see _.over */ over(...iteratees: (Function|Function[])[]): LoDashImplicitObjectWrapper<(...args: any[]) => TResult[]>; } interface LoDashExplicitArrayWrapper { /** * @see _.over */ over(...iteratees: (Function|Function[])[]): LoDashExplicitObjectWrapper<(...args: any[]) => TResult[]>; } interface LoDashExplicitObjectWrapper { /** * @see _.over */ over(...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 { /** * @see _.overEvery */ overEvery(...predicates: (Function|Function[])[]): LoDashImplicitObjectWrapper<(...args: any[]) => boolean>; } interface LoDashImplicitObjectWrapper { /** * @see _.overEvery */ overEvery(...predicates: (Function|Function[])[]): LoDashImplicitObjectWrapper<(...args: any[]) => boolean>; } interface LoDashExplicitArrayWrapper { /** * @see _.overEvery */ overEvery(...predicates: (Function|Function[])[]): LoDashExplicitObjectWrapper<(...args: any[]) => boolean>; } interface LoDashExplicitObjectWrapper { /** * @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 { /** * @see _.overSome */ overSome(...predicates: (Function|Function[])[]): LoDashImplicitObjectWrapper<(...args: any[]) => boolean>; } interface LoDashImplicitObjectWrapper { /** * @see _.overSome */ overSome(...predicates: (Function|Function[])[]): LoDashImplicitObjectWrapper<(...args: any[]) => boolean>; } interface LoDashExplicitArrayWrapper { /** * @see _.overSome */ overSome(...predicates: (Function|Function[])[]): LoDashExplicitObjectWrapper<(...args: any[]) => boolean>; } interface LoDashExplicitObjectWrapper { /** * @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(path: StringRepresentable|StringRepresentable[]): (obj: TObj) => TResult; } interface LoDashImplicitWrapper { /** * @see _.property */ property(): LoDashImplicitObjectWrapper<(obj: TObj) => TResult>; } interface LoDashImplicitArrayWrapper { /** * @see _.property */ property(): LoDashImplicitObjectWrapper<(obj: TObj) => TResult>; } interface LoDashExplicitWrapper { /** * @see _.property */ property(): LoDashExplicitObjectWrapper<(obj: TObj) => TResult>; } interface LoDashExplicitArrayWrapper { /** * @see _.property */ property(): 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(object: T): (path: string|string[]) => any; } interface LoDashImplicitObjectWrapper { /** * @see _.propertyOf */ propertyOf(): LoDashImplicitObjectWrapper<(path: string|string[]) => any>; } interface LoDashExplicitObjectWrapper { /** * @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 { /** * @see _.range */ range( end?: number, step?: number ): LoDashImplicitArrayWrapper; } interface LoDashExplicitWrapper { /** * @see _.range */ range( end?: number, step?: number ): LoDashExplicitArrayWrapper; } //_.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 { /** * @see _.rangeRight */ rangeRight( end?: number, step?: number ): LoDashImplicitArrayWrapper; } interface LoDashExplicitWrapper { /** * @see _.rangeRight */ rangeRight( end?: number, step?: number ): LoDashExplicitArrayWrapper; } //_.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 { /** * @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( n: number, iteratee: (num: number) => TResult ): TResult[]; /** * @see _.times */ times(n: number): number[]; } interface LoDashImplicitWrapper { /** * @see _.times */ times( iteratee: (num: number) => TResult ): TResult[]; /** * @see _.times */ times(): number[]; } interface LoDashExplicitWrapper { /** * @see _.times */ times( iteratee: (num: number) => TResult ): LoDashExplicitArrayWrapper; /** * @see _.times */ times(): LoDashExplicitArrayWrapper; } //_.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 { /** * @see _.toPath */ toPath(): LoDashImplicitWrapper; } interface LoDashExplicitWrapperBase { /** * @see _.toPath */ toPath(): LoDashExplicitWrapper; } //_.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 { /** * @see _.uniqueId */ uniqueId(): string; } interface LoDashExplicitWrapper { /** * @see _.uniqueId */ uniqueId(): LoDashExplicitWrapper; } interface ListIterator { (value: T, index: number, collection: List): TResult; } interface DictionaryIterator { (value: T, key?: string, collection?: Dictionary): TResult; } interface NumericDictionaryIterator { (value: T, key?: number, collection?: Dictionary): TResult; } interface ObjectIterator { (element: T, key?: string, collection?: any): TResult; } interface StringIterator { (char: string, index?: number, string?: string): TResult; } interface MemoVoidIterator { (prev: TResult, curr: T, indexOrKey?: any, list?: T[]): void; } interface MemoIterator { (prev: TResult, curr: T, indexOrKey?: any, list?: T[]): TResult; } interface MemoVoidArrayIterator { (acc: TResult, curr: T, index?: number, arr?: T[]): void; } interface MemoVoidDictionaryIterator { (acc: TResult, curr: T, key?: string, dict?: Dictionary): void; } //interface Collection {} // Common interface between Arrays and jQuery objects interface List { [index: number]: T; length: number; } interface Dictionary { [index: string]: T; } interface NumericDictionary { [index: number]: T; } interface StringRepresentable { toString(): string; } interface Cancelable { cancel(): void; } } declare module "lodash" { export = _; }WebDevelopment-assignment-2/typings/browser/ambient/minimatch/000077500000000000000000000000001266350324300250575ustar00rootroot00000000000000WebDevelopment-assignment-2/typings/browser/ambient/minimatch/minimatch.d.ts000066400000000000000000000037111266350324300276240ustar00rootroot00000000000000// Compiled using typings@0.6.8 // Source: https://raw.githubusercontent.com/DefinitelyTyped/DefinitelyTyped/a3900b896f7b3361b79f9b503224777619907d53/minimatch/minimatch.d.ts // Type definitions for Minimatch 2.0.8 // Project: https://github.com/isaacs/minimatch // Definitions by: vvakame // Definitions: https://github.com/borisyankov/DefinitelyTyped declare module "minimatch" { function M(target: string, pattern: string, options?: M.IOptions): boolean; module M { function match(list: string[], pattern: string, options?: IOptions): string[]; function filter(pattern: string, options?: IOptions): (element: string, indexed: number, array: string[]) => boolean; function makeRe(pattern: string, options?: IOptions): RegExp; var Minimatch: IMinimatchStatic; interface IOptions { debug?: boolean; nobrace?: boolean; noglobstar?: boolean; dot?: boolean; noext?: boolean; nocase?: boolean; nonull?: boolean; matchBase?: boolean; nocomment?: boolean; nonegate?: boolean; flipNegate?: boolean; } interface IMinimatchStatic { new (pattern: string, options?: IOptions): IMinimatch; prototype: IMinimatch; } interface IMinimatch { pattern: string; options: IOptions; /** 2-dimensional array of regexp or string expressions. */ set: any[][]; // (RegExp | string)[][] regexp: RegExp; negate: boolean; comment: boolean; empty: boolean; makeRe(): RegExp; // regexp or boolean match(fname: string): boolean; matchOne(files: string[], pattern: string[], partial: boolean): boolean; /** Deprecated. For internal use. */ debug(): void; /** Deprecated. For internal use. */ make(): void; /** Deprecated. For internal use. */ parseNegate(): void; /** Deprecated. For internal use. */ braceExpand(pattern: string, options: IOptions): void; /** Deprecated. For internal use. */ parse(pattern: string, isSub?: boolean): void; } } export = M; }WebDevelopment-assignment-2/typings/browser/ambient/node/000077500000000000000000000000001266350324300240335ustar00rootroot00000000000000WebDevelopment-assignment-2/typings/browser/ambient/node/node.d.ts000066400000000000000000002636661266350324300255750ustar00rootroot00000000000000// Compiled using typings@0.6.8 // Source: https://raw.githubusercontent.com/DefinitelyTyped/DefinitelyTyped/20e1eb9616922d382d918cc5a21870a9dbe255f5/node/node.d.ts // Type definitions for Node.js v4.x // Project: http://nodejs.org/ // Definitions by: Microsoft TypeScript , DefinitelyTyped // Definitions: https://github.com/borisyankov/DefinitelyTyped /************************************************ * * * Node.js v4.x API * * * ************************************************/ interface Error { stack?: string; } // compat for TypeScript 1.5.3 // if you use with --target es3 or --target es5 and use below definitions, // use the lib.es6.d.ts that is bundled with TypeScript 1.5.3. interface MapConstructor {} interface WeakMapConstructor {} interface SetConstructor {} interface WeakSetConstructor {} /************************************************ * * * GLOBAL * * * ************************************************/ declare var process: NodeJS.Process; declare var global: NodeJS.Global; declare var __filename: string; declare var __dirname: string; declare function setTimeout(callback: (...args: any[]) => void, ms: number, ...args: any[]): NodeJS.Timer; declare function clearTimeout(timeoutId: NodeJS.Timer): void; declare function setInterval(callback: (...args: any[]) => void, ms: number, ...args: any[]): NodeJS.Timer; declare function clearInterval(intervalId: NodeJS.Timer): void; declare function setImmediate(callback: (...args: any[]) => void, ...args: any[]): any; declare function clearImmediate(immediateId: any): void; interface NodeRequireFunction { (id: string): any; } interface NodeRequire extends NodeRequireFunction { resolve(id:string): string; cache: any; extensions: any; main: any; } declare var require: NodeRequire; interface NodeModule { exports: any; require: NodeRequireFunction; id: string; filename: string; loaded: boolean; parent: any; children: any[]; } declare var module: NodeModule; // Same as module.exports declare var exports: any; declare var SlowBuffer: { new (str: string, encoding?: string): Buffer; new (size: number): Buffer; new (size: Uint8Array): Buffer; new (array: any[]): Buffer; prototype: Buffer; isBuffer(obj: any): boolean; byteLength(string: string, encoding?: string): number; concat(list: Buffer[], totalLength?: number): Buffer; }; // Buffer class interface Buffer extends NodeBuffer {} /** * Raw data is stored in instances of the Buffer class. * A Buffer is similar to an array of integers but corresponds to a raw memory allocation outside the V8 heap. A Buffer cannot be resized. * Valid string encodings: 'ascii'|'utf8'|'utf16le'|'ucs2'(alias of 'utf16le')|'base64'|'binary'(deprecated)|'hex' */ declare var Buffer: { /** * Allocates a new buffer containing the given {str}. * * @param str String to store in buffer. * @param encoding encoding to use, optional. Default is 'utf8' */ new (str: string, encoding?: string): Buffer; /** * Allocates a new buffer of {size} octets. * * @param size count of octets to allocate. */ new (size: number): Buffer; /** * Allocates a new buffer containing the given {array} of octets. * * @param array The octets to store. */ new (array: Uint8Array): Buffer; /** * Allocates a new buffer containing the given {array} of octets. * * @param array The octets to store. */ new (array: any[]): Buffer; /** * Copies the passed {buffer} data onto a new {Buffer} instance. * * @param buffer The buffer to copy. */ new (buffer: Buffer): Buffer; prototype: Buffer; /** * Returns true if {obj} is a Buffer * * @param obj object to test. */ isBuffer(obj: any): obj is Buffer; /** * Returns true if {encoding} is a valid encoding argument. * Valid string encodings in Node 0.12: 'ascii'|'utf8'|'utf16le'|'ucs2'(alias of 'utf16le')|'base64'|'binary'(deprecated)|'hex' * * @param encoding string to test. */ isEncoding(encoding: string): boolean; /** * Gives the actual byte length of a string. encoding defaults to 'utf8'. * This is not the same as String.prototype.length since that returns the number of characters in a string. * * @param string string to test. * @param encoding encoding used to evaluate (defaults to 'utf8') */ byteLength(string: string, encoding?: string): number; /** * Returns a buffer which is the result of concatenating all the buffers in the list together. * * If the list has no items, or if the totalLength is 0, then it returns a zero-length buffer. * If the list has exactly one item, then the first item of the list is returned. * If the list has more than one item, then a new Buffer is created. * * @param list An array of Buffer objects to concatenate * @param totalLength Total length of the buffers when concatenated. * If totalLength is not provided, it is read from the buffers in the list. However, this adds an additional loop to the function, so it is faster to provide the length explicitly. */ concat(list: Buffer[], totalLength?: number): Buffer; /** * The same as buf1.compare(buf2). */ compare(buf1: Buffer, buf2: Buffer): number; }; /************************************************ * * * GLOBAL INTERFACES * * * ************************************************/ declare module NodeJS { export interface ErrnoException extends Error { errno?: number; code?: string; path?: string; syscall?: string; stack?: string; } export interface EventEmitter { addListener(event: string, listener: Function): EventEmitter; on(event: string, listener: Function): EventEmitter; once(event: string, listener: Function): EventEmitter; removeListener(event: string, listener: Function): EventEmitter; removeAllListeners(event?: string): EventEmitter; setMaxListeners(n: number): EventEmitter; getMaxListeners(): number; listeners(event: string): Function[]; emit(event: string, ...args: any[]): boolean; listenerCount(type: string): number; } export interface ReadableStream extends EventEmitter { readable: boolean; read(size?: number): string|Buffer; setEncoding(encoding: string): void; pause(): void; resume(): void; pipe(destination: T, options?: { end?: boolean; }): T; unpipe(destination?: T): void; unshift(chunk: string): void; unshift(chunk: Buffer): void; wrap(oldStream: ReadableStream): ReadableStream; } export interface WritableStream extends EventEmitter { writable: boolean; write(buffer: Buffer|string, cb?: Function): boolean; write(str: string, encoding?: string, cb?: Function): boolean; end(): void; end(buffer: Buffer, cb?: Function): void; end(str: string, cb?: Function): void; end(str: string, encoding?: string, cb?: Function): void; } export interface ReadWriteStream extends ReadableStream, WritableStream {} export interface Process extends EventEmitter { stdout: WritableStream; stderr: WritableStream; stdin: ReadableStream; argv: string[]; execArgv: string[]; execPath: string; abort(): void; chdir(directory: string): void; cwd(): string; env: any; exit(code?: number): void; getgid(): number; setgid(id: number): void; setgid(id: string): void; getuid(): number; setuid(id: number): void; setuid(id: string): void; version: string; versions: { http_parser: string; node: string; v8: string; ares: string; uv: string; zlib: string; openssl: string; }; config: { target_defaults: { cflags: any[]; default_configuration: string; defines: string[]; include_dirs: string[]; libraries: string[]; }; variables: { clang: number; host_arch: string; node_install_npm: boolean; node_install_waf: boolean; node_prefix: string; node_shared_openssl: boolean; node_shared_v8: boolean; node_shared_zlib: boolean; node_use_dtrace: boolean; node_use_etw: boolean; node_use_openssl: boolean; target_arch: string; v8_no_strict_aliasing: number; v8_use_snapshot: boolean; visibility: string; }; }; kill(pid:number, signal?: string|number): void; pid: number; title: string; arch: string; platform: string; memoryUsage(): { rss: number; heapTotal: number; heapUsed: number; }; nextTick(callback: Function): void; umask(mask?: number): number; uptime(): number; hrtime(time?:number[]): number[]; // Worker send?(message: any, sendHandle?: any): void; } export interface Global { Array: typeof Array; ArrayBuffer: typeof ArrayBuffer; Boolean: typeof Boolean; Buffer: typeof Buffer; DataView: typeof DataView; Date: typeof Date; Error: typeof Error; EvalError: typeof EvalError; Float32Array: typeof Float32Array; Float64Array: typeof Float64Array; Function: typeof Function; GLOBAL: Global; Infinity: typeof Infinity; Int16Array: typeof Int16Array; Int32Array: typeof Int32Array; Int8Array: typeof Int8Array; Intl: typeof Intl; JSON: typeof JSON; Map: MapConstructor; Math: typeof Math; NaN: typeof NaN; Number: typeof Number; Object: typeof Object; Promise: Function; RangeError: typeof RangeError; ReferenceError: typeof ReferenceError; RegExp: typeof RegExp; Set: SetConstructor; String: typeof String; Symbol: Function; SyntaxError: typeof SyntaxError; TypeError: typeof TypeError; URIError: typeof URIError; Uint16Array: typeof Uint16Array; Uint32Array: typeof Uint32Array; Uint8Array: typeof Uint8Array; Uint8ClampedArray: Function; WeakMap: WeakMapConstructor; WeakSet: WeakSetConstructor; clearImmediate: (immediateId: any) => void; clearInterval: (intervalId: NodeJS.Timer) => void; clearTimeout: (timeoutId: NodeJS.Timer) => void; console: typeof console; decodeURI: typeof decodeURI; decodeURIComponent: typeof decodeURIComponent; encodeURI: typeof encodeURI; encodeURIComponent: typeof encodeURIComponent; escape: (str: string) => string; eval: typeof eval; global: Global; isFinite: typeof isFinite; isNaN: typeof isNaN; parseFloat: typeof parseFloat; parseInt: typeof parseInt; process: Process; root: Global; setImmediate: (callback: (...args: any[]) => void, ...args: any[]) => any; setInterval: (callback: (...args: any[]) => void, ms: number, ...args: any[]) => NodeJS.Timer; setTimeout: (callback: (...args: any[]) => void, ms: number, ...args: any[]) => NodeJS.Timer; undefined: typeof undefined; unescape: (str: string) => string; gc: () => void; v8debug?: any; } export interface Timer { ref() : void; unref() : void; } } /** * @deprecated */ interface NodeBuffer { [index: number]: number; write(string: string, offset?: number, length?: number, encoding?: string): number; toString(encoding?: string, start?: number, end?: number): string; toJSON(): any; length: number; equals(otherBuffer: Buffer): boolean; compare(otherBuffer: Buffer): number; copy(targetBuffer: Buffer, targetStart?: number, sourceStart?: number, sourceEnd?: number): number; slice(start?: number, end?: number): Buffer; writeUIntLE(value: number, offset: number, byteLength: number, noAssert?: boolean): number; writeUIntBE(value: number, offset: number, byteLength: number, noAssert?: boolean): number; writeIntLE(value: number, offset: number, byteLength: number, noAssert?: boolean): number; writeIntBE(value: number, offset: number, byteLength: number, noAssert?: boolean): number; readUIntLE(offset: number, byteLength: number, noAssert?: boolean): number; readUIntBE(offset: number, byteLength: number, noAssert?: boolean): number; readIntLE(offset: number, byteLength: number, noAssert?: boolean): number; readIntBE(offset: number, byteLength: number, noAssert?: boolean): number; readUInt8(offset: number, noAsset?: boolean): number; readUInt16LE(offset: number, noAssert?: boolean): number; readUInt16BE(offset: number, noAssert?: boolean): number; readUInt32LE(offset: number, noAssert?: boolean): number; readUInt32BE(offset: number, noAssert?: boolean): number; readInt8(offset: number, noAssert?: boolean): number; readInt16LE(offset: number, noAssert?: boolean): number; readInt16BE(offset: number, noAssert?: boolean): number; readInt32LE(offset: number, noAssert?: boolean): number; readInt32BE(offset: number, noAssert?: boolean): number; readFloatLE(offset: number, noAssert?: boolean): number; readFloatBE(offset: number, noAssert?: boolean): number; readDoubleLE(offset: number, noAssert?: boolean): number; readDoubleBE(offset: number, noAssert?: boolean): number; writeUInt8(value: number, offset: number, noAssert?: boolean): number; writeUInt16LE(value: number, offset: number, noAssert?: boolean): number; writeUInt16BE(value: number, offset: number, noAssert?: boolean): number; writeUInt32LE(value: number, offset: number, noAssert?: boolean): number; writeUInt32BE(value: number, offset: number, noAssert?: boolean): number; writeInt8(value: number, offset: number, noAssert?: boolean): number; writeInt16LE(value: number, offset: number, noAssert?: boolean): number; writeInt16BE(value: number, offset: number, noAssert?: boolean): number; writeInt32LE(value: number, offset: number, noAssert?: boolean): number; writeInt32BE(value: number, offset: number, noAssert?: boolean): number; writeFloatLE(value: number, offset: number, noAssert?: boolean): number; writeFloatBE(value: number, offset: number, noAssert?: boolean): number; writeDoubleLE(value: number, offset: number, noAssert?: boolean): number; writeDoubleBE(value: number, offset: number, noAssert?: boolean): number; fill(value: any, offset?: number, end?: number): Buffer; indexOf(value: string | number | Buffer, byteOffset?: number): number; } /************************************************ * * * MODULES * * * ************************************************/ declare module "buffer" { export var INSPECT_MAX_BYTES: number; var BuffType: typeof Buffer; var SlowBuffType: typeof SlowBuffer; export { BuffType as Buffer, SlowBuffType as SlowBuffer }; } declare module "querystring" { export interface StringifyOptions { encodeURIComponent?: Function; } export interface ParseOptions { maxKeys?: number; decodeURIComponent?: Function; } export function stringify(obj: T, sep?: string, eq?: string, options?: StringifyOptions): string; export function parse(str: string, sep?: string, eq?: string, options?: ParseOptions): any; export function parse(str: string, sep?: string, eq?: string, options?: ParseOptions): T; export function escape(str: string): string; export function unescape(str: string): string; } declare module "events" { export class EventEmitter implements NodeJS.EventEmitter { static EventEmitter: EventEmitter; static listenerCount(emitter: EventEmitter, event: string): number; // deprecated static defaultMaxListeners: number; addListener(event: string, listener: Function): EventEmitter; on(event: string, listener: Function): EventEmitter; once(event: string, listener: Function): EventEmitter; removeListener(event: string, listener: Function): EventEmitter; removeAllListeners(event?: string): EventEmitter; setMaxListeners(n: number): EventEmitter; getMaxListeners(): number; listeners(event: string): Function[]; emit(event: string, ...args: any[]): boolean; listenerCount(type: string): number; } } declare module "http" { import * as events from "events"; import * as net from "net"; import * as stream from "stream"; export interface RequestOptions { protocol?: string; host?: string; hostname?: string; family?: number; port?: number; localAddress?: string; socketPath?: string; method?: string; path?: string; headers?: { [key: string]: any }; auth?: string; agent?: Agent|boolean; } export interface Server extends events.EventEmitter { listen(port: number, hostname?: string, backlog?: number, callback?: Function): Server; listen(port: number, hostname?: string, callback?: Function): Server; listen(path: string, callback?: Function): Server; listen(handle: any, listeningListener?: Function): Server; close(cb?: any): Server; address(): { port: number; family: string; address: string; }; maxHeadersCount: number; } /** * @deprecated Use IncomingMessage */ export interface ServerRequest extends IncomingMessage { connection: net.Socket; } export interface ServerResponse extends events.EventEmitter, stream.Writable { // Extended base methods write(buffer: Buffer): boolean; write(buffer: Buffer, cb?: Function): boolean; write(str: string, cb?: Function): boolean; write(str: string, encoding?: string, cb?: Function): boolean; write(str: string, encoding?: string, fd?: string): boolean; writeContinue(): void; writeHead(statusCode: number, reasonPhrase?: string, headers?: any): void; writeHead(statusCode: number, headers?: any): void; statusCode: number; statusMessage: string; headersSent: boolean; setHeader(name: string, value: string | string[]): void; sendDate: boolean; getHeader(name: string): string; removeHeader(name: string): void; write(chunk: any, encoding?: string): any; addTrailers(headers: any): void; // Extended base methods end(): void; end(buffer: Buffer, cb?: Function): void; end(str: string, cb?: Function): void; end(str: string, encoding?: string, cb?: Function): void; end(data?: any, encoding?: string): void; } export interface ClientRequest extends events.EventEmitter, stream.Writable { // Extended base methods write(buffer: Buffer): boolean; write(buffer: Buffer, cb?: Function): boolean; write(str: string, cb?: Function): boolean; write(str: string, encoding?: string, cb?: Function): boolean; write(str: string, encoding?: string, fd?: string): boolean; write(chunk: any, encoding?: string): void; abort(): void; setTimeout(timeout: number, callback?: Function): void; setNoDelay(noDelay?: boolean): void; setSocketKeepAlive(enable?: boolean, initialDelay?: number): void; // Extended base methods end(): void; end(buffer: Buffer, cb?: Function): void; end(str: string, cb?: Function): void; end(str: string, encoding?: string, cb?: Function): void; end(data?: any, encoding?: string): void; } export interface IncomingMessage extends events.EventEmitter, stream.Readable { httpVersion: string; headers: any; rawHeaders: string[]; trailers: any; rawTrailers: any; setTimeout(msecs: number, callback: Function): NodeJS.Timer; /** * Only valid for request obtained from http.Server. */ method?: string; /** * Only valid for request obtained from http.Server. */ url?: string; /** * Only valid for response obtained from http.ClientRequest. */ statusCode?: number; /** * Only valid for response obtained from http.ClientRequest. */ statusMessage?: string; socket: net.Socket; } /** * @deprecated Use IncomingMessage */ export interface ClientResponse extends IncomingMessage { } export interface AgentOptions { /** * Keep sockets around in a pool to be used by other requests in the future. Default = false */ keepAlive?: boolean; /** * When using HTTP KeepAlive, how often to send TCP KeepAlive packets over sockets being kept alive. Default = 1000. * Only relevant if keepAlive is set to true. */ keepAliveMsecs?: number; /** * Maximum number of sockets to allow per host. Default for Node 0.10 is 5, default for Node 0.12 is Infinity */ maxSockets?: number; /** * Maximum number of sockets to leave open in a free state. Only relevant if keepAlive is set to true. Default = 256. */ maxFreeSockets?: number; } export class Agent { maxSockets: number; sockets: any; requests: any; constructor(opts?: AgentOptions); /** * Destroy any sockets that are currently in use by the agent. * It is usually not necessary to do this. However, if you are using an agent with KeepAlive enabled, * then it is best to explicitly shut down the agent when you know that it will no longer be used. Otherwise, * sockets may hang open for quite a long time before the server terminates them. */ destroy(): void; } export var METHODS: string[]; export var STATUS_CODES: { [errorCode: number]: string; [errorCode: string]: string; }; export function createServer(requestListener?: (request: IncomingMessage, response: ServerResponse) =>void ): Server; export function createClient(port?: number, host?: string): any; export function request(options: RequestOptions, callback?: (res: IncomingMessage) => void): ClientRequest; export function get(options: any, callback?: (res: IncomingMessage) => void): ClientRequest; export var globalAgent: Agent; } declare module "cluster" { import * as child from "child_process"; import * as events from "events"; export interface ClusterSettings { exec?: string; args?: string[]; silent?: boolean; } export class Worker extends events.EventEmitter { id: string; process: child.ChildProcess; suicide: boolean; send(message: any, sendHandle?: any): void; kill(signal?: string): void; destroy(signal?: string): void; disconnect(): void; } export var settings: ClusterSettings; export var isMaster: boolean; export var isWorker: boolean; export function setupMaster(settings?: ClusterSettings): void; export function fork(env?: any): Worker; export function disconnect(callback?: Function): void; export var worker: Worker; export var workers: Worker[]; // Event emitter export function addListener(event: string, listener: Function): void; export function on(event: "disconnect", listener: (worker: Worker) => void): void; export function on(event: "exit", listener: (worker: Worker, code: number, signal: string) => void): void; export function on(event: "fork", listener: (worker: Worker) => void): void; export function on(event: "listening", listener: (worker: Worker, address: any) => void): void; export function on(event: "message", listener: (worker: Worker, message: any) => void): void; export function on(event: "online", listener: (worker: Worker) => void): void; export function on(event: "setup", listener: (settings: any) => void): void; export function on(event: string, listener: Function): any; export function once(event: string, listener: Function): void; export function removeListener(event: string, listener: Function): void; export function removeAllListeners(event?: string): void; export function setMaxListeners(n: number): void; export function listeners(event: string): Function[]; export function emit(event: string, ...args: any[]): boolean; } declare module "zlib" { import * as stream from "stream"; export interface ZlibOptions { chunkSize?: number; windowBits?: number; level?: number; memLevel?: number; strategy?: number; dictionary?: any; } export interface Gzip extends stream.Transform { } export interface Gunzip extends stream.Transform { } export interface Deflate extends stream.Transform { } export interface Inflate extends stream.Transform { } export interface DeflateRaw extends stream.Transform { } export interface InflateRaw extends stream.Transform { } export interface Unzip extends stream.Transform { } export function createGzip(options?: ZlibOptions): Gzip; export function createGunzip(options?: ZlibOptions): Gunzip; export function createDeflate(options?: ZlibOptions): Deflate; export function createInflate(options?: ZlibOptions): Inflate; export function createDeflateRaw(options?: ZlibOptions): DeflateRaw; export function createInflateRaw(options?: ZlibOptions): InflateRaw; export function createUnzip(options?: ZlibOptions): Unzip; export function deflate(buf: Buffer, callback: (error: Error, result: any) =>void ): void; export function deflateSync(buf: Buffer, options?: ZlibOptions): any; export function deflateRaw(buf: Buffer, callback: (error: Error, result: any) =>void ): void; export function deflateRawSync(buf: Buffer, options?: ZlibOptions): any; export function gzip(buf: Buffer, callback: (error: Error, result: any) =>void ): void; export function gzipSync(buf: Buffer, options?: ZlibOptions): any; export function gunzip(buf: Buffer, callback: (error: Error, result: any) =>void ): void; export function gunzipSync(buf: Buffer, options?: ZlibOptions): any; export function inflate(buf: Buffer, callback: (error: Error, result: any) =>void ): void; export function inflateSync(buf: Buffer, options?: ZlibOptions): any; export function inflateRaw(buf: Buffer, callback: (error: Error, result: any) =>void ): void; export function inflateRawSync(buf: Buffer, options?: ZlibOptions): any; export function unzip(buf: Buffer, callback: (error: Error, result: any) =>void ): void; export function unzipSync(buf: Buffer, options?: ZlibOptions): any; // Constants export var Z_NO_FLUSH: number; export var Z_PARTIAL_FLUSH: number; export var Z_SYNC_FLUSH: number; export var Z_FULL_FLUSH: number; export var Z_FINISH: number; export var Z_BLOCK: number; export var Z_TREES: number; export var Z_OK: number; export var Z_STREAM_END: number; export var Z_NEED_DICT: number; export var Z_ERRNO: number; export var Z_STREAM_ERROR: number; export var Z_DATA_ERROR: number; export var Z_MEM_ERROR: number; export var Z_BUF_ERROR: number; export var Z_VERSION_ERROR: number; export var Z_NO_COMPRESSION: number; export var Z_BEST_SPEED: number; export var Z_BEST_COMPRESSION: number; export var Z_DEFAULT_COMPRESSION: number; export var Z_FILTERED: number; export var Z_HUFFMAN_ONLY: number; export var Z_RLE: number; export var Z_FIXED: number; export var Z_DEFAULT_STRATEGY: number; export var Z_BINARY: number; export var Z_TEXT: number; export var Z_ASCII: number; export var Z_UNKNOWN: number; export var Z_DEFLATED: number; export var Z_NULL: number; } declare module "os" { export interface CpuInfo { model: string; speed: number; times: { user: number; nice: number; sys: number; idle: number; irq: number; }; } export interface NetworkInterfaceInfo { address: string; netmask: string; family: string; mac: string; internal: boolean; } export function tmpdir(): string; export function homedir(): string; export function endianness(): string; export function hostname(): string; export function type(): string; export function platform(): string; export function arch(): string; export function release(): string; export function uptime(): number; export function loadavg(): number[]; export function totalmem(): number; export function freemem(): number; export function cpus(): CpuInfo[]; export function networkInterfaces(): {[index: string]: NetworkInterfaceInfo[]}; export var EOL: string; } declare module "https" { import * as tls from "tls"; import * as events from "events"; import * as http from "http"; export interface ServerOptions { pfx?: any; key?: any; passphrase?: string; cert?: any; ca?: any; crl?: any; ciphers?: string; honorCipherOrder?: boolean; requestCert?: boolean; rejectUnauthorized?: boolean; NPNProtocols?: any; SNICallback?: (servername: string) => any; } export interface RequestOptions extends http.RequestOptions{ pfx?: any; key?: any; passphrase?: string; cert?: any; ca?: any; ciphers?: string; rejectUnauthorized?: boolean; secureProtocol?: string; } export interface Agent { maxSockets: number; sockets: any; requests: any; } export var Agent: { new (options?: RequestOptions): Agent; }; export interface Server extends tls.Server { } export function createServer(options: ServerOptions, requestListener?: Function): Server; export function request(options: RequestOptions, callback?: (res: http.IncomingMessage) =>void ): http.ClientRequest; export function get(options: RequestOptions, callback?: (res: http.IncomingMessage) =>void ): http.ClientRequest; export var globalAgent: Agent; } declare module "punycode" { export function decode(string: string): string; export function encode(string: string): string; export function toUnicode(domain: string): string; export function toASCII(domain: string): string; export var ucs2: ucs2; interface ucs2 { decode(string: string): number[]; encode(codePoints: number[]): string; } export var version: any; } declare module "repl" { import * as stream from "stream"; import * as events from "events"; export interface ReplOptions { prompt?: string; input?: NodeJS.ReadableStream; output?: NodeJS.WritableStream; terminal?: boolean; eval?: Function; useColors?: boolean; useGlobal?: boolean; ignoreUndefined?: boolean; writer?: Function; } export function start(options: ReplOptions): events.EventEmitter; } declare module "readline" { import * as events from "events"; import * as stream from "stream"; export interface Key { sequence?: string; name?: string; ctrl?: boolean; meta?: boolean; shift?: boolean; } export interface ReadLine extends events.EventEmitter { setPrompt(prompt: string): void; prompt(preserveCursor?: boolean): void; question(query: string, callback: (answer: string) => void): void; pause(): ReadLine; resume(): ReadLine; close(): void; write(data: string|Buffer, key?: Key): void; } export interface Completer { (line: string): CompleterResult; (line: string, callback: (err: any, result: CompleterResult) => void): any; } export interface CompleterResult { completions: string[]; line: string; } export interface ReadLineOptions { input: NodeJS.ReadableStream; output?: NodeJS.WritableStream; completer?: Completer; terminal?: boolean; historySize?: number; } export function createInterface(input: NodeJS.ReadableStream, output?: NodeJS.WritableStream, completer?: Completer, terminal?: boolean): ReadLine; export function createInterface(options: ReadLineOptions): ReadLine; export function cursorTo(stream: NodeJS.WritableStream, x: number, y: number): void; export function moveCursor(stream: NodeJS.WritableStream, dx: number|string, dy: number|string): void; export function clearLine(stream: NodeJS.WritableStream, dir: number): void; export function clearScreenDown(stream: NodeJS.WritableStream): void; } declare module "vm" { export interface Context { } export interface Script { runInThisContext(): void; runInNewContext(sandbox?: Context): void; } export function runInThisContext(code: string, filename?: string): void; export function runInNewContext(code: string, sandbox?: Context, filename?: string): void; export function runInContext(code: string, context: Context, filename?: string): void; export function createContext(initSandbox?: Context): Context; export function createScript(code: string, filename?: string): Script; } declare module "child_process" { import * as events from "events"; import * as stream from "stream"; export interface ChildProcess extends events.EventEmitter { stdin: stream.Writable; stdout: stream.Readable; stderr: stream.Readable; stdio: (stream.Readable|stream.Writable)[]; pid: number; kill(signal?: string): void; send(message: any, sendHandle?: any): void; disconnect(): void; unref(): void; } export function spawn(command: string, args?: string[], options?: { cwd?: string; stdio?: any; custom?: any; env?: any; detached?: boolean; }): ChildProcess; export function exec(command: string, options: { cwd?: string; stdio?: any; customFds?: any; env?: any; encoding?: string; timeout?: number; maxBuffer?: number; killSignal?: string; }, callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess; export function exec(command: string, callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess; export function execFile(file: string, callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess; export function execFile(file: string, args?: string[], callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess; export function execFile(file: string, args?: string[], options?: { cwd?: string; stdio?: any; customFds?: any; env?: any; encoding?: string; timeout?: number; maxBuffer?: number; killSignal?: string; }, callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess; export function fork(modulePath: string, args?: string[], options?: { cwd?: string; env?: any; execPath?: string; execArgv?: string[]; silent?: boolean; uid?: number; gid?: number; }): ChildProcess; export function spawnSync(command: string, args?: string[], options?: { cwd?: string; input?: string | Buffer; stdio?: any; env?: any; uid?: number; gid?: number; timeout?: number; maxBuffer?: number; killSignal?: string; encoding?: string; }): { pid: number; output: string[]; stdout: string | Buffer; stderr: string | Buffer; status: number; signal: string; error: Error; }; export function execSync(command: string, options?: { cwd?: string; input?: string|Buffer; stdio?: any; env?: any; uid?: number; gid?: number; timeout?: number; maxBuffer?: number; killSignal?: string; encoding?: string; }): string | Buffer; export function execFileSync(command: string, args?: string[], options?: { cwd?: string; input?: string|Buffer; stdio?: any; env?: any; uid?: number; gid?: number; timeout?: number; maxBuffer?: number; killSignal?: string; encoding?: string; }): string | Buffer; } declare module "url" { export interface Url { href?: string; protocol?: string; auth?: string; hostname?: string; port?: string; host?: string; pathname?: string; search?: string; query?: any; // string | Object slashes?: boolean; hash?: string; path?: string; } export function parse(urlStr: string, parseQueryString?: boolean , slashesDenoteHost?: boolean ): Url; export function format(url: Url): string; export function resolve(from: string, to: string): string; } declare module "dns" { export function lookup(domain: string, family: number, callback: (err: Error, address: string, family: number) =>void ): string; export function lookup(domain: string, callback: (err: Error, address: string, family: number) =>void ): string; export function resolve(domain: string, rrtype: string, callback: (err: Error, addresses: string[]) =>void ): string[]; export function resolve(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[]; export function resolve4(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[]; export function resolve6(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[]; export function resolveMx(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[]; export function resolveTxt(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[]; export function resolveSrv(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[]; export function resolveNs(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[]; export function resolveCname(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[]; export function reverse(ip: string, callback: (err: Error, domains: string[]) =>void ): string[]; } declare module "net" { import * as stream from "stream"; export interface Socket extends stream.Duplex { // Extended base methods write(buffer: Buffer): boolean; write(buffer: Buffer, cb?: Function): boolean; write(str: string, cb?: Function): boolean; write(str: string, encoding?: string, cb?: Function): boolean; write(str: string, encoding?: string, fd?: string): boolean; connect(port: number, host?: string, connectionListener?: Function): void; connect(path: string, connectionListener?: Function): void; bufferSize: number; setEncoding(encoding?: string): void; write(data: any, encoding?: string, callback?: Function): void; destroy(): void; pause(): void; resume(): void; setTimeout(timeout: number, callback?: Function): void; setNoDelay(noDelay?: boolean): void; setKeepAlive(enable?: boolean, initialDelay?: number): void; address(): { port: number; family: string; address: string; }; unref(): void; ref(): void; remoteAddress: string; remoteFamily: string; remotePort: number; localAddress: string; localPort: number; bytesRead: number; bytesWritten: number; // Extended base methods end(): void; end(buffer: Buffer, cb?: Function): void; end(str: string, cb?: Function): void; end(str: string, encoding?: string, cb?: Function): void; end(data?: any, encoding?: string): void; } export var Socket: { new (options?: { fd?: string; type?: string; allowHalfOpen?: boolean; }): Socket; }; export interface Server extends Socket { listen(port: number, host?: string, backlog?: number, listeningListener?: Function): Server; listen(path: string, listeningListener?: Function): Server; listen(handle: any, listeningListener?: Function): Server; close(callback?: Function): Server; address(): { port: number; family: string; address: string; }; maxConnections: number; connections: number; } export function createServer(connectionListener?: (socket: Socket) =>void ): Server; export function createServer(options?: { allowHalfOpen?: boolean; }, connectionListener?: (socket: Socket) =>void ): Server; export function connect(options: { port: number, host?: string, localAddress? : string, localPort? : string, family? : number, allowHalfOpen?: boolean; }, connectionListener?: Function): Socket; export function connect(port: number, host?: string, connectionListener?: Function): Socket; export function connect(path: string, connectionListener?: Function): Socket; export function createConnection(options: { port: number, host?: string, localAddress? : string, localPort? : string, family? : number, allowHalfOpen?: boolean; }, connectionListener?: Function): Socket; export function createConnection(port: number, host?: string, connectionListener?: Function): Socket; export function createConnection(path: string, connectionListener?: Function): Socket; export function isIP(input: string): number; export function isIPv4(input: string): boolean; export function isIPv6(input: string): boolean; } declare module "dgram" { import * as events from "events"; interface RemoteInfo { address: string; port: number; size: number; } interface AddressInfo { address: string; family: string; port: number; } export function createSocket(type: string, callback?: (msg: Buffer, rinfo: RemoteInfo) => void): Socket; interface Socket extends events.EventEmitter { send(buf: Buffer, offset: number, length: number, port: number, address: string, callback?: (error: Error, bytes: number) => void): void; bind(port: number, address?: string, callback?: () => void): void; close(): void; address(): AddressInfo; setBroadcast(flag: boolean): void; setMulticastTTL(ttl: number): void; setMulticastLoopback(flag: boolean): void; addMembership(multicastAddress: string, multicastInterface?: string): void; dropMembership(multicastAddress: string, multicastInterface?: string): void; } } declare module "fs" { import * as stream from "stream"; import * as events from "events"; interface Stats { isFile(): boolean; isDirectory(): boolean; isBlockDevice(): boolean; isCharacterDevice(): boolean; isSymbolicLink(): boolean; isFIFO(): boolean; isSocket(): boolean; dev: number; ino: number; mode: number; nlink: number; uid: number; gid: number; rdev: number; size: number; blksize: number; blocks: number; atime: Date; mtime: Date; ctime: Date; birthtime: Date; } interface FSWatcher extends events.EventEmitter { close(): void; } export interface ReadStream extends stream.Readable { close(): void; } export interface WriteStream extends stream.Writable { close(): void; bytesWritten: number; } /** * Asynchronous rename. * @param oldPath * @param newPath * @param callback No arguments other than a possible exception are given to the completion callback. */ export function rename(oldPath: string, newPath: string, callback?: (err?: NodeJS.ErrnoException) => void): void; /** * Synchronous rename * @param oldPath * @param newPath */ export function renameSync(oldPath: string, newPath: string): void; export function truncate(path: string, callback?: (err?: NodeJS.ErrnoException) => void): void; export function truncate(path: string, len: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function truncateSync(path: string, len?: number): void; export function ftruncate(fd: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function ftruncate(fd: number, len: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function ftruncateSync(fd: number, len?: number): void; export function chown(path: string, uid: number, gid: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function chownSync(path: string, uid: number, gid: number): void; export function fchown(fd: number, uid: number, gid: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function fchownSync(fd: number, uid: number, gid: number): void; export function lchown(path: string, uid: number, gid: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function lchownSync(path: string, uid: number, gid: number): void; export function chmod(path: string, mode: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function chmod(path: string, mode: string, callback?: (err?: NodeJS.ErrnoException) => void): void; export function chmodSync(path: string, mode: number): void; export function chmodSync(path: string, mode: string): void; export function fchmod(fd: number, mode: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function fchmod(fd: number, mode: string, callback?: (err?: NodeJS.ErrnoException) => void): void; export function fchmodSync(fd: number, mode: number): void; export function fchmodSync(fd: number, mode: string): void; export function lchmod(path: string, mode: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function lchmod(path: string, mode: string, callback?: (err?: NodeJS.ErrnoException) => void): void; export function lchmodSync(path: string, mode: number): void; export function lchmodSync(path: string, mode: string): void; export function stat(path: string, callback?: (err: NodeJS.ErrnoException, stats: Stats) => any): void; export function lstat(path: string, callback?: (err: NodeJS.ErrnoException, stats: Stats) => any): void; export function fstat(fd: number, callback?: (err: NodeJS.ErrnoException, stats: Stats) => any): void; export function statSync(path: string): Stats; export function lstatSync(path: string): Stats; export function fstatSync(fd: number): Stats; export function link(srcpath: string, dstpath: string, callback?: (err?: NodeJS.ErrnoException) => void): void; export function linkSync(srcpath: string, dstpath: string): void; export function symlink(srcpath: string, dstpath: string, type?: string, callback?: (err?: NodeJS.ErrnoException) => void): void; export function symlinkSync(srcpath: string, dstpath: string, type?: string): void; export function readlink(path: string, callback?: (err: NodeJS.ErrnoException, linkString: string) => any): void; export function readlinkSync(path: string): string; export function realpath(path: string, callback?: (err: NodeJS.ErrnoException, resolvedPath: string) => any): void; export function realpath(path: string, cache: {[path: string]: string}, callback: (err: NodeJS.ErrnoException, resolvedPath: string) =>any): void; export function realpathSync(path: string, cache?: { [path: string]: string }): string; /* * Asynchronous unlink - deletes the file specified in {path} * * @param path * @param callback No arguments other than a possible exception are given to the completion callback. */ export function unlink(path: string, callback?: (err?: NodeJS.ErrnoException) => void): void; /* * Synchronous unlink - deletes the file specified in {path} * * @param path */ export function unlinkSync(path: string): void; /* * Asynchronous rmdir - removes the directory specified in {path} * * @param path * @param callback No arguments other than a possible exception are given to the completion callback. */ export function rmdir(path: string, callback?: (err?: NodeJS.ErrnoException) => void): void; /* * Synchronous rmdir - removes the directory specified in {path} * * @param path */ export function rmdirSync(path: string): void; /* * Asynchronous mkdir - creates the directory specified in {path}. Parameter {mode} defaults to 0777. * * @param path * @param callback No arguments other than a possible exception are given to the completion callback. */ export function mkdir(path: string, callback?: (err?: NodeJS.ErrnoException) => void): void; /* * Asynchronous mkdir - creates the directory specified in {path}. Parameter {mode} defaults to 0777. * * @param path * @param mode * @param callback No arguments other than a possible exception are given to the completion callback. */ export function mkdir(path: string, mode: number, callback?: (err?: NodeJS.ErrnoException) => void): void; /* * Asynchronous mkdir - creates the directory specified in {path}. Parameter {mode} defaults to 0777. * * @param path * @param mode * @param callback No arguments other than a possible exception are given to the completion callback. */ export function mkdir(path: string, mode: string, callback?: (err?: NodeJS.ErrnoException) => void): void; /* * Synchronous mkdir - creates the directory specified in {path}. Parameter {mode} defaults to 0777. * * @param path * @param mode * @param callback No arguments other than a possible exception are given to the completion callback. */ export function mkdirSync(path: string, mode?: number): void; /* * Synchronous mkdir - creates the directory specified in {path}. Parameter {mode} defaults to 0777. * * @param path * @param mode * @param callback No arguments other than a possible exception are given to the completion callback. */ export function mkdirSync(path: string, mode?: string): void; export function readdir(path: string, callback?: (err: NodeJS.ErrnoException, files: string[]) => void): void; export function readdirSync(path: string): string[]; export function close(fd: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function closeSync(fd: number): void; export function open(path: string, flags: string, callback?: (err: NodeJS.ErrnoException, fd: number) => any): void; export function open(path: string, flags: string, mode: number, callback?: (err: NodeJS.ErrnoException, fd: number) => any): void; export function open(path: string, flags: string, mode: string, callback?: (err: NodeJS.ErrnoException, fd: number) => any): void; export function openSync(path: string, flags: string, mode?: number): number; export function openSync(path: string, flags: string, mode?: string): number; export function utimes(path: string, atime: number, mtime: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function utimes(path: string, atime: Date, mtime: Date, callback?: (err?: NodeJS.ErrnoException) => void): void; export function utimesSync(path: string, atime: number, mtime: number): void; export function utimesSync(path: string, atime: Date, mtime: Date): void; export function futimes(fd: number, atime: number, mtime: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function futimes(fd: number, atime: Date, mtime: Date, callback?: (err?: NodeJS.ErrnoException) => void): void; export function futimesSync(fd: number, atime: number, mtime: number): void; export function futimesSync(fd: number, atime: Date, mtime: Date): void; export function fsync(fd: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function fsyncSync(fd: number): void; export function write(fd: number, buffer: Buffer, offset: number, length: number, position: number, callback?: (err: NodeJS.ErrnoException, written: number, buffer: Buffer) => void): void; export function write(fd: number, buffer: Buffer, offset: number, length: number, callback?: (err: NodeJS.ErrnoException, written: number, buffer: Buffer) => void): void; export function write(fd: number, data: any, callback?: (err: NodeJS.ErrnoException, written: number, str: string) => void): void; export function write(fd: number, data: any, offset: number, callback?: (err: NodeJS.ErrnoException, written: number, str: string) => void): void; export function write(fd: number, data: any, offset: number, encoding: string, callback?: (err: NodeJS.ErrnoException, written: number, str: string) => void): void; export function writeSync(fd: number, buffer: Buffer, offset: number, length: number, position: number): number; export function read(fd: number, buffer: Buffer, offset: number, length: number, position: number, callback?: (err: NodeJS.ErrnoException, bytesRead: number, buffer: Buffer) => void): void; export function readSync(fd: number, buffer: Buffer, offset: number, length: number, position: number): number; /* * Asynchronous readFile - Asynchronously reads the entire contents of a file. * * @param fileName * @param encoding * @param callback - The callback is passed two arguments (err, data), where data is the contents of the file. */ export function readFile(filename: string, encoding: string, callback: (err: NodeJS.ErrnoException, data: string) => void): void; /* * Asynchronous readFile - Asynchronously reads the entire contents of a file. * * @param fileName * @param options An object with optional {encoding} and {flag} properties. If {encoding} is specified, readFile returns a string; otherwise it returns a Buffer. * @param callback - The callback is passed two arguments (err, data), where data is the contents of the file. */ export function readFile(filename: string, options: { encoding: string; flag?: string; }, callback: (err: NodeJS.ErrnoException, data: string) => void): void; /* * Asynchronous readFile - Asynchronously reads the entire contents of a file. * * @param fileName * @param options An object with optional {encoding} and {flag} properties. If {encoding} is specified, readFile returns a string; otherwise it returns a Buffer. * @param callback - The callback is passed two arguments (err, data), where data is the contents of the file. */ export function readFile(filename: string, options: { flag?: string; }, callback: (err: NodeJS.ErrnoException, data: Buffer) => void): void; /* * Asynchronous readFile - Asynchronously reads the entire contents of a file. * * @param fileName * @param callback - The callback is passed two arguments (err, data), where data is the contents of the file. */ export function readFile(filename: string, callback: (err: NodeJS.ErrnoException, data: Buffer) => void): void; /* * Synchronous readFile - Synchronously reads the entire contents of a file. * * @param fileName * @param encoding */ export function readFileSync(filename: string, encoding: string): string; /* * Synchronous readFile - Synchronously reads the entire contents of a file. * * @param fileName * @param options An object with optional {encoding} and {flag} properties. If {encoding} is specified, readFileSync returns a string; otherwise it returns a Buffer. */ export function readFileSync(filename: string, options: { encoding: string; flag?: string; }): string; /* * Synchronous readFile - Synchronously reads the entire contents of a file. * * @param fileName * @param options An object with optional {encoding} and {flag} properties. If {encoding} is specified, readFileSync returns a string; otherwise it returns a Buffer. */ export function readFileSync(filename: string, options?: { flag?: string; }): Buffer; export function writeFile(filename: string, data: any, callback?: (err: NodeJS.ErrnoException) => void): void; export function writeFile(filename: string, data: any, options: { encoding?: string; mode?: number; flag?: string; }, callback?: (err: NodeJS.ErrnoException) => void): void; export function writeFile(filename: string, data: any, options: { encoding?: string; mode?: string; flag?: string; }, callback?: (err: NodeJS.ErrnoException) => void): void; export function writeFileSync(filename: string, data: any, options?: { encoding?: string; mode?: number; flag?: string; }): void; export function writeFileSync(filename: string, data: any, options?: { encoding?: string; mode?: string; flag?: string; }): void; export function appendFile(filename: string, data: any, options: { encoding?: string; mode?: number; flag?: string; }, callback?: (err: NodeJS.ErrnoException) => void): void; export function appendFile(filename: string, data: any, options: { encoding?: string; mode?: string; flag?: string; }, callback?: (err: NodeJS.ErrnoException) => void): void; export function appendFile(filename: string, data: any, callback?: (err: NodeJS.ErrnoException) => void): void; export function appendFileSync(filename: string, data: any, options?: { encoding?: string; mode?: number; flag?: string; }): void; export function appendFileSync(filename: string, data: any, options?: { encoding?: string; mode?: string; flag?: string; }): void; export function watchFile(filename: string, listener: (curr: Stats, prev: Stats) => void): void; export function watchFile(filename: string, options: { persistent?: boolean; interval?: number; }, listener: (curr: Stats, prev: Stats) => void): void; export function unwatchFile(filename: string, listener?: (curr: Stats, prev: Stats) => void): void; export function watch(filename: string, listener?: (event: string, filename: string) => any): FSWatcher; export function watch(filename: string, options: { persistent?: boolean; }, listener?: (event: string, filename: string) => any): FSWatcher; export function exists(path: string, callback?: (exists: boolean) => void): void; export function existsSync(path: string): boolean; /** Constant for fs.access(). File is visible to the calling process. */ export var F_OK: number; /** Constant for fs.access(). File can be read by the calling process. */ export var R_OK: number; /** Constant for fs.access(). File can be written by the calling process. */ export var W_OK: number; /** Constant for fs.access(). File can be executed by the calling process. */ export var X_OK: number; /** Tests a user's permissions for the file specified by path. */ export function access(path: string, callback: (err: NodeJS.ErrnoException) => void): void; export function access(path: string, mode: number, callback: (err: NodeJS.ErrnoException) => void): void; /** Synchronous version of fs.access. This throws if any accessibility checks fail, and does nothing otherwise. */ export function accessSync(path: string, mode ?: number): void; export function createReadStream(path: string, options?: { flags?: string; encoding?: string; fd?: number; mode?: number; autoClose?: boolean; }): ReadStream; export function createWriteStream(path: string, options?: { flags?: string; encoding?: string; fd?: number; mode?: number; }): WriteStream; } declare module "path" { /** * A parsed path object generated by path.parse() or consumed by path.format(). */ export interface ParsedPath { /** * The root of the path such as '/' or 'c:\' */ root: string; /** * The full directory path such as '/home/user/dir' or 'c:\path\dir' */ dir: string; /** * The file name including extension (if any) such as 'index.html' */ base: string; /** * The file extension (if any) such as '.html' */ ext: string; /** * The file name without extension (if any) such as 'index' */ name: string; } /** * Normalize a string path, reducing '..' and '.' parts. * When multiple slashes are found, they're replaced by a single one; when the path contains a trailing slash, it is preserved. On Windows backslashes are used. * * @param p string path to normalize. */ export function normalize(p: string): string; /** * Join all arguments together and normalize the resulting path. * Arguments must be strings. In v0.8, non-string arguments were silently ignored. In v0.10 and up, an exception is thrown. * * @param paths string paths to join. */ export function join(...paths: any[]): string; /** * Join all arguments together and normalize the resulting path. * Arguments must be strings. In v0.8, non-string arguments were silently ignored. In v0.10 and up, an exception is thrown. * * @param paths string paths to join. */ export function join(...paths: string[]): string; /** * The right-most parameter is considered {to}. Other parameters are considered an array of {from}. * * Starting from leftmost {from} paramter, resolves {to} to an absolute path. * * If {to} isn't already absolute, {from} arguments are prepended in right to left order, until an absolute path is found. If after using all {from} paths still no absolute path is found, the current working directory is used as well. The resulting path is normalized, and trailing slashes are removed unless the path gets resolved to the root directory. * * @param pathSegments string paths to join. Non-string arguments are ignored. */ export function resolve(...pathSegments: any[]): string; /** * Determines whether {path} is an absolute path. An absolute path will always resolve to the same location, regardless of the working directory. * * @param path path to test. */ export function isAbsolute(path: string): boolean; /** * Solve the relative path from {from} to {to}. * At times we have two absolute paths, and we need to derive the relative path from one to the other. This is actually the reverse transform of path.resolve. * * @param from * @param to */ export function relative(from: string, to: string): string; /** * Return the directory name of a path. Similar to the Unix dirname command. * * @param p the path to evaluate. */ export function dirname(p: string): string; /** * Return the last portion of a path. Similar to the Unix basename command. * Often used to extract the file name from a fully qualified path. * * @param p the path to evaluate. * @param ext optionally, an extension to remove from the result. */ export function basename(p: string, ext?: string): string; /** * Return the extension of the path, from the last '.' to end of string in the last portion of the path. * If there is no '.' in the last portion of the path or the first character of it is '.', then it returns an empty string * * @param p the path to evaluate. */ export function extname(p: string): string; /** * The platform-specific file separator. '\\' or '/'. */ export var sep: string; /** * The platform-specific file delimiter. ';' or ':'. */ export var delimiter: string; /** * Returns an object from a path string - the opposite of format(). * * @param pathString path to evaluate. */ export function parse(pathString: string): ParsedPath; /** * Returns a path string from an object - the opposite of parse(). * * @param pathString path to evaluate. */ export function format(pathObject: ParsedPath): string; export module posix { export function normalize(p: string): string; export function join(...paths: any[]): string; export function resolve(...pathSegments: any[]): string; export function isAbsolute(p: string): boolean; export function relative(from: string, to: string): string; export function dirname(p: string): string; export function basename(p: string, ext?: string): string; export function extname(p: string): string; export var sep: string; export var delimiter: string; export function parse(p: string): ParsedPath; export function format(pP: ParsedPath): string; } export module win32 { export function normalize(p: string): string; export function join(...paths: any[]): string; export function resolve(...pathSegments: any[]): string; export function isAbsolute(p: string): boolean; export function relative(from: string, to: string): string; export function dirname(p: string): string; export function basename(p: string, ext?: string): string; export function extname(p: string): string; export var sep: string; export var delimiter: string; export function parse(p: string): ParsedPath; export function format(pP: ParsedPath): string; } } declare module "string_decoder" { export interface NodeStringDecoder { write(buffer: Buffer): string; detectIncompleteChar(buffer: Buffer): number; } export var StringDecoder: { new (encoding: string): NodeStringDecoder; }; } declare module "tls" { import * as crypto from "crypto"; import * as net from "net"; import * as stream from "stream"; var CLIENT_RENEG_LIMIT: number; var CLIENT_RENEG_WINDOW: number; export interface TlsOptions { host?: string; port?: number; pfx?: any; //string or buffer key?: any; //string or buffer passphrase?: string; cert?: any; ca?: any; //string or buffer crl?: any; //string or string array ciphers?: string; honorCipherOrder?: any; requestCert?: boolean; rejectUnauthorized?: boolean; NPNProtocols?: any; //array or Buffer; SNICallback?: (servername: string) => any; } export interface ConnectionOptions { host?: string; port?: number; socket?: net.Socket; pfx?: any; //string | Buffer key?: any; //string | Buffer passphrase?: string; cert?: any; //string | Buffer ca?: any; //Array of string | Buffer rejectUnauthorized?: boolean; NPNProtocols?: any; //Array of string | Buffer servername?: string; } export interface Server extends net.Server { // Extended base methods listen(port: number, host?: string, backlog?: number, listeningListener?: Function): Server; listen(path: string, listeningListener?: Function): Server; listen(handle: any, listeningListener?: Function): Server; listen(port: number, host?: string, callback?: Function): Server; close(): Server; address(): { port: number; family: string; address: string; }; addContext(hostName: string, credentials: { key: string; cert: string; ca: string; }): void; maxConnections: number; connections: number; } export interface ClearTextStream extends stream.Duplex { authorized: boolean; authorizationError: Error; getPeerCertificate(): any; getCipher: { name: string; version: string; }; address: { port: number; family: string; address: string; }; remoteAddress: string; remotePort: number; } export interface SecurePair { encrypted: any; cleartext: any; } export interface SecureContextOptions { pfx?: any; //string | buffer key?: any; //string | buffer passphrase?: string; cert?: any; // string | buffer ca?: any; // string | buffer crl?: any; // string | string[] ciphers?: string; honorCipherOrder?: boolean; } export interface SecureContext { context: any; } export function createServer(options: TlsOptions, secureConnectionListener?: (cleartextStream: ClearTextStream) =>void ): Server; export function connect(options: TlsOptions, secureConnectionListener?: () =>void ): ClearTextStream; export function connect(port: number, host?: string, options?: ConnectionOptions, secureConnectListener?: () =>void ): ClearTextStream; export function connect(port: number, options?: ConnectionOptions, secureConnectListener?: () =>void ): ClearTextStream; export function createSecurePair(credentials?: crypto.Credentials, isServer?: boolean, requestCert?: boolean, rejectUnauthorized?: boolean): SecurePair; export function createSecureContext(details: SecureContextOptions): SecureContext; } declare module "crypto" { export interface CredentialDetails { pfx: string; key: string; passphrase: string; cert: string; ca: any; //string | string array crl: any; //string | string array ciphers: string; } export interface Credentials { context?: any; } export function createCredentials(details: CredentialDetails): Credentials; export function createHash(algorithm: string): Hash; export function createHmac(algorithm: string, key: string): Hmac; export function createHmac(algorithm: string, key: Buffer): Hmac; export interface Hash { update(data: any, input_encoding?: string): Hash; digest(encoding: 'buffer'): Buffer; digest(encoding: string): any; digest(): Buffer; } export interface Hmac extends NodeJS.ReadWriteStream { update(data: any, input_encoding?: string): Hmac; digest(encoding: 'buffer'): Buffer; digest(encoding: string): any; digest(): Buffer; } export function createCipher(algorithm: string, password: any): Cipher; export function createCipheriv(algorithm: string, key: any, iv: any): Cipher; export interface Cipher { update(data: Buffer): Buffer; update(data: string, input_encoding?: string, output_encoding?: string): string; final(): Buffer; final(output_encoding: string): string; setAutoPadding(auto_padding: boolean): void; } export function createDecipher(algorithm: string, password: any): Decipher; export function createDecipheriv(algorithm: string, key: any, iv: any): Decipher; export interface Decipher { update(data: Buffer): Buffer; update(data: string, input_encoding?: string, output_encoding?: string): string; final(): Buffer; final(output_encoding: string): string; setAutoPadding(auto_padding: boolean): void; } export function createSign(algorithm: string): Signer; export interface Signer extends NodeJS.WritableStream { update(data: any): void; sign(private_key: string, output_format: string): string; } export function createVerify(algorith: string): Verify; export interface Verify extends NodeJS.WritableStream { update(data: any): void; verify(object: string, signature: string, signature_format?: string): boolean; } export function createDiffieHellman(prime_length: number): DiffieHellman; export function createDiffieHellman(prime: number, encoding?: string): DiffieHellman; export interface DiffieHellman { generateKeys(encoding?: string): string; computeSecret(other_public_key: string, input_encoding?: string, output_encoding?: string): string; getPrime(encoding?: string): string; getGenerator(encoding: string): string; getPublicKey(encoding?: string): string; getPrivateKey(encoding?: string): string; setPublicKey(public_key: string, encoding?: string): void; setPrivateKey(public_key: string, encoding?: string): void; } export function getDiffieHellman(group_name: string): DiffieHellman; export function pbkdf2(password: string|Buffer, salt: string|Buffer, iterations: number, keylen: number, callback: (err: Error, derivedKey: Buffer) => any): void; export function pbkdf2(password: string|Buffer, salt: string|Buffer, iterations: number, keylen: number, digest: string, callback: (err: Error, derivedKey: Buffer) => any): void; export function pbkdf2Sync(password: string|Buffer, salt: string|Buffer, iterations: number, keylen: number) : Buffer; export function pbkdf2Sync(password: string|Buffer, salt: string|Buffer, iterations: number, keylen: number, digest: string) : Buffer; export function randomBytes(size: number): Buffer; export function randomBytes(size: number, callback: (err: Error, buf: Buffer) =>void ): void; export function pseudoRandomBytes(size: number): Buffer; export function pseudoRandomBytes(size: number, callback: (err: Error, buf: Buffer) =>void ): void; export interface RsaPublicKey { key: string; padding?: any; } export interface RsaPrivateKey { key: string; passphrase?: string, padding?: any; } export function publicEncrypt(public_key: string|RsaPublicKey, buffer: Buffer): Buffer export function privateDecrypt(private_key: string|RsaPrivateKey, buffer: Buffer): Buffer } declare module "stream" { import * as events from "events"; export class Stream extends events.EventEmitter { pipe(destination: T, options?: { end?: boolean; }): T; } export interface ReadableOptions { highWaterMark?: number; encoding?: string; objectMode?: boolean; } export class Readable extends events.EventEmitter implements NodeJS.ReadableStream { readable: boolean; constructor(opts?: ReadableOptions); _read(size: number): void; read(size?: number): any; setEncoding(encoding: string): void; pause(): void; resume(): void; pipe(destination: T, options?: { end?: boolean; }): T; unpipe(destination?: T): void; unshift(chunk: any): void; wrap(oldStream: NodeJS.ReadableStream): NodeJS.ReadableStream; push(chunk: any, encoding?: string): boolean; } export interface WritableOptions { highWaterMark?: number; decodeStrings?: boolean; objectMode?: boolean; } export class Writable extends events.EventEmitter implements NodeJS.WritableStream { writable: boolean; constructor(opts?: WritableOptions); _write(chunk: any, encoding: string, callback: Function): void; write(chunk: any, cb?: Function): boolean; write(chunk: any, encoding?: string, cb?: Function): boolean; end(): void; end(chunk: any, cb?: Function): void; end(chunk: any, encoding?: string, cb?: Function): void; } export interface DuplexOptions extends ReadableOptions, WritableOptions { allowHalfOpen?: boolean; } // Note: Duplex extends both Readable and Writable. export class Duplex extends Readable implements NodeJS.ReadWriteStream { writable: boolean; constructor(opts?: DuplexOptions); _write(chunk: any, encoding: string, callback: Function): void; write(chunk: any, cb?: Function): boolean; write(chunk: any, encoding?: string, cb?: Function): boolean; end(): void; end(chunk: any, cb?: Function): void; end(chunk: any, encoding?: string, cb?: Function): void; } export interface TransformOptions extends ReadableOptions, WritableOptions {} // Note: Transform lacks the _read and _write methods of Readable/Writable. export class Transform extends events.EventEmitter implements NodeJS.ReadWriteStream { readable: boolean; writable: boolean; constructor(opts?: TransformOptions); _transform(chunk: any, encoding: string, callback: Function): void; _flush(callback: Function): void; read(size?: number): any; setEncoding(encoding: string): void; pause(): void; resume(): void; pipe(destination: T, options?: { end?: boolean; }): T; unpipe(destination?: T): void; unshift(chunk: any): void; wrap(oldStream: NodeJS.ReadableStream): NodeJS.ReadableStream; push(chunk: any, encoding?: string): boolean; write(chunk: any, cb?: Function): boolean; write(chunk: any, encoding?: string, cb?: Function): boolean; end(): void; end(chunk: any, cb?: Function): void; end(chunk: any, encoding?: string, cb?: Function): void; } export class PassThrough extends Transform {} } declare module "util" { export interface InspectOptions { showHidden?: boolean; depth?: number; colors?: boolean; customInspect?: boolean; } export function format(format: any, ...param: any[]): string; export function debug(string: string): void; export function error(...param: any[]): void; export function puts(...param: any[]): void; export function print(...param: any[]): void; export function log(string: string): void; export function inspect(object: any, showHidden?: boolean, depth?: number, color?: boolean): string; export function inspect(object: any, options: InspectOptions): string; export function isArray(object: any): boolean; export function isRegExp(object: any): boolean; export function isDate(object: any): boolean; export function isError(object: any): boolean; export function inherits(constructor: any, superConstructor: any): void; export function debuglog(key:string): (msg:string,...param: any[])=>void; } declare module "assert" { function internal (value: any, message?: string): void; module internal { export class AssertionError implements Error { name: string; message: string; actual: any; expected: any; operator: string; generatedMessage: boolean; constructor(options?: {message?: string; actual?: any; expected?: any; operator?: string; stackStartFunction?: Function}); } export function fail(actual?: any, expected?: any, message?: string, operator?: string): void; export function ok(value: any, message?: string): void; export function equal(actual: any, expected: any, message?: string): void; export function notEqual(actual: any, expected: any, message?: string): void; export function deepEqual(actual: any, expected: any, message?: string): void; export function notDeepEqual(acutal: any, expected: any, message?: string): void; export function strictEqual(actual: any, expected: any, message?: string): void; export function notStrictEqual(actual: any, expected: any, message?: string): void; export function deepStrictEqual(actual: any, expected: any, message?: string): void; export function notDeepStrictEqual(actual: any, expected: any, message?: string): void; export var throws: { (block: Function, message?: string): void; (block: Function, error: Function, message?: string): void; (block: Function, error: RegExp, message?: string): void; (block: Function, error: (err: any) => boolean, message?: string): void; }; export var doesNotThrow: { (block: Function, message?: string): void; (block: Function, error: Function, message?: string): void; (block: Function, error: RegExp, message?: string): void; (block: Function, error: (err: any) => boolean, message?: string): void; }; export function ifError(value: any): void; } export = internal; } declare module "tty" { import * as net from "net"; export function isatty(fd: number): boolean; export interface ReadStream extends net.Socket { isRaw: boolean; setRawMode(mode: boolean): void; isTTY: boolean; } export interface WriteStream extends net.Socket { columns: number; rows: number; isTTY: boolean; } } declare module "domain" { import * as events from "events"; export class Domain extends events.EventEmitter { run(fn: Function): void; add(emitter: events.EventEmitter): void; remove(emitter: events.EventEmitter): void; bind(cb: (err: Error, data: any) => any): any; intercept(cb: (data: any) => any): any; dispose(): void; addListener(event: string, listener: Function): Domain; on(event: string, listener: Function): Domain; once(event: string, listener: Function): Domain; removeListener(event: string, listener: Function): Domain; removeAllListeners(event?: string): Domain; } export function create(): Domain; } declare module "constants" { export var E2BIG: number; export var EACCES: number; export var EADDRINUSE: number; export var EADDRNOTAVAIL: number; export var EAFNOSUPPORT: number; export var EAGAIN: number; export var EALREADY: number; export var EBADF: number; export var EBADMSG: number; export var EBUSY: number; export var ECANCELED: number; export var ECHILD: number; export var ECONNABORTED: number; export var ECONNREFUSED: number; export var ECONNRESET: number; export var EDEADLK: number; export var EDESTADDRREQ: number; export var EDOM: number; export var EEXIST: number; export var EFAULT: number; export var EFBIG: number; export var EHOSTUNREACH: number; export var EIDRM: number; export var EILSEQ: number; export var EINPROGRESS: number; export var EINTR: number; export var EINVAL: number; export var EIO: number; export var EISCONN: number; export var EISDIR: number; export var ELOOP: number; export var EMFILE: number; export var EMLINK: number; export var EMSGSIZE: number; export var ENAMETOOLONG: number; export var ENETDOWN: number; export var ENETRESET: number; export var ENETUNREACH: number; export var ENFILE: number; export var ENOBUFS: number; export var ENODATA: number; export var ENODEV: number; export var ENOENT: number; export var ENOEXEC: number; export var ENOLCK: number; export var ENOLINK: number; export var ENOMEM: number; export var ENOMSG: number; export var ENOPROTOOPT: number; export var ENOSPC: number; export var ENOSR: number; export var ENOSTR: number; export var ENOSYS: number; export var ENOTCONN: number; export var ENOTDIR: number; export var ENOTEMPTY: number; export var ENOTSOCK: number; export var ENOTSUP: number; export var ENOTTY: number; export var ENXIO: number; export var EOPNOTSUPP: number; export var EOVERFLOW: number; export var EPERM: number; export var EPIPE: number; export var EPROTO: number; export var EPROTONOSUPPORT: number; export var EPROTOTYPE: number; export var ERANGE: number; export var EROFS: number; export var ESPIPE: number; export var ESRCH: number; export var ETIME: number; export var ETIMEDOUT: number; export var ETXTBSY: number; export var EWOULDBLOCK: number; export var EXDEV: number; export var WSAEINTR: number; export var WSAEBADF: number; export var WSAEACCES: number; export var WSAEFAULT: number; export var WSAEINVAL: number; export var WSAEMFILE: number; export var WSAEWOULDBLOCK: number; export var WSAEINPROGRESS: number; export var WSAEALREADY: number; export var WSAENOTSOCK: number; export var WSAEDESTADDRREQ: number; export var WSAEMSGSIZE: number; export var WSAEPROTOTYPE: number; export var WSAENOPROTOOPT: number; export var WSAEPROTONOSUPPORT: number; export var WSAESOCKTNOSUPPORT: number; export var WSAEOPNOTSUPP: number; export var WSAEPFNOSUPPORT: number; export var WSAEAFNOSUPPORT: number; export var WSAEADDRINUSE: number; export var WSAEADDRNOTAVAIL: number; export var WSAENETDOWN: number; export var WSAENETUNREACH: number; export var WSAENETRESET: number; export var WSAECONNABORTED: number; export var WSAECONNRESET: number; export var WSAENOBUFS: number; export var WSAEISCONN: number; export var WSAENOTCONN: number; export var WSAESHUTDOWN: number; export var WSAETOOMANYREFS: number; export var WSAETIMEDOUT: number; export var WSAECONNREFUSED: number; export var WSAELOOP: number; export var WSAENAMETOOLONG: number; export var WSAEHOSTDOWN: number; export var WSAEHOSTUNREACH: number; export var WSAENOTEMPTY: number; export var WSAEPROCLIM: number; export var WSAEUSERS: number; export var WSAEDQUOT: number; export var WSAESTALE: number; export var WSAEREMOTE: number; export var WSASYSNOTREADY: number; export var WSAVERNOTSUPPORTED: number; export var WSANOTINITIALISED: number; export var WSAEDISCON: number; export var WSAENOMORE: number; export var WSAECANCELLED: number; export var WSAEINVALIDPROCTABLE: number; export var WSAEINVALIDPROVIDER: number; export var WSAEPROVIDERFAILEDINIT: number; export var WSASYSCALLFAILURE: number; export var WSASERVICE_NOT_FOUND: number; export var WSATYPE_NOT_FOUND: number; export var WSA_E_NO_MORE: number; export var WSA_E_CANCELLED: number; export var WSAEREFUSED: number; export var SIGHUP: number; export var SIGINT: number; export var SIGILL: number; export var SIGABRT: number; export var SIGFPE: number; export var SIGKILL: number; export var SIGSEGV: number; export var SIGTERM: number; export var SIGBREAK: number; export var SIGWINCH: number; export var SSL_OP_ALL: number; export var SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION: number; export var SSL_OP_CIPHER_SERVER_PREFERENCE: number; export var SSL_OP_CISCO_ANYCONNECT: number; export var SSL_OP_COOKIE_EXCHANGE: number; export var SSL_OP_CRYPTOPRO_TLSEXT_BUG: number; export var SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS: number; export var SSL_OP_EPHEMERAL_RSA: number; export var SSL_OP_LEGACY_SERVER_CONNECT: number; export var SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER: number; export var SSL_OP_MICROSOFT_SESS_ID_BUG: number; export var SSL_OP_MSIE_SSLV2_RSA_PADDING: number; export var SSL_OP_NETSCAPE_CA_DN_BUG: number; export var SSL_OP_NETSCAPE_CHALLENGE_BUG: number; export var SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG: number; export var SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG: number; export var SSL_OP_NO_COMPRESSION: number; export var SSL_OP_NO_QUERY_MTU: number; export var SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION: number; export var SSL_OP_NO_SSLv2: number; export var SSL_OP_NO_SSLv3: number; export var SSL_OP_NO_TICKET: number; export var SSL_OP_NO_TLSv1: number; export var SSL_OP_NO_TLSv1_1: number; export var SSL_OP_NO_TLSv1_2: number; export var SSL_OP_PKCS1_CHECK_1: number; export var SSL_OP_PKCS1_CHECK_2: number; export var SSL_OP_SINGLE_DH_USE: number; export var SSL_OP_SINGLE_ECDH_USE: number; export var SSL_OP_SSLEAY_080_CLIENT_DH_BUG: number; export var SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG: number; export var SSL_OP_TLS_BLOCK_PADDING_BUG: number; export var SSL_OP_TLS_D5_BUG: number; export var SSL_OP_TLS_ROLLBACK_BUG: number; export var ENGINE_METHOD_DSA: number; export var ENGINE_METHOD_DH: number; export var ENGINE_METHOD_RAND: number; export var ENGINE_METHOD_ECDH: number; export var ENGINE_METHOD_ECDSA: number; export var ENGINE_METHOD_CIPHERS: number; export var ENGINE_METHOD_DIGESTS: number; export var ENGINE_METHOD_STORE: number; export var ENGINE_METHOD_PKEY_METHS: number; export var ENGINE_METHOD_PKEY_ASN1_METHS: number; export var ENGINE_METHOD_ALL: number; export var ENGINE_METHOD_NONE: number; export var DH_CHECK_P_NOT_SAFE_PRIME: number; export var DH_CHECK_P_NOT_PRIME: number; export var DH_UNABLE_TO_CHECK_GENERATOR: number; export var DH_NOT_SUITABLE_GENERATOR: number; export var NPN_ENABLED: number; export var RSA_PKCS1_PADDING: number; export var RSA_SSLV23_PADDING: number; export var RSA_NO_PADDING: number; export var RSA_PKCS1_OAEP_PADDING: number; export var RSA_X931_PADDING: number; export var RSA_PKCS1_PSS_PADDING: number; export var POINT_CONVERSION_COMPRESSED: number; export var POINT_CONVERSION_UNCOMPRESSED: number; export var POINT_CONVERSION_HYBRID: number; export var O_RDONLY: number; export var O_WRONLY: number; export var O_RDWR: number; export var S_IFMT: number; export var S_IFREG: number; export var S_IFDIR: number; export var S_IFCHR: number; export var S_IFLNK: number; export var O_CREAT: number; export var O_EXCL: number; export var O_TRUNC: number; export var O_APPEND: number; export var F_OK: number; export var R_OK: number; export var W_OK: number; export var X_OK: number; export var UV_UDP_REUSEADDR: number; }WebDevelopment-assignment-2/typings/browser/definitions/000077500000000000000000000000001266350324300240025ustar00rootroot00000000000000WebDevelopment-assignment-2/typings/browser/definitions/gulp/000077500000000000000000000000001266350324300247515ustar00rootroot00000000000000WebDevelopment-assignment-2/typings/browser/definitions/gulp/gulp.d.ts000066400000000000000000000504661266350324300265250ustar00rootroot00000000000000// Compiled using typings@0.6.8 // Source: https://raw.githubusercontent.com/typed-typings/npm-es6-promise/fb04188767acfec1defd054fc8024fafa5cd4de7/dist/es6-promise.d.ts declare module 'gulp~orchestrator~es6-promise/dist/es6-promise' { export interface Thenable { then (onFulfilled?: (value: R) => U | Thenable, onRejected?: (error: any) => U | Thenable): Thenable; then (onFulfilled?: (value: R) => U | Thenable, onRejected?: (error: any) => void): Thenable; } export class Promise implements Thenable { /** * If you call resolve in the body of the callback passed to the constructor, * your promise is fulfilled with result object passed to resolve. * If you call reject your promise is rejected with the object passed to resolve. * For consistency and debugging (eg stack traces), obj should be an instanceof Error. * Any errors thrown in the constructor callback will be implicitly passed to reject(). */ constructor (callback: (resolve : (value?: R | Thenable) => void, reject: (error?: any) => void) => void); /** * onFulfilled is called when/if "promise" resolves. onRejected is called when/if "promise" rejects. * Both are optional, if either/both are omitted the next onFulfilled/onRejected in the chain is called. * Both callbacks have a single parameter , the fulfillment value or rejection reason. * "then" returns a new promise equivalent to the value you return from onFulfilled/onRejected after being passed through Promise.resolve. * If an error is thrown in the callback, the returned promise rejects with that error. * * @param onFulfilled called when/if "promise" resolves * @param onRejected called when/if "promise" rejects */ then (onFulfilled?: (value: R) => U | Thenable, onRejected?: (error: any) => U | Thenable): Promise; then (onFulfilled?: (value: R) => U | Thenable, onRejected?: (error: any) => void): Promise; /** * Sugar for promise.then(undefined, onRejected) * * @param onRejected called when/if "promise" rejects */ catch (onRejected?: (error: any) => U | Thenable): Promise; /** * Make a new promise from the thenable. * A thenable is promise-like in as far as it has a "then" method. */ static resolve (): Promise; static resolve (value: R | Thenable): Promise; /** * Make a promise that rejects to obj. For consistency and debugging (eg stack traces), obj should be an instanceof Error */ static reject (error: any): Promise; /** * Make a promise that fulfills when every item in the array fulfills, and rejects if (and when) any item rejects. * the array passed to all can be a mixture of promise-like objects and other objects. * The fulfillment value is an array (in order) of fulfillment values. The rejection value is the first rejection value. */ static all(values: [T1 | Thenable, T2 | Thenable, T3 | Thenable, T4 | Thenable , T5 | Thenable, T6 | Thenable, T7 | Thenable, T8 | Thenable, T9 | Thenable, T10 | Thenable]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>; static all(values: [T1 | Thenable, T2 | Thenable, T3 | Thenable, T4 | Thenable , T5 | Thenable, T6 | Thenable, T7 | Thenable, T8 | Thenable, T9 | Thenable]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>; static all(values: [T1 | Thenable, T2 | Thenable, T3 | Thenable, T4 | Thenable , T5 | Thenable, T6 | Thenable, T7 | Thenable, T8 | Thenable]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8]>; static all(values: [T1 | Thenable, T2 | Thenable, T3 | Thenable, T4 | Thenable , T5 | Thenable, T6 | Thenable, T7 | Thenable]): Promise<[T1, T2, T3, T4, T5, T6, T7]>; static all(values: [T1 | Thenable, T2 | Thenable, T3 | Thenable, T4 | Thenable , T5 | Thenable, T6 | Thenable]): Promise<[T1, T2, T3, T4, T5, T6]>; static all(values: [T1 | Thenable, T2 | Thenable, T3 | Thenable, T4 | Thenable , T5 | Thenable]): Promise<[T1, T2, T3, T4, T5]>; static all(values: [T1 | Thenable, T2 | Thenable, T3 | Thenable, T4 | Thenable ]): Promise<[T1, T2, T3, T4]>; static all(values: [T1 | Thenable, T2 | Thenable, T3 | Thenable]): Promise<[T1, T2, T3]>; static all(values: [T1 | Thenable, T2 | Thenable]): Promise<[T1, T2]>; static all(values: [T1 | Thenable]): Promise<[T1]>; static all(values: Array>): Promise; /** * Make a Promise that fulfills when any item fulfills, and rejects if any item rejects. */ static race (promises: (R | Thenable)[]): Promise; } /** * The polyfill method will patch the global environment (in this case to the Promise name) when called. */ export function polyfill (): void; } declare module 'gulp~orchestrator~es6-promise' { export * from 'gulp~orchestrator~es6-promise/dist/es6-promise'; } // Compiled using typings@0.6.8 // Source: https://raw.githubusercontent.com/typed-typings/npm-orchestrator/bd916c96d6d8e946bc73772fc3854accd5860aa4/orchestrator.d.ts declare module 'gulp~orchestrator/orchestrator' { // Type definitions for Orchestrator // Project: https://github.com/orchestrator/orchestrator // Definitions by: Qubo // Definitions: https://github.com/borisyankov/DefinitelyTyped import { Promise } from 'gulp~orchestrator~es6-promise'; type Strings = string | string[]; class Orchestrator { add: Orchestrator.AddMethod; /** * Have you defined a task with this name? * @param name The task name to query */ hasTask(name: string): boolean; start: Orchestrator.StartMethod; stop(): void; /** * Listen to orchestrator internals * @param event Event name to listen to: *
    *
  • start: from start() method, shows you the task sequence *
  • stop: from stop() method, the queue finished successfully *
  • err: from stop() method, the queue was aborted due to a task error *
  • task_start: from _runTask() method, task was started *
  • task_stop: from _runTask() method, task completed successfully *
  • task_err: from _runTask() method, task errored *
  • task_not_found: from start() method, you're trying to start a task that doesn't exist *
  • task_recursion: from start() method, there are recursive dependencies in your task list *
* @param cb Passes single argument: e: event details */ on(event: string, cb: (e: Orchestrator.OnCallbackEvent) => any): Orchestrator; /** * Listen to all orchestrator events from one callback * @param cb Passes single argument: e: event details */ onAll(cb: (e: Orchestrator.OnAllCallbackEvent) => any): void; } namespace Orchestrator { interface AddMethodCallback { /** * Accept a callback * @param callback */ (callback?: Function): any; /** * Return a promise */ (): Promise; /** * Return a stream: (task is marked complete when stream ends) */ (): any; //TODO: stream type should be here e.g. map-stream } /** * Define a task */ interface AddMethod { /** * Define a task * @param name The name of the task. * @param deps An array of task names to be executed and completed before your task will run. * @param fn The function that performs the task's operations. For asynchronous tasks, you need to provide a hint when the task is complete: *
    *
  • Take in a callback
    • *
  • Return a stream or a promise
    • *
*/ (name: string, deps?: string[], fn?: AddMethodCallback | Function): Orchestrator; /** * Define a task * @param name The name of the task. * @param fn The function that performs the task's operations. For asynchronous tasks, you need to provide a hint when the task is complete: *
    *
  • Take in a callback
    • *
  • Return a stream or a promise
    • *
*/ (name: string, fn?: AddMethodCallback | Function): Orchestrator; } /** * Start running the tasks */ interface StartMethod { /** * Start running the tasks * @param tasks Tasks to be executed. You may pass any number of tasks as individual arguments. * @param cb Callback to call after run completed. */ (tasks: Strings, cb?: (error?: any) => any): Orchestrator; /** * Start running the tasks * @param tasks Tasks to be executed. You may pass any number of tasks as individual arguments. * @param cb Callback to call after run completed. */ (...tasks: Strings[]/*, cb?: (error: any) => any */): Orchestrator; //TODO: TypeScript 1.5.3 cannot express varargs followed by callback as a last argument... (task1: Strings, task2: Strings, cb?: (error?: any) => any): Orchestrator; (task1: Strings, task2: Strings, task3: Strings, cb?: (error?: any) => any): Orchestrator; (task1: Strings, task2: Strings, task3: Strings, task4: Strings, cb?: (error?: any) => any): Orchestrator; (task1: Strings, task2: Strings, task3: Strings, task4: Strings, task5: Strings, cb?: (error?: any) => any): Orchestrator; (task1: Strings, task2: Strings, task3: Strings, task4: Strings, task5: Strings, task6: Strings, cb?: (error?: any) => any): Orchestrator; } interface OnCallbackEvent { message: string; task: string; err: any; duration?: number; } interface OnAllCallbackEvent extends OnCallbackEvent { src: string; } } export = Orchestrator; } declare module 'gulp~orchestrator' { import main = require('gulp~orchestrator/orchestrator'); export = main; } // Compiled using typings@0.6.8 // Source: https://raw.githubusercontent.com/typed-typings/npm-gulp/504da08753acdfe9dd2c415ab8fe36151e9645c1/gulp.d.ts declare module 'gulp/gulp' { // Type definitions for Gulp v3.8.x // Project: http://gulpjs.com // Original Definitions by: Drew Noakes import Orchestrator = require('gulp~orchestrator'); import { EventEmitter } from 'events'; import { Duplex } from 'stream'; module gulp { interface Gulp extends Orchestrator { /** * Define a task * @param name The name of the task. * @param deps An array of task names to be executed and completed before your task will run. * @param fn The function that performs the task's operations. For asynchronous tasks, you need to provide a hint when the task is complete: *
    *
  • Take in a callback
    • *
  • Return a stream or a promise
    • *
*/ task: Orchestrator.AddMethod; /** * Emits files matching provided glob or an array of globs. Returns a stream of Vinyl files that can be piped to plugins. * @param glob Glob or array of globs to read. * @param opt Options to pass to node-glob through glob-stream. */ src: SrcMethod; /** * Can be piped to and it will write files. Re-emits all data passed to it so you can pipe to multiple folders. * Folders that don't exist will be created. * * @param outFolder The path (output folder) to write files to. Or a function that returns it, the function will be provided a vinyl File instance. * @param opt */ dest: DestMethod; /** * Watch files and do something when a file changes. This always returns an EventEmitter that emits change events. * * @param glob a single glob or array of globs that indicate which files to watch for changes. * @param opt options, that are passed to the gaze library. * @param fn a callback or array of callbacks to be called on each change, or names of task(s) to run when a file changes, added with task(). */ watch: WatchMethod; } interface GulpPlugin { (...args: any[]): Duplex; } interface WatchMethod { /** * Watch files and do something when a file changes. This always returns an EventEmitter that emits change events. * * @param glob a single glob or array of globs that indicate which files to watch for changes. * @param fn a callback or array of callbacks to be called on each change, or names of task(s) to run when a file changes, added with task(). */ (glob: string | string[], fn: (WatchCallback | string)): EventEmitter; /** * Watch files and do something when a file changes. This always returns an EventEmitter that emits change events. * * @param glob a single glob or array of globs that indicate which files to watch for changes. * @param fn a callback or array of callbacks to be called on each change, or names of task(s) to run when a file changes, added with task(). */ (glob: string | string[], fn: (WatchCallback | string)[]): EventEmitter; /** * Watch files and do something when a file changes. This always returns an EventEmitter that emits change events. * * @param glob a single glob or array of globs that indicate which files to watch for changes. * @param opt options, that are passed to the gaze library. * @param fn a callback or array of callbacks to be called on each change, or names of task(s) to run when a file changes, added with task(). */ (glob: string | string[], opt: WatchOptions, fn: (WatchCallback | string)): EventEmitter; /** * Watch files and do something when a file changes. This always returns an EventEmitter that emits change events. * * @param glob a single glob or array of globs that indicate which files to watch for changes. * @param opt options, that are passed to the gaze library. * @param fn a callback or array of callbacks to be called on each change, or names of task(s) to run when a file changes, added with task(). */ (glob: string | string[], opt: WatchOptions, fn: (WatchCallback | string)[]): EventEmitter; } interface DestMethod { /** * Can be piped to and it will write files. Re-emits all data passed to it so you can pipe to multiple folders. * Folders that don't exist will be created. * * @param outFolder The path (output folder) to write files to. Or a function that returns it, the function will be provided a vinyl File instance. * @param opt */ (outFolder: string | ((file: string) => string), opt?: DestOptions): Duplex; } interface SrcMethod { /** * Emits files matching provided glob or an array of globs. Returns a stream of Vinyl files that can be piped to plugins. * @param glob Glob or array of globs to read. * @param opt Options to pass to node-glob through glob-stream. */ (glob: string | string[], opt?: SrcOptions): Duplex; } /** * Options to pass to node-glob through glob-stream. * Specifies two options in addition to those used by node-glob: * https://github.com/isaacs/node-glob#options */ interface SrcOptions { /** * Setting this to false will return file.contents as null * and not read the file at all. * Default: true. */ read?: boolean; /** * Setting this to false will return file.contents as a stream and not buffer files. * This is useful when working with large files. * Note: Plugins might not implement support for streams. * Default: true. */ buffer?: boolean; /** * The base path of a glob. * * Default is everything before a glob starts. */ base?: string; /** * The current working directory in which to search. * Defaults to process.cwd(). */ cwd?: string; /** * The place where patterns starting with / will be mounted onto. * Defaults to path.resolve(options.cwd, "/") (/ on Unix systems, and C:\ or some such on Windows.) */ root?: string; /** * Include .dot files in normal matches and globstar matches. * Note that an explicit dot in a portion of the pattern will always match dot files. */ dot?: boolean; /** * By default, a pattern starting with a forward-slash will be "mounted" onto the root setting, so that a valid * filesystem path is returned. Set this flag to disable that behavior. */ nomount?: boolean; /** * Add a / character to directory matches. Note that this requires additional stat calls. */ mark?: boolean; /** * Don't sort the results. */ nosort?: boolean; /** * Set to true to stat all results. This reduces performance somewhat, and is completely unnecessary, unless * readdir is presumed to be an untrustworthy indicator of file existence. It will cause ELOOP to be triggered one * level sooner in the case of cyclical symbolic links. */ stat?: boolean; /** * When an unusual error is encountered when attempting to read a directory, a warning will be printed to stderr. * Set the silent option to true to suppress these warnings. */ silent?: boolean; /** * When an unusual error is encountered when attempting to read a directory, the process will just continue on in * search of other matches. Set the strict option to raise an error in these cases. */ strict?: boolean; /** * See cache property above. Pass in a previously generated cache object to save some fs calls. */ cache?: boolean; /** * A cache of results of filesystem information, to prevent unnecessary stat calls. * While it should not normally be necessary to set this, you may pass the statCache from one glob() call to the * options object of another, if you know that the filesystem will not change between calls. */ statCache?: boolean; /** * Perform a synchronous glob search. */ sync?: boolean; /** * In some cases, brace-expanded patterns can result in the same file showing up multiple times in the result set. * By default, this implementation prevents duplicates in the result set. Set this flag to disable that behavior. */ nounique?: boolean; /** * Set to never return an empty set, instead returning a set containing the pattern itself. * This is the default in glob(3). */ nonull?: boolean; /** * Perform a case-insensitive match. Note that case-insensitive filesystems will sometimes result in glob returning * results that are case-insensitively matched anyway, since readdir and stat will not raise an error. */ nocase?: boolean; /** * Set to enable debug logging in minimatch and glob. */ debug?: boolean; /** * Set to enable debug logging in glob, but not minimatch. */ globDebug?: boolean; } interface DestOptions { /** * The output folder. Only has an effect if provided output folder is relative. * Default: process.cwd() */ cwd?: string; /** * Octal permission string specifying mode for any folders that need to be created for output folder. * Default: 0777. */ mode?: string; } /** * Options that are passed to gaze. * https://github.com/shama/gaze */ interface WatchOptions { /** Interval to pass to fs.watchFile. */ interval?: number; /** Delay for events called in succession for the same file/event. */ debounceDelay?: number; /** Force the watch mode. Either 'auto' (default), 'watch' (force native events), or 'poll' (force stat polling). */ mode?: string; /** The current working directory to base file patterns from. Default is process.cwd().. */ cwd?: string; } interface WatchEvent { /** The type of change that occurred, either added, changed or deleted. */ type: string; /** The path to the file that triggered the event. */ path: string; } /** * Callback to be called on each watched file change. */ interface WatchCallback { (event: WatchEvent): void; } interface TaskCallback { /** * Defines a task. * Tasks may be made asynchronous if they are passing a callback or return a promise or a stream. * @param cb callback used to signal asynchronous completion. Caller includes err in case of error. */ (cb?: (err?: any) => void): any; } } var gulp: gulp.Gulp; export = gulp; } declare module 'gulp' { import main = require('gulp/gulp'); export = main; }WebDevelopment-assignment-2/typings/main.d.ts000066400000000000000000000007441266350324300215270ustar00rootroot00000000000000/// /// /// /// /// /// /// /// WebDevelopment-assignment-2/typings/main/000077500000000000000000000000001266350324300207305ustar00rootroot00000000000000WebDevelopment-assignment-2/typings/main/ambient/000077500000000000000000000000001266350324300223475ustar00rootroot00000000000000WebDevelopment-assignment-2/typings/main/ambient/del/000077500000000000000000000000001266350324300231135ustar00rootroot00000000000000WebDevelopment-assignment-2/typings/main/ambient/del/del.d.ts000066400000000000000000000020121266350324300244440ustar00rootroot00000000000000// Compiled using typings@0.6.8 // Source: https://raw.githubusercontent.com/DefinitelyTyped/DefinitelyTyped/9027703c0bd831319dcdf7f3169f7a468537f448/del/del.d.ts // Type definitions for del v2.2.0 // Project: https://github.com/sindresorhus/del // Definitions by: Asana , Aya Morisawa // Definitions: https://github.com/borisyankov/DefinitelyTyped declare module "del" { import glob = require("glob"); function Del(pattern: string): Promise; function Del(pattern: string, options: Del.Options): Promise; function Del(patterns: string[]): Promise; function Del(patterns: string[], options: Del.Options): Promise; module Del { function sync(pattern: string, options?: Options): string[]; function sync(patterns: string[], options?: Options): string[]; interface Options extends glob.IOptions { force?: boolean; dryRun?: boolean; } } export = Del; }WebDevelopment-assignment-2/typings/main/ambient/glob/000077500000000000000000000000001266350324300232725ustar00rootroot00000000000000WebDevelopment-assignment-2/typings/main/ambient/glob/glob.d.ts000066400000000000000000000056131266350324300250140ustar00rootroot00000000000000// Compiled using typings@0.6.8 // Source: https://raw.githubusercontent.com/DefinitelyTyped/DefinitelyTyped/a14d724826174d1669d4df04c80f4838b7e71fdf/glob/glob.d.ts // Type definitions for Glob 5.0.10 // Project: https://github.com/isaacs/node-glob // Definitions by: vvakame // Definitions: https://github.com/borisyankov/DefinitelyTyped declare module "glob" { import events = require("events"); import fs = require('fs'); import minimatch = require("minimatch"); function G(pattern: string, cb: (err: Error, matches: string[]) => void): void; function G(pattern: string, options: G.IOptions, cb: (err: Error, matches: string[]) => void): void; module G { function sync(pattern: string, options?: IOptions): string[]; function hasMagic(pattern: string, options?: IOptions): boolean; var Glob: IGlobStatic; var GlobSync: IGlobSyncStatic; interface IOptions extends minimatch.IOptions { cwd?: string; root?: string; dot?: boolean; nomount?: boolean; mark?: boolean; nosort?: boolean; stat?: boolean; silent?: boolean; strict?: boolean; cache?: { [path: string]: any /* boolean | string | string[] */ }; statCache?: { [path: string]: fs.Stats }; symlinks?: any; sync?: boolean; nounique?: boolean; nonull?: boolean; debug?: boolean; nobrace?: boolean; noglobstar?: boolean; noext?: boolean; nocase?: boolean; matchBase?: any; nodir?: boolean; ignore?: any; /* string | string[] */ follow?: boolean; realpath?: boolean; nonegate?: boolean; nocomment?: boolean; /** Deprecated. */ globDebug?: boolean; } interface IGlobStatic extends events.EventEmitter { new (pattern: string, cb?: (err: Error, matches: string[]) => void): IGlob; new (pattern: string, options: IOptions, cb?: (err: Error, matches: string[]) => void): IGlob; prototype: IGlob; } interface IGlobSyncStatic { new (pattern: string, options?: IOptions): IGlobBase prototype: IGlobBase; } interface IGlobBase { minimatch: minimatch.IMinimatch; options: IOptions; aborted: boolean; cache: { [path: string]: any /* boolean | string | string[] */ }; statCache: { [path: string]: fs.Stats }; symlinks: { [path: string]: boolean }; realpathCache: { [path: string]: string }; found: string[]; } interface IGlob extends IGlobBase, events.EventEmitter { pause(): void; resume(): void; abort(): void; /** Deprecated. */ EOF: any; /** Deprecated. */ paused: boolean; /** Deprecated. */ maxDepth: number; /** Deprecated. */ maxLength: number; /** Deprecated. */ changedCwd: boolean; /** Deprecated. */ cwd: string; /** Deprecated. */ root: string; /** Deprecated. */ error: any; /** Deprecated. */ matches: string[]; /** Deprecated. */ log(...args: any[]): void; /** Deprecated. */ emitMatch(m: any): void; } } export = G; }WebDevelopment-assignment-2/typings/main/ambient/gulp-sourcemaps/000077500000000000000000000000001266350324300254755ustar00rootroot00000000000000WebDevelopment-assignment-2/typings/main/ambient/gulp-sourcemaps/gulp-sourcemaps.d.ts000066400000000000000000000017631266350324300314240ustar00rootroot00000000000000// Compiled using typings@0.6.8 // Source: https://raw.githubusercontent.com/DefinitelyTyped/DefinitelyTyped/5d6c3bdb5d936b257f22961890141a999e19daef/gulp-sourcemaps/gulp-sourcemaps.d.ts // Type definitions for gulp-sourcemaps // Project: https://github.com/floridoo/gulp-sourcemaps // Definitions by: Asana // Definitions: https://github.com/borisyankov/DefinitelyTyped declare module "gulp-sourcemaps" { interface InitOptions { loadMaps?: boolean; debug?: boolean; } interface WriteMapper { (file: string): string; } interface WriteOptions { addComment?: boolean; includeContent?: boolean; sourceRoot?: string | WriteMapper; sourceMappingURLPrefix?: string | WriteMapper; } export function init(opts?: InitOptions): NodeJS.ReadWriteStream; export function write(path?: string, opts?: WriteOptions): NodeJS.ReadWriteStream; export function write(opts?: WriteOptions): NodeJS.ReadWriteStream; }WebDevelopment-assignment-2/typings/main/ambient/gulp-typescript/000077500000000000000000000000001266350324300255225ustar00rootroot00000000000000WebDevelopment-assignment-2/typings/main/ambient/gulp-typescript/gulp-typescript.d.ts000066400000000000000000000051041266350324300314670ustar00rootroot00000000000000// Compiled using typings@0.6.8 // Source: https://raw.githubusercontent.com/DefinitelyTyped/DefinitelyTyped/960fd659b456e2fb5d23c52794ffdc56b09796cf/gulp-typescript/gulp-typescript.d.ts // Type definitions for gulp-typescript // Project: https://github.com/ivogabe/gulp-typescript // Definitions by: Asana , Thomas Corbière // Definitions: https://github.com/borisyankov/DefinitelyTyped declare module "gulp-typescript" { function GulpTypescript(params?: GulpTypescript.Params, filters?: GulpTypescript.FilterSettings, reporter?: GulpTypescript.Reporter): GulpTypescript.CompilationStream; module GulpTypescript { export function createProject(params?: Params): Project; export function createProject(file: string, params?: Params): Project; export function filter(filters: FilterSettings): CompilationStream; interface Params { declarationFiles?: boolean; module?: string; noEmitOnError?: boolean; noExternalResolve?: boolean; noImplicitAny?: boolean; noLib?: boolean; removeComments?: boolean; sourceRoot?: string; // use gulp-sourcemaps instead sortOutput?: boolean; target?: string; typescript?: any; outFile?: string; outDir?: string; suppressImplicitAnyIndexErrors?: boolean; jsx?: string; declaration?: boolean; emitDecoratorMetadata?: boolean; experimentalDecorators?: boolean; experimentalAsyncFunctions?: boolean; moduleResolution?: string; noEmitHelpers?: boolean; preserveConstEnums?: boolean; isolatedModules?: boolean; } interface TsConfig { files?: string[]; exclude?: string[]; compilerOptions?: any; } interface Project { config: TsConfig; src(): NodeJS.ReadWriteStream; } interface FilterSettings { referencedFrom?: string[]; } interface Reporter { error(error: any): void; } interface CompilationStream extends NodeJS.ReadWriteStream { dts: NodeJS.ReadWriteStream; js: NodeJS.ReadWriteStream; } module reporter { function nullReporter(): Reporter; function defaultReporter(): Reporter; function fullReporter(showFullFilename?: boolean): Reporter; } } export = GulpTypescript; }WebDevelopment-assignment-2/typings/main/ambient/lodash/000077500000000000000000000000001266350324300236215ustar00rootroot00000000000000WebDevelopment-assignment-2/typings/main/ambient/lodash/lodash.d.ts000066400000000000000000017236711266350324300257060ustar00rootroot00000000000000// Compiled using typings@0.6.8 // Source: https://raw.githubusercontent.com/DefinitelyTyped/DefinitelyTyped/c22a5e55b062c7b2af9df92ea0820c2afa153b2a/lodash/lodash.d.ts // Type definitions for Lo-Dash // Project: http://lodash.com/ // Definitions by: Brian Zengel , Ilya Mochalov // Definitions: https://github.com/borisyankov/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 ** 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 flush method to debounced & throttled functions - [ ] 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; (value: string): LoDashImplicitStringWrapper; (value: boolean): LoDashImplicitWrapper; (value: Array): LoDashImplicitNumberArrayWrapper; (value: Array): LoDashImplicitArrayWrapper; (value: T): LoDashImplicitObjectWrapper; (value: any): LoDashImplicitWrapper; /** * 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; /** * 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; } interface LoDashWrapperBase { } interface LoDashImplicitWrapperBase extends LoDashWrapperBase { } interface LoDashExplicitWrapperBase extends LoDashWrapperBase { } interface LoDashImplicitWrapper extends LoDashImplicitWrapperBase> { } interface LoDashExplicitWrapper extends LoDashExplicitWrapperBase> { } interface LoDashImplicitStringWrapper extends LoDashImplicitWrapper { } interface LoDashExplicitStringWrapper extends LoDashExplicitWrapper { } interface LoDashImplicitObjectWrapper extends LoDashImplicitWrapperBase> { } interface LoDashExplicitObjectWrapper extends LoDashExplicitWrapperBase> { } interface LoDashImplicitArrayWrapper extends LoDashImplicitWrapperBase> { pop(): T; push(...items: T[]): LoDashImplicitArrayWrapper; shift(): T; sort(compareFn?: (a: T, b: T) => number): LoDashImplicitArrayWrapper; splice(start: number): LoDashImplicitArrayWrapper; splice(start: number, deleteCount: number, ...items: any[]): LoDashImplicitArrayWrapper; unshift(...items: T[]): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper extends LoDashExplicitWrapperBase> { } interface LoDashImplicitNumberArrayWrapper extends LoDashImplicitArrayWrapper { } interface LoDashExplicitNumberArrayWrapper extends LoDashExplicitArrayWrapper { } /********* * 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( array: List, size?: number ): T[][]; } interface LoDashImplicitArrayWrapper { /** * @see _.chunk */ chunk(size?: number): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.chunk */ chunk(size?: number): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.chunk */ chunk(size?: number): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.chunk */ chunk(size?: number): LoDashExplicitArrayWrapper; } //_.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(array?: List): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.compact */ compact(): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.compact */ compact(): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.compact */ compact(): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.compact */ compact(): LoDashExplicitArrayWrapper; } //_.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(...values: (T[]|List)[]) : 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( array: T[]|List, ...values: Array> ): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.difference */ difference(...values: (T[]|List)[]): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.difference */ difference(...values: (TValue[]|List)[]): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.difference */ difference(...values: (T[]|List)[]): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.difference */ difference(...values: (TValue[]|List)[]): LoDashExplicitArrayWrapper; } //_.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( array: T[]|List, values?: T[]|List, iteratee?: ((value: T) => any)|string ): T[]; /** * @see _.differenceBy */ differenceBy( array: T[]|List, values?: T[]|List, iteratee?: W ): T[]; /** * @see _.differenceBy */ differenceBy( array: T[]|List, values1?: T[]|List, values2?: T[]|List, iteratee?: ((value: T) => any)|string ): T[]; /** * @see _.differenceBy */ differenceBy( array: T[]|List, values1?: T[]|List, values2?: T[]|List, iteratee?: W ): T[]; /** * @see _.differenceBy */ differenceBy( array: T[]|List, values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, iteratee?: ((value: T) => any)|string ): T[]; /** * @see _.differenceBy */ differenceBy( array: T[]|List, values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, iteratee?: W ): T[]; /** * @see _.differenceBy */ differenceBy( array: T[]|List, values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, iteratee?: W ): T[]; /** * @see _.differenceBy */ differenceBy( array: T[]|List, values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, iteratee?: ((value: T) => any)|string ): T[]; /** * @see _.differenceBy */ differenceBy( array: T[]|List, values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, values5?: T[]|List, iteratee?: ((value: T) => any)|string ): T[]; /** * @see _.differenceBy */ differenceBy( array: T[]|List, values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, values5?: T[]|List, iteratee?: W ): T[]; /** * @see _.differenceBy */ differenceBy( array: T[]|List, ...values: any[] ): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.differenceBy */ differenceBy( values?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values?: T[]|List, iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, values5?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, values5?: T[]|List, iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( ...values: any[] ): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.differenceBy */ differenceBy( values?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values?: T[]|List, iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, values5?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, values5?: T[]|List, iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( ...values: any[] ): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.differenceBy */ differenceBy( values?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values?: T[]|List, iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, values5?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, values5?: T[]|List, iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( ...values: any[] ): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.differenceBy */ differenceBy( values?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values?: T[]|List, iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, values5?: T[]|List, iteratee?: ((value: T) => any)|string ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( values1?: T[]|List, values2?: T[]|List, values3?: T[]|List, values4?: T[]|List, values5?: T[]|List, iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.differenceBy */ differenceBy( ...values: any[] ): LoDashExplicitArrayWrapper; } //_.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, ...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(array: T[]|List, n?: number): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.drop */ drop(n?: number): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.drop */ drop(n?: number): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.drop */ drop(n?: number): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.drop */ drop(n?: number): LoDashExplicitArrayWrapper; } //_.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( array: List, n?: number ): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.dropRight */ dropRight(n?: number): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.dropRight */ dropRight(n?: number): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.dropRight */ dropRight(n?: number): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.dropRight */ dropRight(n?: number): LoDashExplicitArrayWrapper; } //_.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( array: List, predicate?: ListIterator, thisArg?: any ): TValue[]; /** * @see _.dropRightWhile */ dropRightWhile( array: List, predicate?: string, thisArg?: any ): TValue[]; /** * @see _.dropRightWhile */ dropRightWhile( array: List, predicate?: TWhere ): TValue[]; } interface LoDashImplicitArrayWrapper { /** * @see _.dropRightWhile */ dropRightWhile( predicate?: ListIterator, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.dropRightWhile */ dropRightWhile( predicate?: string, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.dropRightWhile */ dropRightWhile( predicate?: TWhere ): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.dropRightWhile */ dropRightWhile( predicate?: ListIterator, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.dropRightWhile */ dropRightWhile( predicate?: string, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.dropRightWhile */ dropRightWhile( predicate?: TWhere ): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.dropRightWhile */ dropRightWhile( predicate?: ListIterator, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.dropRightWhile */ dropRightWhile( predicate?: string, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.dropRightWhile */ dropRightWhile( predicate?: TWhere ): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.dropRightWhile */ dropRightWhile( predicate?: ListIterator, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.dropRightWhile */ dropRightWhile( predicate?: string, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.dropRightWhile */ dropRightWhile( predicate?: TWhere ): LoDashExplicitArrayWrapper; } //_.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( array: List, predicate?: ListIterator, thisArg?: any ): TValue[]; /** * @see _.dropWhile */ dropWhile( array: List, predicate?: string, thisArg?: any ): TValue[]; /** * @see _.dropWhile */ dropWhile( array: List, predicate?: TWhere ): TValue[]; } interface LoDashImplicitArrayWrapper { /** * @see _.dropWhile */ dropWhile( predicate?: ListIterator, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.dropWhile */ dropWhile( predicate?: string, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.dropWhile */ dropWhile( predicate?: TWhere ): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.dropWhile */ dropWhile( predicate?: ListIterator, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.dropWhile */ dropWhile( predicate?: string, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.dropWhile */ dropWhile( predicate?: TWhere ): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.dropWhile */ dropWhile( predicate?: ListIterator, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.dropWhile */ dropWhile( predicate?: string, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.dropWhile */ dropWhile( predicate?: TWhere ): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.dropWhile */ dropWhile( predicate?: ListIterator, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.dropWhile */ dropWhile( predicate?: string, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.dropWhile */ dropWhile( predicate?: TWhere ): LoDashExplicitArrayWrapper; } //_.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( array: any[], value: T, start?: number, end?: number ): T[]; /** * @see _.fill */ fill( array: List, value: T, start?: number, end?: number ): List; } interface LoDashImplicitArrayWrapper { /** * @see _.fill */ fill( value: T, start?: number, end?: number ): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.fill */ fill( value: T, start?: number, end?: number ): LoDashImplicitObjectWrapper>; } interface LoDashExplicitArrayWrapper { /** * @see _.fill */ fill( value: T, start?: number, end?: number ): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.fill */ fill( value: T, start?: number, end?: number ): LoDashExplicitObjectWrapper>; } //_.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 thisArg The this binding of predicate. * @return Returns the index of the found element, else -1. */ findIndex( array: List, predicate?: ListIterator, thisArg?: any ): number; /** * @see _.findIndex */ findIndex( array: List, predicate?: string, thisArg?: any ): number; /** * @see _.findIndex */ findIndex( array: List, predicate?: W ): number; } interface LoDashImplicitArrayWrapper { /** * @see _.findIndex */ findIndex( predicate?: ListIterator, thisArg?: any ): number; /** * @see _.findIndex */ findIndex( predicate?: string, thisArg?: any ): number; /** * @see _.findIndex */ findIndex( predicate?: W ): number; } interface LoDashImplicitObjectWrapper { /** * @see _.findIndex */ findIndex( predicate?: ListIterator, thisArg?: any ): number; /** * @see _.findIndex */ findIndex( predicate?: string, thisArg?: any ): number; /** * @see _.findIndex */ findIndex( predicate?: W ): number; } interface LoDashExplicitArrayWrapper { /** * @see _.findIndex */ findIndex( predicate?: ListIterator, thisArg?: any ): LoDashExplicitWrapper; /** * @see _.findIndex */ findIndex( predicate?: string, thisArg?: any ): LoDashExplicitWrapper; /** * @see _.findIndex */ findIndex( predicate?: W ): LoDashExplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.findIndex */ findIndex( predicate?: ListIterator, thisArg?: any ): LoDashExplicitWrapper; /** * @see _.findIndex */ findIndex( predicate?: string, thisArg?: any ): LoDashExplicitWrapper; /** * @see _.findIndex */ findIndex( predicate?: W ): LoDashExplicitWrapper; } //_.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 thisArg The function invoked per iteration. * @return Returns the index of the found element, else -1. */ findLastIndex( array: List, predicate?: ListIterator, thisArg?: any ): number; /** * @see _.findLastIndex */ findLastIndex( array: List, predicate?: string, thisArg?: any ): number; /** * @see _.findLastIndex */ findLastIndex( array: List, predicate?: W ): number; } interface LoDashImplicitArrayWrapper { /** * @see _.findLastIndex */ findLastIndex( predicate?: ListIterator, thisArg?: any ): number; /** * @see _.findLastIndex */ findLastIndex( predicate?: string, thisArg?: any ): number; /** * @see _.findLastIndex */ findLastIndex( predicate?: W ): number; } interface LoDashImplicitObjectWrapper { /** * @see _.findLastIndex */ findLastIndex( predicate?: ListIterator, thisArg?: any ): number; /** * @see _.findLastIndex */ findLastIndex( predicate?: string, thisArg?: any ): number; /** * @see _.findLastIndex */ findLastIndex( predicate?: W ): number; } interface LoDashExplicitArrayWrapper { /** * @see _.findLastIndex */ findLastIndex( predicate?: ListIterator, thisArg?: any ): LoDashExplicitWrapper; /** * @see _.findLastIndex */ findLastIndex( predicate?: string, thisArg?: any ): LoDashExplicitWrapper; /** * @see _.findLastIndex */ findLastIndex( predicate?: W ): LoDashExplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.findLastIndex */ findLastIndex( predicate?: ListIterator, thisArg?: any ): LoDashExplicitWrapper; /** * @see _.findLastIndex */ findLastIndex( predicate?: string, thisArg?: any ): LoDashExplicitWrapper; /** * @see _.findLastIndex */ findLastIndex( predicate?: W ): LoDashExplicitWrapper; } //_.first interface LoDashStatic { /** * @see _.head */ first(array: List): T; } interface LoDashImplicitArrayWrapper { /** * @see _.head */ first(): T; } interface LoDashImplicitObjectWrapper { /** * @see _.head */ first(): TResult; } interface RecursiveArray extends Array> {} interface ListOfRecursiveArraysOrValues extends List> {} //_.flatMap DUMMY interface LoDashStatic { /** * Creates an array of flattened values by running each element in `array` * through `iteratee` and concating its result to the other mapped values. * The iteratee is invoked with three arguments: (value, index|key, array). * * @static * @memberOf _ * @category Array * @param {Array} array The array to iterate over. * @param {Function|Object|string} [iteratee=_.identity] The function invoked per iteration. * @returns {Array} Returns the new array. * @example * * function duplicate(n) { * return [n, n]; * } * * _.flatMap([1, 2], duplicate); * // => [1, 1, 2, 2] */ flatMap( array: any[]|List, ...values: any[] ): any[]; } //_.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(array: ListOfRecursiveArraysOrValues, isDeep: boolean): T[]; /** * @see _.flatten */ flatten(array: List): T[]; /** * @see _.flatten */ flatten(array: ListOfRecursiveArraysOrValues): RecursiveArray; } interface LoDashImplicitWrapper { /** * @see _.flatten */ flatten(): LoDashImplicitArrayWrapper; } interface LoDashImplicitArrayWrapper { /** * @see _.flatten */ flatten(isDeep?: boolean): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.flatten */ flatten(isDeep?: boolean): LoDashImplicitArrayWrapper; } interface LoDashExplicitWrapper { /** * @see _.flatten */ flatten(): LoDashExplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.flatten */ flatten(isDeep?: boolean): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.flatten */ flatten(isDeep?: boolean): LoDashExplicitArrayWrapper; } //_.flattenDeep interface LoDashStatic { /** * Recursively flattens a nested array. * * @param array The array to recursively flatten. * @return Returns the new flattened array. */ flattenDeep(array: ListOfRecursiveArraysOrValues): T[]; } interface LoDashImplicitWrapper { /** * @see _.flattenDeep */ flattenDeep(): LoDashImplicitArrayWrapper; } interface LoDashImplicitArrayWrapper { /** * @see _.flattenDeep */ flattenDeep(): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.flattenDeep */ flattenDeep(): LoDashImplicitArrayWrapper; } interface LoDashExplicitWrapper { /** * @see _.flattenDeep */ flattenDeep(): LoDashExplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.flattenDeep */ flattenDeep(): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.flattenDeep */ flattenDeep(): LoDashExplicitArrayWrapper; } //_.fromPairs DUMMY 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( array: any[]|List ): 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(array: List): T; } interface LoDashImplicitArrayWrapper { /** * @see _.first */ head(): T; } interface LoDashImplicitObjectWrapper { /** * @see _.first */ head(): TResult; } //_.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( array: List, value: T, fromIndex?: boolean|number ): number; } interface LoDashImplicitArrayWrapper { /** * @see _.indexOf */ indexOf( value: T, fromIndex?: boolean|number ): number; } interface LoDashImplicitObjectWrapper { /** * @see _.indexOf */ indexOf( value: TValue, fromIndex?: boolean|number ): number; } interface LoDashExplicitArrayWrapper { /** * @see _.indexOf */ indexOf( value: T, fromIndex?: boolean|number ): LoDashExplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.indexOf */ indexOf( value: TValue, fromIndex?: boolean|number ): LoDashExplicitWrapper; } //_.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, ...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, ...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, separator?: string ): string; } interface LoDashImplicitWrapper { /** * @see _.join */ join(separator?: string): string; } interface LoDashImplicitArrayWrapper { /** * @see _.join */ join(separator?: string): string; } interface LoDashImplicitObjectWrapper { /** * @see _.join */ join(separator?: string): string; } interface LoDashExplicitWrapper { /** * @see _.join */ join(separator?: string): LoDashExplicitWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.join */ join(separator?: string): LoDashExplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.join */ join(separator?: string): LoDashExplicitWrapper; } //_.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, ...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, ...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, ...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( array: List, value: T ): number; } interface LoDashImplicitArrayWrapper { /** * @see _.sortedIndexOf */ sortedIndexOf( value: T ): number; } interface LoDashImplicitObjectWrapper { /** * @see _.sortedIndexOf */ sortedIndexOf( value: TValue ): number; } interface LoDashExplicitArrayWrapper { /** * @see _.sortedIndexOf */ sortedIndexOf( value: T ): LoDashExplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.sortedIndexOf */ sortedIndexOf( value: TValue ): LoDashExplicitWrapper; } //_.initial interface LoDashStatic { /** * Gets all but the last element of array. * * @param array The array to query. * @return Returns the slice of array. */ initial(array: List): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.initial */ initial(): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.initial */ initial(): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.initial */ initial(): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.initial */ initial(): LoDashExplicitArrayWrapper; } //_.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(...arrays: (T[]|List)[]): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.intersection */ intersection(...arrays: (TResult[]|List)[]): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.intersection */ intersection(...arrays: (TResult[]|List)[]): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.intersection */ intersection(...arrays: (TResult[]|List)[]): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.intersection */ intersection(...arrays: (TResult[]|List)[]): LoDashExplicitArrayWrapper; } //_.last interface LoDashStatic { /** * Gets the last element of array. * * @param array The array to query. * @return Returns the last element of array. */ last(array: List): T; } interface LoDashImplicitArrayWrapper { /** * @see _.last */ last(): T; } interface LoDashImplicitObjectWrapper { /** * @see _.last */ last(): T; } interface LoDashExplicitArrayWrapper { /** * @see _.last */ last(): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.last */ last(): LoDashExplicitObjectWrapper; } //_.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( array: List, value: T, fromIndex?: boolean|number ): number; } interface LoDashImplicitArrayWrapper { /** * @see _.lastIndexOf */ lastIndexOf( value: T, fromIndex?: boolean|number ): number; } interface LoDashImplicitObjectWrapper { /** * @see _.lastIndexOf */ lastIndexOf( value: TResult, fromIndex?: boolean|number ): number; } interface LoDashExplicitArrayWrapper { /** * @see _.lastIndexOf */ lastIndexOf( value: T, fromIndex?: boolean|number ): LoDashExplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.lastIndexOf */ lastIndexOf( value: TResult, fromIndex?: boolean|number ): LoDashExplicitWrapper; } //_.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( array: T[], ...values: T[] ): T[]; /** * @see _.pull */ pull( array: List, ...values: T[] ): List; } interface LoDashImplicitArrayWrapper { /** * @see _.pull */ pull(...values: T[]): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.pull */ pull(...values: TValue[]): LoDashImplicitObjectWrapper>; } interface LoDashExplicitArrayWrapper { /** * @see _.pull */ pull(...values: T[]): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.pull */ pull(...values: TValue[]): LoDashExplicitObjectWrapper>; } //_.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( array: List, ...indexes: (number|number[])[] ): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.pullAt */ pullAt(...indexes: (number|number[])[]): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.pullAt */ pullAt(...indexes: (number|number[])[]): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.pullAt */ pullAt(...indexes: (number|number[])[]): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.pullAt */ pullAt(...indexes: (number|number[])[]): LoDashExplicitArrayWrapper; } //_.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( array: List, predicate?: ListIterator, thisArg?: any ): T[]; /** * @see _.remove */ remove( array: List, predicate?: string, thisArg?: any ): T[]; /** * @see _.remove */ remove( array: List, predicate?: W ): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.remove */ remove( predicate?: ListIterator, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.remove */ remove( predicate?: string, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.remove */ remove( predicate?: W ): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.remove */ remove( predicate?: ListIterator, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.remove */ remove( predicate?: string, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.remove */ remove( predicate?: W ): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.remove */ remove( predicate?: ListIterator, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.remove */ remove( predicate?: string, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.remove */ remove( predicate?: W ): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.remove */ remove( predicate?: ListIterator, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.remove */ remove( predicate?: string, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.remove */ remove( predicate?: W ): LoDashExplicitArrayWrapper; } //_.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(array: List): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.tail */ tail(): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.tail */ tail(): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.tail */ tail(): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.tail */ tail(): LoDashExplicitArrayWrapper; } //_.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( array: T[], start?: number, end?: number ): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.slice */ slice( start?: number, end?: number ): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.slice */ slice( start?: number, end?: number ): LoDashExplicitArrayWrapper; } //_.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( array: List, value: T ): number; /** * @see _.sortedIndex */ sortedIndex( array: List, value: T ): number; /** * @see _.sortedIndex */ sortedIndex( array: List, value: T ): number; /** * @see _.sortedIndex */ sortedIndex( array: List, value: T ): number; /** * @see _.sortedIndex */ sortedIndex( array: List, value: T ): number; } interface LoDashImplicitWrapper { /** * @see _.sortedIndex */ sortedIndex( value: string ): number; } interface LoDashImplicitArrayWrapper { /** * @see _.sortedIndex */ sortedIndex( value: T ): number; /** * @see _.sortedIndex */ sortedIndex( value: T ): number; } interface LoDashImplicitObjectWrapper { /** * @see _.sortedIndex */ sortedIndex( value: T ): number; /** * @see _.sortedIndex */ sortedIndex( value: T ): number; /** * @see _.sortedIndex */ sortedIndex( value: T ): number; } interface LoDashExplicitWrapper { /** * @see _.sortedIndex */ sortedIndex( value: string ): LoDashExplicitWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.sortedIndex */ sortedIndex( value: T ): LoDashExplicitWrapper; /** * @see _.sortedIndex */ sortedIndex( value: T ): LoDashExplicitWrapper; /** * @see _.sortedIndex */ sortedIndex( value: T ): LoDashExplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.sortedIndex */ sortedIndex( value: T ): LoDashExplicitWrapper; /** * @see _.sortedIndex */ sortedIndex( value: T ): LoDashExplicitWrapper; /** * @see _.sortedIndex */ sortedIndex( value: T ): LoDashExplicitWrapper; } //_.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( array: List, value: T, iteratee: (x: T) => TSort ): number; /** * @see _.sortedIndexBy */ sortedIndexBy( array: List, value: T, iteratee: (x: T) => any ): number; /** * @see _.sortedIndexBy */ sortedIndexBy( array: List, value: T, iteratee: string ): number; /** * @see _.sortedIndexBy */ sortedIndexBy( array: List, value: T, iteratee: W ): number; /** * @see _.sortedIndexBy */ sortedIndexBy( array: List, value: T, iteratee: Object ): number; } interface LoDashImplicitWrapper { /** * @see _.sortedIndexBy */ sortedIndexBy( value: string, iteratee: (x: string) => TSort ): number; } interface LoDashImplicitArrayWrapper { /** * @see _.sortedIndexBy */ sortedIndexBy( value: T, iteratee: (x: T) => TSort ): number; /** * @see _.sortedIndexBy */ sortedIndexBy( value: T, iteratee: string ): number; /** * @see _.sortedIndexBy */ sortedIndexBy( value: T, iteratee: W ): number; } interface LoDashImplicitObjectWrapper { /** * @see _.sortedIndexBy */ sortedIndexBy( value: T, iteratee: (x: T) => TSort ): number; /** * @see _.sortedIndexBy */ sortedIndexBy( value: T, iteratee: (x: T) => any ): number; /** * @see _.sortedIndexBy */ sortedIndexBy( value: T, iteratee: string ): number; /** * @see _.sortedIndexBy */ sortedIndexBy( value: T, iteratee: W ): number; /** * @see _.sortedIndexBy */ sortedIndexBy( value: T, iteratee: Object ): number; } interface LoDashExplicitWrapper { /** * @see _.sortedIndexBy */ sortedIndexBy( value: string, iteratee: (x: string) => TSort ): LoDashExplicitWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.sortedIndexBy */ sortedIndexBy( value: T, iteratee: (x: T) => TSort ): LoDashExplicitWrapper; /** * @see _.sortedIndexBy */ sortedIndexBy( value: T, iteratee: string ): LoDashExplicitWrapper; /** * @see _.sortedIndexBy */ sortedIndexBy( value: T, iteratee: W ): LoDashExplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.sortedIndexBy */ sortedIndexBy( value: T, iteratee: (x: T) => TSort ): LoDashExplicitWrapper; /** * @see _.sortedIndexBy */ sortedIndexBy( value: T, iteratee: (x: T) => any ): LoDashExplicitWrapper; /** * @see _.sortedIndexBy */ sortedIndexBy( value: T, iteratee: string ): LoDashExplicitWrapper; /** * @see _.sortedIndexBy */ sortedIndexBy( value: T, iteratee: W ): LoDashExplicitWrapper; /** * @see _.sortedIndexBy */ sortedIndexBy( value: T, iteratee: Object ): LoDashExplicitWrapper; } //_.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( array: List, value: T ): number; /** * @see _.sortedLastIndex */ sortedLastIndex( array: List, value: T ): number; /** * @see _.sortedLastIndex */ sortedLastIndex( array: List, value: T ): number; /** * @see _.sortedLastIndex */ sortedLastIndex( array: List, value: T ): number; /** * @see _.sortedLastIndex */ sortedLastIndex( array: List, value: T ): number; } interface LoDashImplicitWrapper { /** * @see _.sortedLastIndex */ sortedLastIndex( value: string ): number; } interface LoDashImplicitArrayWrapper { /** * @see _.sortedLastIndex */ sortedLastIndex( value: T ): number; /** * @see _.sortedLastIndex */ sortedLastIndex( value: T ): number; /** * @see _.sortedLastIndex */ sortedLastIndex( value: T ): number; } interface LoDashImplicitObjectWrapper { /** * @see _.sortedLastIndex */ sortedLastIndex( value: T ): number; /** * @see _.sortedLastIndex */ sortedLastIndex( value: T ): number; /** * @see _.sortedLastIndex */ sortedLastIndex( value: T ): number; } interface LoDashExplicitWrapper { /** * @see _.sortedLastIndex */ sortedLastIndex( value: string ): LoDashExplicitWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.sortedLastIndex */ sortedLastIndex( value: T ): LoDashExplicitWrapper; /** * @see _.sortedLastIndex */ sortedLastIndex( value: T ): LoDashExplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.sortedLastIndex */ sortedLastIndex( value: T ): LoDashExplicitWrapper; /** * @see _.sortedLastIndex */ sortedLastIndex( value: T ): LoDashExplicitWrapper; /** * @see _.sortedLastIndex */ sortedLastIndex( value: T ): LoDashExplicitWrapper; } //_.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( array: List, value: T, iteratee: (x: T) => TSort ): number; /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( array: List, value: T, iteratee: (x: T) => any ): number; /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( array: List, value: T, iteratee: string ): number; /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( array: List, value: T, iteratee: W ): number; /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( array: List, value: T, iteratee: Object ): number; } interface LoDashImplicitWrapper { /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( value: string, iteratee: (x: string) => TSort ): number; } interface LoDashImplicitArrayWrapper { /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( value: T, iteratee: (x: T) => TSort ): number; /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( value: T, iteratee: string ): number; /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( value: T, iteratee: W ): number; } interface LoDashImplicitObjectWrapper { /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( value: T, iteratee: (x: T) => TSort ): number; /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( value: T, iteratee: (x: T) => any ): number; /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( value: T, iteratee: string ): number; /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( value: T, iteratee: W ): number; /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( value: T, iteratee: Object ): number; } interface LoDashExplicitWrapper { /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( value: string, iteratee: (x: string) => TSort ): LoDashExplicitWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( value: T, iteratee: (x: T) => TSort ): LoDashExplicitWrapper; /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( value: T, iteratee: string ): LoDashExplicitWrapper; /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( value: T, iteratee: W ): LoDashExplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( value: T, iteratee: (x: T) => TSort ): LoDashExplicitWrapper; /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( value: T, iteratee: (x: T) => any ): LoDashExplicitWrapper; /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( value: T, iteratee: string ): LoDashExplicitWrapper; /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( value: T, iteratee: W ): LoDashExplicitWrapper; /** * @see _.sortedLastIndexBy */ sortedLastIndexBy( value: T, iteratee: Object ): LoDashExplicitWrapper; } //_.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, ...values: any[] ): any[]; } //_.tail interface LoDashStatic { /** * @see _.rest */ tail(array: List): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.rest */ tail(): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.rest */ tail(): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.rest */ tail(): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.rest */ tail(): LoDashExplicitArrayWrapper; } //_.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( array: List, n?: number ): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.take */ take(n?: number): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.take */ take(n?: number): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.take */ take(n?: number): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.take */ take(n?: number): LoDashExplicitArrayWrapper; } //_.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( array: List, n?: number ): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.takeRight */ takeRight(n?: number): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.takeRight */ takeRight(n?: number): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.takeRight */ takeRight(n?: number): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.takeRight */ takeRight(n?: number): LoDashExplicitArrayWrapper; } //_.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( array: List, predicate?: ListIterator, thisArg?: any ): TValue[]; /** * @see _.takeRightWhile */ takeRightWhile( array: List, predicate?: string, thisArg?: any ): TValue[]; /** * @see _.takeRightWhile */ takeRightWhile( array: List, predicate?: TWhere ): TValue[]; } interface LoDashImplicitArrayWrapper { /** * @see _.takeRightWhile */ takeRightWhile( predicate?: ListIterator, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.takeRightWhile */ takeRightWhile( predicate?: string, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.takeRightWhile */ takeRightWhile( predicate?: TWhere ): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.takeRightWhile */ takeRightWhile( predicate?: ListIterator, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.takeRightWhile */ takeRightWhile( predicate?: string, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.takeRightWhile */ takeRightWhile( predicate?: TWhere ): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.takeRightWhile */ takeRightWhile( predicate?: ListIterator, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.takeRightWhile */ takeRightWhile( predicate?: string, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.takeRightWhile */ takeRightWhile( predicate?: TWhere ): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.takeRightWhile */ takeRightWhile( predicate?: ListIterator, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.takeRightWhile */ takeRightWhile( predicate?: string, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.takeRightWhile */ takeRightWhile( predicate?: TWhere ): LoDashExplicitArrayWrapper; } //_.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( array: List, predicate?: ListIterator, thisArg?: any ): TValue[]; /** * @see _.takeWhile */ takeWhile( array: List, predicate?: string, thisArg?: any ): TValue[]; /** * @see _.takeWhile */ takeWhile( array: List, predicate?: TWhere ): TValue[]; } interface LoDashImplicitArrayWrapper { /** * @see _.takeWhile */ takeWhile( predicate?: ListIterator, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.takeWhile */ takeWhile( predicate?: string, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.takeWhile */ takeWhile( predicate?: TWhere ): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.takeWhile */ takeWhile( predicate?: ListIterator, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.takeWhile */ takeWhile( predicate?: string, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.takeWhile */ takeWhile( predicate?: TWhere ): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.takeWhile */ takeWhile( predicate?: ListIterator, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.takeWhile */ takeWhile( predicate?: string, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.takeWhile */ takeWhile( predicate?: TWhere ): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.takeWhile */ takeWhile( predicate?: ListIterator, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.takeWhile */ takeWhile( predicate?: string, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.takeWhile */ takeWhile( predicate?: TWhere ): LoDashExplicitArrayWrapper; } //_.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(...arrays: List[]): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.union */ union(...arrays: List[]): LoDashImplicitArrayWrapper; /** * @see _.union */ union(...arrays: List[]): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.union */ union(...arrays: List[]): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.union */ union(...arrays: List[]): LoDashExplicitArrayWrapper; /** * @see _.union */ union(...arrays: List[]): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.union */ union(...arrays: List[]): LoDashExplicitArrayWrapper; } //_.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( arrays: T[]|List, iteratee?: (value: T) => any ): T[]; /** * @see _.unionBy */ unionBy( arrays: T[]|List, iteratee?: W ): T[]; /** * @see _.unionBy */ unionBy( arrays1: T[]|List, arrays2: T[]|List, iteratee?: (value: T) => any ): T[]; /** * @see _.unionBy */ unionBy( arrays1: T[]|List, arrays2: T[]|List, iteratee?: W ): T[]; /** * @see _.unionBy */ unionBy( arrays1: T[]|List, arrays2: T[]|List, arrays3: T[]|List, iteratee?: (value: T) => any ): T[]; /** * @see _.unionBy */ unionBy( arrays1: T[]|List, arrays2: T[]|List, arrays3: T[]|List, iteratee?: W ): T[]; /** * @see _.unionBy */ unionBy( arrays1: T[]|List, arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, iteratee?: (value: T) => any ): T[]; /** * @see _.unionBy */ unionBy( arrays1: T[]|List, arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, iteratee?: W ): T[]; /** * @see _.unionBy */ unionBy( arrays1: T[]|List, arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, arrays5: T[]|List, iteratee?: (value: T) => any ): T[]; /** * @see _.unionBy */ unionBy( arrays1: T[]|List, arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, arrays5: T[]|List, iteratee?: W ): T[]; /** * @see _.unionBy */ unionBy( arrays: T[]|List, ...iteratee: any[] ): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.unionBy */ unionBy( iteratee?: (value: T) => any ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, iteratee?: (value: T) => any ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, iteratee?: (value: T) => any ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, iteratee?: (value: T) => any ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, arrays5: T[]|List, iteratee?: (value: T) => any ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, arrays5: T[]|List, iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( ...iteratee: any[] ): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.unionBy */ unionBy( iteratee?: (value: T) => any ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, iteratee?: (value: T) => any ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, iteratee?: (value: T) => any ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, iteratee?: (value: T) => any ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, arrays5: T[]|List, iteratee?: (value: T) => any ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, arrays5: T[]|List, iteratee?: W ): LoDashImplicitArrayWrapper; /** * @see _.unionBy */ unionBy( ...iteratee: any[] ): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.unionBy */ unionBy( iteratee?: (value: T) => any ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, iteratee?: (value: T) => any ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, iteratee?: (value: T) => any ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, iteratee?: (value: T) => any ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, arrays5: T[]|List, iteratee?: (value: T) => any ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, arrays5: T[]|List, iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( ...iteratee: any[] ): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.unionBy */ unionBy( iteratee?: (value: T) => any ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, iteratee?: (value: T) => any ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, iteratee?: (value: T) => any ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, iteratee?: (value: T) => any ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, arrays5: T[]|List, iteratee?: (value: T) => any ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( arrays2: T[]|List, arrays3: T[]|List, arrays4: T[]|List, arrays5: T[]|List, iteratee?: W ): LoDashExplicitArrayWrapper; /** * @see _.unionBy */ unionBy( ...iteratee: any[] ): LoDashExplicitArrayWrapper; } //_.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( array: List ): T[]; /** * @see _.uniq */ uniq( array: List ): T[]; } interface LoDashImplicitWrapper { /** * @see _.uniq */ uniq(): LoDashImplicitArrayWrapper; } interface LoDashImplicitArrayWrapper { /** * @see _.uniq */ uniq(): LoDashImplicitArrayWrapper; /** * @see _.uniq */ uniq(): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { uniq(): LoDashImplicitArrayWrapper; /** * @see _.uniq */ uniq(): LoDashImplicitArrayWrapper; } interface LoDashExplicitWrapper { /** * @see _.uniq */ uniq(): LoDashExplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.uniq */ uniq(): LoDashExplicitArrayWrapper; /** * @see _.uniq */ uniq(): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.uniq */ uniq(): LoDashExplicitArrayWrapper; /** * @see _.uniq */ uniq(): LoDashExplicitArrayWrapper; } //_.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( array: List, iteratee: ListIterator ): T[]; /** * @see _.uniqBy */ uniqBy( array: List, iteratee: ListIterator ): T[]; /** * @see _.uniqBy */ uniqBy( array: List, iteratee: string ): T[]; /** * @see _.uniqBy */ uniqBy( array: List, iteratee: Object ): T[]; /** * @see _.uniqBy */ uniqBy( array: List, iteratee: TWhere ): T[]; } interface LoDashImplicitWrapper { /** * @see _.uniqBy */ uniqBy( iteratee: ListIterator ): LoDashImplicitArrayWrapper; } interface LoDashImplicitArrayWrapper { /** * @see _.uniqBy */ uniqBy( iteratee: ListIterator ): LoDashImplicitArrayWrapper; /** * @see _.uniqBy */ uniqBy( iteratee: string ): LoDashImplicitArrayWrapper; /** * @see _.uniqBy */ uniqBy( iteratee: TWhere ): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.uniqBy */ uniqBy( iteratee: ListIterator ): LoDashImplicitArrayWrapper; /** * @see _.uniqBy */ uniqBy( iteratee: ListIterator ): LoDashImplicitArrayWrapper; /** * @see _.uniqBy */ uniqBy( iteratee: string ): LoDashImplicitArrayWrapper; /** * @see _.uniqBy */ uniqBy( iteratee: Object ): LoDashImplicitArrayWrapper; /** * @see _.uniqBy */ uniqBy( iteratee: TWhere ): LoDashImplicitArrayWrapper; } interface LoDashExplicitWrapper { /** * @see _.uniqBy */ uniqBy( iteratee: ListIterator ): LoDashExplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.uniqBy */ uniqBy( iteratee: ListIterator ): LoDashExplicitArrayWrapper; /** * @see _.uniqBy */ uniqBy( iteratee: string ): LoDashExplicitArrayWrapper; /** * @see _.uniqBy */ uniqBy( iteratee: TWhere ): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.uniqBy */ uniqBy( iteratee: ListIterator ): LoDashExplicitArrayWrapper; /** * @see _.uniqBy */ uniqBy( iteratee: ListIterator ): LoDashExplicitArrayWrapper; /** * @see _.uniqBy */ uniqBy( iteratee: string ): LoDashExplicitArrayWrapper; /** * @see _.uniqBy */ uniqBy( iteratee: Object ): LoDashExplicitArrayWrapper; /** * @see _.uniqBy */ uniqBy( iteratee: TWhere ): LoDashExplicitArrayWrapper; } //_.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( array: List ): T[]; /** * @see _.sortedUniq */ sortedUniq( array: List ): T[]; } interface LoDashImplicitWrapper { /** * @see _.sortedUniq */ sortedUniq(): LoDashImplicitArrayWrapper; } interface LoDashImplicitArrayWrapper { /** * @see _.sortedUniq */ sortedUniq(): LoDashImplicitArrayWrapper; /** * @see _.sortedUniq */ sortedUniq(): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { sortedUniq(): LoDashImplicitArrayWrapper; /** * @see _.sortedUniq */ sortedUniq(): LoDashImplicitArrayWrapper; } interface LoDashExplicitWrapper { /** * @see _.sortedUniq */ sortedUniq(): LoDashExplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.sortedUniq */ sortedUniq(): LoDashExplicitArrayWrapper; /** * @see _.sortedUniq */ sortedUniq(): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.sortedUniq */ sortedUniq(): LoDashExplicitArrayWrapper; /** * @see _.sortedUniq */ sortedUniq(): LoDashExplicitArrayWrapper; } //_.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( array: List, iteratee: ListIterator ): T[]; /** * @see _.sortedUniqBy */ sortedUniqBy( array: List, iteratee: ListIterator ): T[]; /** * @see _.sortedUniqBy */ sortedUniqBy( array: List, iteratee: string ): T[]; /** * @see _.sortedUniqBy */ sortedUniqBy( array: List, iteratee: Object ): T[]; /** * @see _.sortedUniqBy */ sortedUniqBy( array: List, iteratee: TWhere ): T[]; } interface LoDashImplicitWrapper { /** * @see _.sortedUniqBy */ sortedUniqBy( iteratee: ListIterator ): LoDashImplicitArrayWrapper; } interface LoDashImplicitArrayWrapper { /** * @see _.sortedUniqBy */ sortedUniqBy( iteratee: ListIterator ): LoDashImplicitArrayWrapper; /** * @see _.sortedUniqBy */ sortedUniqBy( iteratee: string ): LoDashImplicitArrayWrapper; /** * @see _.sortedUniqBy */ sortedUniqBy( iteratee: TWhere ): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.sortedUniqBy */ sortedUniqBy( iteratee: ListIterator ): LoDashImplicitArrayWrapper; /** * @see _.sortedUniqBy */ sortedUniqBy( iteratee: ListIterator ): LoDashImplicitArrayWrapper; /** * @see _.sortedUniqBy */ sortedUniqBy( iteratee: string ): LoDashImplicitArrayWrapper; /** * @see _.sortedUniqBy */ sortedUniqBy( iteratee: Object ): LoDashImplicitArrayWrapper; /** * @see _.sortedUniqBy */ sortedUniqBy( iteratee: TWhere ): LoDashImplicitArrayWrapper; } interface LoDashExplicitWrapper { /** * @see _.sortedUniqBy */ sortedUniqBy( iteratee: ListIterator ): LoDashExplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.sortedUniqBy */ sortedUniqBy( iteratee: ListIterator ): LoDashExplicitArrayWrapper; /** * @see _.sortedUniqBy */ sortedUniqBy( iteratee: string ): LoDashExplicitArrayWrapper; /** * @see _.sortedUniqBy */ sortedUniqBy( iteratee: TWhere ): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.sortedUniqBy */ sortedUniqBy( iteratee: ListIterator ): LoDashExplicitArrayWrapper; /** * @see _.sortedUniqBy */ sortedUniqBy( iteratee: ListIterator ): LoDashExplicitArrayWrapper; /** * @see _.sortedUniqBy */ sortedUniqBy( iteratee: string ): LoDashExplicitArrayWrapper; /** * @see _.sortedUniqBy */ sortedUniqBy( iteratee: Object ): LoDashExplicitArrayWrapper; /** * @see _.sortedUniqBy */ sortedUniqBy( iteratee: TWhere ): LoDashExplicitArrayWrapper; } //_.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, ...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, ...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(array: List>): T[][]; } interface LoDashImplicitArrayWrapper { /** * @see _.unzip */ unzip(): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.unzip */ unzip(): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.unzip */ unzip(): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.unzip */ unzip(): LoDashExplicitArrayWrapper; } //_.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( array: List>, iteratee?: MemoIterator, thisArg?: any ): TResult[]; } interface LoDashImplicitArrayWrapper { /** * @see _.unzipWith */ unzipWith( iteratee?: MemoIterator, thisArg?: any ): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.unzipWith */ unzipWith( iteratee?: MemoIterator, thisArg?: any ): LoDashImplicitArrayWrapper; } //_.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( array: List, ...values: T[] ): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.without */ without(...values: T[]): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.without */ without(...values: T[]): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.without */ without(...values: T[]): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.without */ without(...values: T[]): LoDashExplicitArrayWrapper; } //_.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(...arrays: List[]): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.xor */ xor(...arrays: List[]): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.xor */ xor(...arrays: List[]): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.xor */ xor(...arrays: List[]): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.xor */ xor(...arrays: List[]): LoDashExplicitArrayWrapper; } //_.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, ...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, ...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(...arrays: List[]): T[][]; } interface LoDashImplicitArrayWrapper { /** * @see _.zip */ zip(...arrays: List[]): _.LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.zip */ zip(...arrays: List[]): _.LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.zip */ zip(...arrays: List[]): _.LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.zip */ zip(...arrays: List[]): _.LoDashExplicitArrayWrapper; } //_.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( props: List|List>, values?: List ): TResult; /** * @see _.zipObject */ zipObject( props: List|List>, values?: List ): TResult; /** * @see _.zipObject */ zipObject( props: List|List>, values?: List ): _.Dictionary; } interface LoDashImplicitArrayWrapper { /** * @see _.zipObject */ zipObject( values?: List ): _.LoDashImplicitObjectWrapper; /** * @see _.zipObject */ zipObject( values?: List ): _.LoDashImplicitObjectWrapper; /** * @see _.zipObject */ zipObject( values?: List ): _.LoDashImplicitObjectWrapper<_.Dictionary>; } interface LoDashImplicitObjectWrapper { /** * @see _.zipObject */ zipObject( values?: List ): _.LoDashImplicitObjectWrapper; /** * @see _.zipObject */ zipObject( values?: List ): _.LoDashImplicitObjectWrapper; /** * @see _.zipObject */ zipObject( values?: List ): _.LoDashImplicitObjectWrapper<_.Dictionary>; } interface LoDashExplicitArrayWrapper { /** * @see _.zipObject */ zipObject( values?: List ): _.LoDashExplicitObjectWrapper; /** * @see _.zipObject */ zipObject( values?: List ): _.LoDashExplicitObjectWrapper; /** * @see _.zipObject */ zipObject( values?: List ): _.LoDashExplicitObjectWrapper<_.Dictionary>; } interface LoDashExplicitObjectWrapper { /** * @see _.zipObject */ zipObject( values?: List ): _.LoDashExplicitObjectWrapper; /** * @see _.zipObject */ zipObject( values?: List ): _.LoDashExplicitObjectWrapper; /** * @see _.zipObject */ zipObject( values?: List ): _.LoDashExplicitObjectWrapper<_.Dictionary>; } //_.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(...args: any[]): TResult[]; } interface LoDashImplicitArrayWrapper { /** * @see _.zipWith */ zipWith(...args: any[]): LoDashImplicitArrayWrapper; } /********* * 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; chain(value: string): LoDashExplicitWrapper; chain(value: boolean): LoDashExplicitWrapper; chain(value: T[]): LoDashExplicitArrayWrapper; chain(value: T): LoDashExplicitObjectWrapper; chain(value: any): LoDashExplicitWrapper; } interface LoDashImplicitWrapper { /** * @see _.chain */ chain(): LoDashExplicitWrapper; } interface LoDashImplicitArrayWrapper { /** * @see _.chain */ chain(): LoDashExplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.chain */ chain(): LoDashExplicitObjectWrapper; } interface LoDashExplicitWrapperBase { /** * @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( value: T, interceptor: (value: T) => void, thisArg?: any ): T; } interface LoDashImplicitWrapperBase { /** * @see _.tap */ tap( interceptor: (value: T) => void, thisArg?: any ): TWrapper; } interface LoDashExplicitWrapperBase { /** * @see _.tap */ tap( interceptor: (value: T) => void, thisArg?: any ): 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( value: T, interceptor: (value: T) => TResult, thisArg?: any ): TResult; } interface LoDashImplicitWrapperBase { /** * @see _.thru */ thru( interceptor: (value: T) => TResult, thisArg?: any): LoDashImplicitWrapper; /** * @see _.thru */ thru( interceptor: (value: T) => TResult, thisArg?: any): LoDashImplicitWrapper; /** * @see _.thru */ thru( interceptor: (value: T) => TResult, thisArg?: any): LoDashImplicitWrapper; /** * @see _.thru */ thru( interceptor: (value: T) => TResult, thisArg?: any): LoDashImplicitObjectWrapper; /** * @see _.thru */ thru( interceptor: (value: T) => TResult[], thisArg?: any): LoDashImplicitArrayWrapper; } interface LoDashExplicitWrapperBase { /** * @see _.thru */ thru( interceptor: (value: T) => TResult, thisArg?: any ): LoDashExplicitWrapper; /** * @see _.thru */ thru( interceptor: (value: T) => TResult, thisArg?: any ): LoDashExplicitWrapper; /** * @see _.thru */ thru( interceptor: (value: T) => TResult, thisArg?: any ): LoDashExplicitWrapper; /** * @see _.thru */ thru( interceptor: (value: T) => TResult, thisArg?: any ): LoDashExplicitObjectWrapper; /** * @see _.thru */ thru( interceptor: (value: T) => TResult[], thisArg?: any ): LoDashExplicitArrayWrapper; } //_.prototype.commit interface LoDashImplicitWrapperBase { /** * Executes the chained sequence and returns the wrapped result. * * @return Returns the new lodash wrapper instance. */ commit(): TWrapper; } interface LoDashExplicitWrapperBase { /** * @see _.commit */ commit(): TWrapper; } //_.prototype.concat interface LoDashImplicitWrapperBase { /** * Creates a new array joining a wrapped array with any additional arrays and/or values. * * @param items * @return Returns the new concatenated array. */ concat(...items: Array>): LoDashImplicitArrayWrapper; /** * @see _.concat */ concat(...items: Array>): LoDashImplicitArrayWrapper; } interface LoDashExplicitWrapperBase { /** * @see _.concat */ concat(...items: Array>): LoDashExplicitArrayWrapper; /** * @see _.concat */ concat(...items: Array>): LoDashExplicitArrayWrapper; } //_.prototype.plant interface LoDashImplicitWrapperBase { /** * 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; /** * @see _.plant */ plant(value: string): LoDashImplicitStringWrapper; /** * @see _.plant */ plant(value: boolean): LoDashImplicitWrapper; /** * @see _.plant */ plant(value: number[]): LoDashImplicitNumberArrayWrapper; /** * @see _.plant */ plant(value: T[]): LoDashImplicitArrayWrapper; /** * @see _.plant */ plant(value: T): LoDashImplicitObjectWrapper; /** * @see _.plant */ plant(value: any): LoDashImplicitWrapper; } interface LoDashExplicitWrapperBase { /** * @see _.plant */ plant(value: number): LoDashExplicitWrapper; /** * @see _.plant */ plant(value: string): LoDashExplicitStringWrapper; /** * @see _.plant */ plant(value: boolean): LoDashExplicitWrapper; /** * @see _.plant */ plant(value: number[]): LoDashExplicitNumberArrayWrapper; /** * @see _.plant */ plant(value: T[]): LoDashExplicitArrayWrapper; /** * @see _.plant */ plant(value: T): LoDashExplicitObjectWrapper; /** * @see _.plant */ plant(value: any): LoDashExplicitWrapper; } //_.prototype.reverse interface LoDashImplicitArrayWrapper { /** * 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; } interface LoDashExplicitArrayWrapper { /** * @see _.reverse */ reverse(): LoDashExplicitArrayWrapper; } //_.prototype.toJSON interface LoDashWrapperBase { /** * @see _.value */ toJSON(): T; } //_.prototype.toString interface LoDashWrapperBase { /** * Produces the result of coercing the unwrapped value to a string. * * @return Returns the coerced string value. */ toString(): string; } //_.prototype.value interface LoDashWrapperBase { /** * Executes the chained sequence to extract the unwrapped value. * * @alias _.toJSON, _.valueOf * * @return Returns the resolved unwrapped value. */ value(): T; } //_.valueOf interface LoDashWrapperBase { /** * @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( collection: List|Dictionary, ...props: (number|string|(number|string)[])[] ): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.at */ at(...props: (number|string|(number|string)[])[]): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.at */ at(...props: (number|string|(number|string)[])[]): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.at */ at(...props: (number|string|(number|string)[])[]): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.at */ at(...props: (number|string|(number|string)[])[]): LoDashExplicitArrayWrapper; } //_.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( collection: List, iteratee?: ListIterator, thisArg?: any ): Dictionary; /** * @see _.countBy */ countBy( collection: Dictionary, iteratee?: DictionaryIterator, thisArg?: any ): Dictionary; /** * @see _.countBy */ countBy( collection: NumericDictionary, iteratee?: NumericDictionaryIterator, thisArg?: any ): Dictionary; /** * @see _.countBy */ countBy( collection: List|Dictionary|NumericDictionary, iteratee?: string, thisArg?: any ): Dictionary; /** * @see _.countBy */ countBy( collection: List|Dictionary|NumericDictionary, iteratee?: W ): Dictionary; /** * @see _.countBy */ countBy( collection: List|Dictionary|NumericDictionary, iteratee?: Object ): Dictionary; } interface LoDashImplicitWrapper { /** * @see _.countBy */ countBy( iteratee?: ListIterator, thisArg?: any ): LoDashImplicitObjectWrapper>; } interface LoDashImplicitArrayWrapper { /** * @see _.countBy */ countBy( iteratee?: ListIterator, thisArg?: any ): LoDashImplicitObjectWrapper>; /** * @see _.countBy */ countBy( iteratee?: string, thisArg?: any ): LoDashImplicitObjectWrapper>; /** * @see _.countBy */ countBy( iteratee?: W ): LoDashImplicitObjectWrapper>; } interface LoDashImplicitObjectWrapper { /** * @see _.countBy */ countBy( iteratee?: ListIterator|DictionaryIterator|NumericDictionaryIterator, thisArg?: any ): LoDashImplicitObjectWrapper>; /** * @see _.countBy */ countBy( iteratee?: string, thisArg?: any ): LoDashImplicitObjectWrapper>; /** * @see _.countBy */ countBy( iteratee?: W ): LoDashImplicitObjectWrapper>; } interface LoDashExplicitWrapper { /** * @see _.countBy */ countBy( iteratee?: ListIterator, thisArg?: any ): LoDashExplicitObjectWrapper>; } interface LoDashExplicitArrayWrapper { /** * @see _.countBy */ countBy( iteratee?: ListIterator, thisArg?: any ): LoDashExplicitObjectWrapper>; /** * @see _.countBy */ countBy( iteratee?: string, thisArg?: any ): LoDashExplicitObjectWrapper>; /** * @see _.countBy */ countBy( iteratee?: W ): LoDashExplicitObjectWrapper>; } interface LoDashExplicitObjectWrapper { /** * @see _.countBy */ countBy( iteratee?: ListIterator|DictionaryIterator|NumericDictionaryIterator, thisArg?: any ): LoDashExplicitObjectWrapper>; /** * @see _.countBy */ countBy( iteratee?: string, thisArg?: any ): LoDashExplicitObjectWrapper>; /** * @see _.countBy */ countBy( iteratee?: W ): LoDashExplicitObjectWrapper>; } //_.each interface LoDashStatic { /** * @see _.forEach */ each( collection: T[], iteratee?: ListIterator, thisArg?: any ): T[]; /** * @see _.forEach */ each( collection: List, iteratee?: ListIterator, thisArg?: any ): List; /** * @see _.forEach */ each( collection: Dictionary, iteratee?: DictionaryIterator, thisArg?: any ): Dictionary; /** * @see _.forEach */ each( collection: T, iteratee?: ObjectIterator, thisArgs?: any ): T; /** * @see _.forEach */ each( collection: T, iteratee?: ObjectIterator, thisArgs?: any ): T; } interface LoDashImplicitWrapper { /** * @see _.forEach */ each( iteratee: ListIterator, thisArg?: any ): LoDashImplicitWrapper; } interface LoDashImplicitArrayWrapper { /** * @see _.forEach */ each( iteratee: ListIterator, thisArg?: any ): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.forEach */ each( iteratee?: ListIterator|DictionaryIterator, thisArg?: any ): LoDashImplicitObjectWrapper; } interface LoDashExplicitWrapper { /** * @see _.forEach */ each( iteratee: ListIterator, thisArg?: any ): LoDashExplicitWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.forEach */ each( iteratee: ListIterator, thisArg?: any ): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.forEach */ each( iteratee?: ListIterator|DictionaryIterator, thisArg?: any ): LoDashExplicitObjectWrapper; } //_.eachRight interface LoDashStatic { /** * @see _.forEachRight */ eachRight( collection: T[], iteratee?: ListIterator, thisArg?: any ): T[]; /** * @see _.forEachRight */ eachRight( collection: List, iteratee?: ListIterator, thisArg?: any ): List; /** * @see _.forEachRight */ eachRight( collection: Dictionary, iteratee?: DictionaryIterator, thisArg?: any ): Dictionary; /** * @see _.forEachRight */ eachRight( collection: T, iteratee?: ObjectIterator, thisArgs?: any ): T; /** * @see _.forEachRight */ eachRight( collection: T, iteratee?: ObjectIterator, thisArgs?: any ): T; } interface LoDashImplicitWrapper { /** * @see _.forEachRight */ eachRight( iteratee: ListIterator, thisArg?: any ): LoDashImplicitWrapper; } interface LoDashImplicitArrayWrapper { /** * @see _.forEachRight */ eachRight( iteratee: ListIterator, thisArg?: any ): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.forEachRight */ eachRight( iteratee?: ListIterator|DictionaryIterator, thisArg?: any ): LoDashImplicitObjectWrapper; } interface LoDashExplicitWrapper { /** * @see _.forEachRight */ eachRight( iteratee: ListIterator, thisArg?: any ): LoDashExplicitWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.forEachRight */ eachRight( iteratee: ListIterator, thisArg?: any ): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.forEachRight */ eachRight( iteratee?: ListIterator|DictionaryIterator, thisArg?: any ): LoDashExplicitObjectWrapper; } //_.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( collection: List, predicate?: ListIterator ): boolean; /** * @see _.every */ every( collection: Dictionary, predicate?: DictionaryIterator ): boolean; /** * @see _.every */ every( collection: NumericDictionary, predicate?: NumericDictionaryIterator ): boolean; /** * @see _.every */ every( collection: List|Dictionary|NumericDictionary, predicate?: string|any[] ): boolean; /** * @see _.every */ every( collection: List|Dictionary|NumericDictionary, predicate?: TObject ): boolean; } interface LoDashImplicitArrayWrapper { /** * @see _.every */ every( predicate?: ListIterator|NumericDictionaryIterator ): boolean; /** * @see _.every */ every( predicate?: string|any[] ): boolean; /** * @see _.every */ every( predicate?: TObject ): boolean; } interface LoDashImplicitObjectWrapper { /** * @see _.every */ every( predicate?: ListIterator|DictionaryIterator|NumericDictionaryIterator ): boolean; /** * @see _.every */ every( predicate?: string|any[] ): boolean; /** * @see _.every */ every( predicate?: TObject ): boolean; } interface LoDashExplicitArrayWrapper { /** * @see _.every */ every( predicate?: ListIterator|NumericDictionaryIterator ): LoDashExplicitWrapper; /** * @see _.every */ every( predicate?: string|any[] ): LoDashExplicitWrapper; /** * @see _.every */ every( predicate?: TObject ): LoDashExplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.every */ every( predicate?: ListIterator|DictionaryIterator|NumericDictionaryIterator ): LoDashExplicitWrapper; /** * @see _.every */ every( predicate?: string|any[] ): LoDashExplicitWrapper; /** * @see _.every */ every( predicate?: TObject ): LoDashExplicitWrapper; } //_.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( collection: List, predicate?: ListIterator, thisArg?: any ): T[]; /** * @see _.filter */ filter( collection: Dictionary, predicate?: DictionaryIterator, thisArg?: any ): T[]; /** * @see _.filter */ filter( collection: string, predicate?: StringIterator, thisArg?: any ): string[]; /** * @see _.filter */ filter( collection: List|Dictionary, predicate: string, thisArg?: any ): T[]; /** * @see _.filter */ filter( collection: List|Dictionary, predicate: W ): T[]; } interface LoDashImplicitWrapper { /** * @see _.filter */ filter( predicate?: StringIterator, thisArg?: any ): LoDashImplicitArrayWrapper; } interface LoDashImplicitArrayWrapper { /** * @see _.filter */ filter( predicate: ListIterator, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.filter */ filter( predicate: string, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.filter */ filter(predicate: W): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.filter */ filter( predicate: ListIterator|DictionaryIterator, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.filter */ filter( predicate: string, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.filter */ filter(predicate: W): LoDashImplicitArrayWrapper; } interface LoDashExplicitWrapper { /** * @see _.filter */ filter( predicate?: StringIterator, thisArg?: any ): LoDashExplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.filter */ filter( predicate: ListIterator, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.filter */ filter( predicate: string, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.filter */ filter(predicate: W): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.filter */ filter( predicate: ListIterator|DictionaryIterator, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.filter */ filter( predicate: string, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.filter */ filter(predicate: W): LoDashExplicitArrayWrapper; } //_.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 thisArg The this binding of predicate. * @return Returns the matched element, else undefined. */ find( collection: List, predicate?: ListIterator, thisArg?: any ): T; /** * @see _.find */ find( collection: Dictionary, predicate?: DictionaryIterator, thisArg?: any ): T; /** * @see _.find */ find( collection: List|Dictionary, predicate?: string, thisArg?: any ): T; /** * @see _.find */ find( collection: List|Dictionary, predicate?: TObject ): T; } interface LoDashImplicitArrayWrapper { /** * @see _.find */ find( predicate?: ListIterator, thisArg?: any ): T; /** * @see _.find */ find( predicate?: string, thisArg?: any ): T; /** * @see _.find */ find( predicate?: TObject ): T; } interface LoDashImplicitObjectWrapper { /** * @see _.find */ find( predicate?: ListIterator|DictionaryIterator, thisArg?: any ): TResult; /** * @see _.find */ find( predicate?: string, thisArg?: any ): TResult; /** * @see _.find */ find( predicate?: TObject ): 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 thisArg The this binding of callback. * @return The found element, else undefined. **/ findLast( collection: Array, callback: ListIterator, thisArg?: any): T; /** * @see _.find **/ findLast( collection: List, callback: ListIterator, thisArg?: any): T; /** * @see _.find **/ findLast( collection: Dictionary, callback: DictionaryIterator, thisArg?: any): T; /** * @see _.find * @param _.pluck style callback **/ findLast( collection: Array, whereValue: W): T; /** * @see _.find * @param _.pluck style callback **/ findLast( collection: List, whereValue: W): T; /** * @see _.find * @param _.pluck style callback **/ findLast( collection: Dictionary, whereValue: W): T; /** * @see _.find * @param _.where style callback **/ findLast( collection: Array, pluckValue: string): T; /** * @see _.find * @param _.where style callback **/ findLast( collection: List, pluckValue: string): T; /** * @see _.find * @param _.where style callback **/ findLast( collection: Dictionary, pluckValue: string): T; } interface LoDashImplicitArrayWrapper { /** * @see _.findLast */ findLast( callback: ListIterator, thisArg?: any): T; /** * @see _.findLast * @param _.where style callback */ findLast( whereValue: W): T; /** * @see _.findLast * @param _.where style callback */ findLast( pluckValue: string): T; } //_.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( collection: T[], iteratee?: ListIterator, thisArg?: any ): T[]; /** * @see _.forEach */ forEach( collection: List, iteratee?: ListIterator, thisArg?: any ): List; /** * @see _.forEach */ forEach( collection: Dictionary, iteratee?: DictionaryIterator, thisArg?: any ): Dictionary; /** * @see _.forEach */ forEach( collection: T, iteratee?: ObjectIterator, thisArgs?: any ): T; /** * @see _.forEach */ forEach( collection: T, iteratee?: ObjectIterator, thisArgs?: any ): T; } interface LoDashImplicitWrapper { /** * @see _.forEach */ forEach( iteratee: ListIterator, thisArg?: any ): LoDashImplicitWrapper; } interface LoDashImplicitArrayWrapper { /** * @see _.forEach */ forEach( iteratee: ListIterator, thisArg?: any ): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.forEach */ forEach( iteratee?: ListIterator|DictionaryIterator, thisArg?: any ): LoDashImplicitObjectWrapper; } interface LoDashExplicitWrapper { /** * @see _.forEach */ forEach( iteratee: ListIterator, thisArg?: any ): LoDashExplicitWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.forEach */ forEach( iteratee: ListIterator, thisArg?: any ): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.forEach */ forEach( iteratee?: ListIterator|DictionaryIterator, thisArg?: any ): LoDashExplicitObjectWrapper; } //_.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( collection: T[], iteratee?: ListIterator, thisArg?: any ): T[]; /** * @see _.forEachRight */ forEachRight( collection: List, iteratee?: ListIterator, thisArg?: any ): List; /** * @see _.forEachRight */ forEachRight( collection: Dictionary, iteratee?: DictionaryIterator, thisArg?: any ): Dictionary; /** * @see _.forEachRight */ forEachRight( collection: T, iteratee?: ObjectIterator, thisArgs?: any ): T; /** * @see _.forEachRight */ forEachRight( collection: T, iteratee?: ObjectIterator, thisArgs?: any ): T; } interface LoDashImplicitWrapper { /** * @see _.forEachRight */ forEachRight( iteratee: ListIterator, thisArg?: any ): LoDashImplicitWrapper; } interface LoDashImplicitArrayWrapper { /** * @see _.forEachRight */ forEachRight( iteratee: ListIterator, thisArg?: any ): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.forEachRight */ forEachRight( iteratee?: ListIterator|DictionaryIterator, thisArg?: any ): LoDashImplicitObjectWrapper; } interface LoDashExplicitWrapper { /** * @see _.forEachRight */ forEachRight( iteratee: ListIterator, thisArg?: any ): LoDashExplicitWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.forEachRight */ forEachRight( iteratee: ListIterator, thisArg?: any ): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.forEachRight */ forEachRight( iteratee?: ListIterator|DictionaryIterator, thisArg?: any ): LoDashExplicitObjectWrapper; } //_.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( collection: List, iteratee?: ListIterator, thisArg?: any ): Dictionary; /** * @see _.groupBy */ groupBy( collection: List, iteratee?: ListIterator, thisArg?: any ): Dictionary; /** * @see _.groupBy */ groupBy( collection: Dictionary, iteratee?: DictionaryIterator, thisArg?: any ): Dictionary; /** * @see _.groupBy */ groupBy( collection: Dictionary, iteratee?: DictionaryIterator, thisArg?: any ): Dictionary; /** * @see _.groupBy */ groupBy( collection: List|Dictionary, iteratee?: string, thisArg?: TValue ): Dictionary; /** * @see _.groupBy */ groupBy( collection: List|Dictionary, iteratee?: string, thisArg?: any ): Dictionary; /** * @see _.groupBy */ groupBy( collection: List|Dictionary, iteratee?: TWhere ): Dictionary; /** * @see _.groupBy */ groupBy( collection: List|Dictionary, iteratee?: Object ): Dictionary; } interface LoDashImplicitWrapper { /** * @see _.groupBy */ groupBy( iteratee?: ListIterator, thisArg?: any ): LoDashImplicitObjectWrapper>; } interface LoDashImplicitArrayWrapper { /** * @see _.groupBy */ groupBy( iteratee?: ListIterator, thisArg?: any ): LoDashImplicitObjectWrapper>; /** * @see _.groupBy */ groupBy( iteratee?: string, thisArg?: TValue ): LoDashImplicitObjectWrapper>; /** * @see _.groupBy */ groupBy( iteratee?: TWhere ): LoDashImplicitObjectWrapper>; } interface LoDashImplicitObjectWrapper { /** * @see _.groupBy */ groupBy( iteratee?: ListIterator|DictionaryIterator, thisArg?: any ): LoDashImplicitObjectWrapper>; /** * @see _.groupBy */ groupBy( iteratee?: ListIterator|DictionaryIterator, thisArg?: any ): LoDashImplicitObjectWrapper>; /** * @see _.groupBy */ groupBy( iteratee?: string, thisArg?: TValue ): LoDashImplicitObjectWrapper>; /** * @see _.groupBy */ groupBy( iteratee?: string, thisArg?: any ): LoDashImplicitObjectWrapper>; /** * @see _.groupBy */ groupBy( iteratee?: TWhere ): LoDashImplicitObjectWrapper>; /** * @see _.groupBy */ groupBy( iteratee?: Object ): LoDashImplicitObjectWrapper>; } interface LoDashExplicitWrapper { /** * @see _.groupBy */ groupBy( iteratee?: ListIterator, thisArg?: any ): LoDashExplicitObjectWrapper>; } interface LoDashExplicitArrayWrapper { /** * @see _.groupBy */ groupBy( iteratee?: ListIterator, thisArg?: any ): LoDashExplicitObjectWrapper>; /** * @see _.groupBy */ groupBy( iteratee?: string, thisArg?: TValue ): LoDashExplicitObjectWrapper>; /** * @see _.groupBy */ groupBy( iteratee?: TWhere ): LoDashExplicitObjectWrapper>; } interface LoDashExplicitObjectWrapper { /** * @see _.groupBy */ groupBy( iteratee?: ListIterator|DictionaryIterator, thisArg?: any ): LoDashExplicitObjectWrapper>; /** * @see _.groupBy */ groupBy( iteratee?: ListIterator|DictionaryIterator, thisArg?: any ): LoDashExplicitObjectWrapper>; /** * @see _.groupBy */ groupBy( iteratee?: string, thisArg?: TValue ): LoDashExplicitObjectWrapper>; /** * @see _.groupBy */ groupBy( iteratee?: string, thisArg?: any ): LoDashExplicitObjectWrapper>; /** * @see _.groupBy */ groupBy( iteratee?: TWhere ): LoDashExplicitObjectWrapper>; /** * @see _.groupBy */ groupBy( iteratee?: Object ): LoDashExplicitObjectWrapper>; } //_.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( collection: List|Dictionary, target: T, fromIndex?: number ): boolean; /** * @see _.includes */ includes( collection: string, target: string, fromIndex?: number ): boolean; } interface LoDashImplicitArrayWrapper { /** * @see _.includes */ includes( target: T, fromIndex?: number ): boolean; } interface LoDashImplicitObjectWrapper { /** * @see _.includes */ includes( target: TValue, fromIndex?: number ): boolean; } interface LoDashImplicitWrapper { /** * @see _.includes */ includes( target: string, fromIndex?: number ): boolean; } interface LoDashExplicitArrayWrapper { /** * @see _.includes */ includes( target: T, fromIndex?: number ): LoDashExplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.includes */ includes( target: TValue, fromIndex?: number ): LoDashExplicitWrapper; } interface LoDashExplicitWrapper { /** * @see _.includes */ includes( target: string, fromIndex?: number ): LoDashExplicitWrapper; } //_.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( collection: List, iteratee?: ListIterator, thisArg?: any ): Dictionary; /** * @see _.keyBy */ keyBy( collection: NumericDictionary, iteratee?: NumericDictionaryIterator, thisArg?: any ): Dictionary; /** * @see _.keyBy */ keyBy( collection: Dictionary, iteratee?: DictionaryIterator, thisArg?: any ): Dictionary; /** * @see _.keyBy */ keyBy( collection: List|NumericDictionary|Dictionary, iteratee?: string, thisArg?: any ): Dictionary; /** * @see _.keyBy */ keyBy( collection: List|NumericDictionary|Dictionary, iteratee?: W ): Dictionary; /** * @see _.keyBy */ keyBy( collection: List|NumericDictionary|Dictionary, iteratee?: Object ): Dictionary; } interface LoDashImplicitWrapper { /** * @see _.keyBy */ keyBy( iteratee?: ListIterator, thisArg?: any ): LoDashImplicitObjectWrapper>; } interface LoDashImplicitArrayWrapper { /** * @see _.keyBy */ keyBy( iteratee?: ListIterator, thisArg?: any ): LoDashImplicitObjectWrapper>; /** * @see _.keyBy */ keyBy( iteratee?: string, thisArg?: any ): LoDashImplicitObjectWrapper>; /** * @see _.keyBy */ keyBy( iteratee?: W ): LoDashImplicitObjectWrapper>; } interface LoDashImplicitObjectWrapper { /** * @see _.keyBy */ keyBy( iteratee?: ListIterator|NumericDictionaryIterator|DictionaryIterator, thisArg?: any ): LoDashImplicitObjectWrapper>; /** * @see _.keyBy */ keyBy( iteratee?: string, thisArg?: any ): LoDashImplicitObjectWrapper>; /** * @see _.keyBy */ keyBy( iteratee?: W ): LoDashImplicitObjectWrapper>; /** * @see _.keyBy */ keyBy( iteratee?: Object ): LoDashImplicitObjectWrapper>; } interface LoDashExplicitWrapper { /** * @see _.keyBy */ keyBy( iteratee?: ListIterator, thisArg?: any ): LoDashExplicitObjectWrapper>; } interface LoDashExplicitArrayWrapper { /** * @see _.keyBy */ keyBy( iteratee?: ListIterator, thisArg?: any ): LoDashExplicitObjectWrapper>; /** * @see _.keyBy */ keyBy( iteratee?: string, thisArg?: any ): LoDashExplicitObjectWrapper>; /** * @see _.keyBy */ keyBy( iteratee?: W ): LoDashExplicitObjectWrapper>; } interface LoDashExplicitObjectWrapper { /** * @see _.keyBy */ keyBy( iteratee?: ListIterator|NumericDictionaryIterator|DictionaryIterator, thisArg?: any ): LoDashExplicitObjectWrapper>; /** * @see _.keyBy */ keyBy( iteratee?: string, thisArg?: any ): LoDashExplicitObjectWrapper>; /** * @see _.keyBy */ keyBy( iteratee?: W ): LoDashExplicitObjectWrapper>; /** * @see _.keyBy */ keyBy( iteratee?: Object ): LoDashExplicitObjectWrapper>; } //_.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( collection: TValue[], methodName: string, ...args: any[]): TResult[]; /** * @see _.invokeMap **/ invokeMap( collection: Dictionary, methodName: string, ...args: any[]): TResult[]; /** * @see _.invokeMap **/ invokeMap( collection: {}[], methodName: string, ...args: any[]): TResult[]; /** * @see _.invokeMap **/ invokeMap( collection: Dictionary<{}>, methodName: string, ...args: any[]): TResult[]; /** * @see _.invokeMap **/ invokeMap( collection: TValue[], method: (...args: any[]) => TResult, ...args: any[]): TResult[]; /** * @see _.invokeMap **/ invokeMap( collection: Dictionary, method: (...args: any[]) => TResult, ...args: any[]): TResult[]; /** * @see _.invokeMap **/ invokeMap( collection: {}[], method: (...args: any[]) => TResult, ...args: any[]): TResult[]; /** * @see _.invokeMap **/ invokeMap( collection: Dictionary<{}>, method: (...args: any[]) => TResult, ...args: any[]): TResult[]; } interface LoDashImplicitArrayWrapper { /** * @see _.invokeMap **/ invokeMap( methodName: string, ...args: any[]): LoDashImplicitArrayWrapper; /** * @see _.invokeMap **/ invokeMap( method: (...args: any[]) => TResult, ...args: any[]): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.invokeMap **/ invokeMap( methodName: string, ...args: any[]): LoDashImplicitArrayWrapper; /** * @see _.invokeMap **/ invokeMap( method: (...args: any[]) => TResult, ...args: any[]): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.invokeMap **/ invokeMap( methodName: string, ...args: any[]): LoDashExplicitArrayWrapper; /** * @see _.invokeMap **/ invokeMap( method: (...args: any[]) => TResult, ...args: any[]): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.invokeMap **/ invokeMap( methodName: string, ...args: any[]): LoDashExplicitArrayWrapper; /** * @see _.invokeMap **/ invokeMap( method: (...args: any[]) => TResult, ...args: any[]): LoDashExplicitArrayWrapper; } //_.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( collection: List, iteratee?: ListIterator, thisArg?: any ): TResult[]; /** * @see _.map */ map( collection: Dictionary, iteratee?: DictionaryIterator, thisArg?: any ): TResult[]; /** * @see _.map */ map( collection: List|Dictionary, iteratee?: string ): TResult[]; /** * @see _.map */ map( collection: List|Dictionary, iteratee?: TObject ): boolean[]; } interface LoDashImplicitArrayWrapper { /** * @see _.map */ map( iteratee?: ListIterator, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.map */ map( iteratee?: string ): LoDashImplicitArrayWrapper; /** * @see _.map */ map( iteratee?: TObject ): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.map */ map( iteratee?: ListIterator|DictionaryIterator, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.map */ map( iteratee?: string ): LoDashImplicitArrayWrapper; /** * @see _.map */ map( iteratee?: TObject ): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.map */ map( iteratee?: ListIterator, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.map */ map( iteratee?: string ): LoDashExplicitArrayWrapper; /** * @see _.map */ map( iteratee?: TObject ): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.map */ map( iteratee?: ListIterator|DictionaryIterator, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.map */ map( iteratee?: string ): LoDashExplicitArrayWrapper; /** * @see _.map */ map( iteratee?: TObject ): LoDashExplicitArrayWrapper; } //_.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( collection: List, callback: ListIterator, thisArg?: any): T[][]; /** * @see _.partition **/ partition( collection: Dictionary, callback: DictionaryIterator, thisArg?: any): T[][]; /** * @see _.partition **/ partition( collection: List, whereValue: W): T[][]; /** * @see _.partition **/ partition( collection: Dictionary, whereValue: W): T[][]; /** * @see _.partition **/ partition( collection: List, path: string, srcValue: any): T[][]; /** * @see _.partition **/ partition( collection: Dictionary, path: string, srcValue: any): T[][]; /** * @see _.partition **/ partition( collection: List, pluckValue: string): T[][]; /** * @see _.partition **/ partition( collection: Dictionary, pluckValue: string): T[][]; } interface LoDashImplicitStringWrapper { /** * @see _.partition */ partition( callback: ListIterator, thisArg?: any): LoDashImplicitArrayWrapper; } interface LoDashImplicitArrayWrapper { /** * @see _.partition */ partition( callback: ListIterator, thisArg?: any): LoDashImplicitArrayWrapper; /** * @see _.partition */ partition( whereValue: W): LoDashImplicitArrayWrapper; /** * @see _.partition */ partition( path: string, srcValue: any): LoDashImplicitArrayWrapper; /** * @see _.partition */ partition( pluckValue: string): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.partition */ partition( callback: ListIterator, thisArg?: any): LoDashImplicitArrayWrapper; /** * @see _.partition */ partition( callback: DictionaryIterator, thisArg?: any): LoDashImplicitArrayWrapper; /** * @see _.partition */ partition( whereValue: W): LoDashImplicitArrayWrapper; /** * @see _.partition */ partition( path: string, srcValue: any): LoDashImplicitArrayWrapper; /** * @see _.partition */ partition( pluckValue: string): LoDashImplicitArrayWrapper; } //_.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( collection: Array, callback: MemoIterator, accumulator: TResult, thisArg?: any): TResult; /** * @see _.reduce **/ reduce( collection: List, callback: MemoIterator, accumulator: TResult, thisArg?: any): TResult; /** * @see _.reduce **/ reduce( collection: Dictionary, callback: MemoIterator, accumulator: TResult, thisArg?: any): TResult; /** * @see _.reduce **/ reduce( collection: Array, callback: MemoIterator, thisArg?: any): TResult; /** * @see _.reduce **/ reduce( collection: List, callback: MemoIterator, thisArg?: any): TResult; /** * @see _.reduce **/ reduce( collection: Dictionary, callback: MemoIterator, thisArg?: any): TResult; } interface LoDashImplicitArrayWrapper { /** * @see _.reduce **/ reduce( callback: MemoIterator, accumulator: TResult, thisArg?: any): TResult; /** * @see _.reduce **/ reduce( callback: MemoIterator, thisArg?: any): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.reduce **/ reduce( callback: MemoIterator, accumulator: TResult, thisArg?: any): TResult; /** * @see _.reduce **/ reduce( callback: MemoIterator, thisArg?: any): 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( collection: Array, callback: MemoIterator, accumulator: TResult, thisArg?: any): TResult; /** * @see _.reduceRight **/ reduceRight( collection: List, callback: MemoIterator, accumulator: TResult, thisArg?: any): TResult; /** * @see _.reduceRight **/ reduceRight( collection: Dictionary, callback: MemoIterator, accumulator: TResult, thisArg?: any): TResult; /** * @see _.reduceRight **/ reduceRight( collection: Array, callback: MemoIterator, thisArg?: any): TResult; /** * @see _.reduceRight **/ reduceRight( collection: List, callback: MemoIterator, thisArg?: any): TResult; /** * @see _.reduceRight **/ reduceRight( collection: Dictionary, callback: MemoIterator, thisArg?: any): 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( collection: List, predicate?: ListIterator, thisArg?: any ): T[]; /** * @see _.reject */ reject( collection: Dictionary, predicate?: DictionaryIterator, thisArg?: any ): T[]; /** * @see _.reject */ reject( collection: string, predicate?: StringIterator, thisArg?: any ): string[]; /** * @see _.reject */ reject( collection: List|Dictionary, predicate: string, thisArg?: any ): T[]; /** * @see _.reject */ reject( collection: List|Dictionary, predicate: W ): T[]; } interface LoDashImplicitWrapper { /** * @see _.reject */ reject( predicate?: StringIterator, thisArg?: any ): LoDashImplicitArrayWrapper; } interface LoDashImplicitArrayWrapper { /** * @see _.reject */ reject( predicate: ListIterator, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.reject */ reject( predicate: string, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.reject */ reject(predicate: W): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.reject */ reject( predicate: ListIterator|DictionaryIterator, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.reject */ reject( predicate: string, thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.reject */ reject(predicate: W): LoDashImplicitArrayWrapper; } interface LoDashExplicitWrapper { /** * @see _.reject */ reject( predicate?: StringIterator, thisArg?: any ): LoDashExplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.reject */ reject( predicate: ListIterator, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.reject */ reject( predicate: string, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.reject */ reject(predicate: W): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.reject */ reject( predicate: ListIterator|DictionaryIterator, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.reject */ reject( predicate: string, thisArg?: any ): LoDashExplicitArrayWrapper; /** * @see _.reject */ reject(predicate: W): LoDashExplicitArrayWrapper; } //_.sample interface LoDashStatic { /** * Gets a random element from `collection`. * * @static * @memberOf _ * @category Collection * @param {Array|Object} collection The collection to sample. * @returns {*} Returns the random element. * @example * * _.sample([1, 2, 3, 4]); * // => 2 */ sample(collection: Array): T; /** * @see _.sample **/ sample(collection: List): T; /** * @see _.sample **/ sample(collection: Dictionary): T; } interface LoDashImplicitArrayWrapper { /** * @see _.sample **/ sample(): LoDashImplicitWrapper; } //_.sampleSize interface LoDashStatic { /** * Gets `n` random elements from `collection`. * * @static * @memberOf _ * @category Collection * @param {Array|Object} collection The collection to sample. * @param {number} [n=0] The number of elements to sample. * @returns {Array} Returns the random elements. * @example * * _.sampleSize([1, 2, 3, 4], 2); * // => [3, 1] */ sampleSize(collection: Array, n: number): T[]; /** * @see _.sampleSize **/ sampleSize(collection: List, n: number): T[]; /** * @see _.sampleSize **/ sampleSize(collection: Dictionary, n: number): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.sampleSize **/ sampleSize(n: number): LoDashImplicitArrayWrapper; /** * @see _.sampleSize **/ sampleSize(): LoDashImplicitWrapper; } //_.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(collection: List|Dictionary): T[]; /** * @see _.shuffle */ shuffle(collection: string): string[]; } interface LoDashImplicitWrapper { /** * @see _.shuffle */ shuffle(): LoDashImplicitArrayWrapper; } interface LoDashImplicitArrayWrapper { /** * @see _.shuffle */ shuffle(): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.shuffle */ shuffle(): LoDashImplicitArrayWrapper; } interface LoDashExplicitWrapper { /** * @see _.shuffle */ shuffle(): LoDashExplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.shuffle */ shuffle(): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.shuffle */ shuffle(): LoDashExplicitArrayWrapper; } //_.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(collection: List|Dictionary): number; /** * @see _.size */ size(collection: string): number; } interface LoDashImplicitWrapper { /** * @see _.size */ size(): number; } interface LoDashImplicitArrayWrapper { /** * @see _.size */ size(): number; } interface LoDashImplicitObjectWrapper { /** * @see _.size */ size(): number; } interface LoDashExplicitWrapper { /** * @see _.size */ size(): LoDashExplicitWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.size */ size(): LoDashExplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.size */ size(): LoDashExplicitWrapper; } //_.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( collection: List, predicate?: ListIterator ): boolean; /** * @see _.some */ some( collection: Dictionary, predicate?: DictionaryIterator ): boolean; /** * @see _.some */ some( collection: NumericDictionary, predicate?: NumericDictionaryIterator ): boolean; /** * @see _.some */ some( collection: List|Dictionary|NumericDictionary, predicate?: string|any[] ): boolean; /** * @see _.some */ some( collection: List|Dictionary|NumericDictionary, predicate?: TObject ): boolean; } interface LoDashImplicitArrayWrapper { /** * @see _.some */ some( predicate?: ListIterator|NumericDictionaryIterator ): boolean; /** * @see _.some */ some( predicate?: string|any[] ): boolean; /** * @see _.some */ some( predicate?: TObject ): boolean; } interface LoDashImplicitObjectWrapper { /** * @see _.some */ some( predicate?: ListIterator|DictionaryIterator|NumericDictionaryIterator ): boolean; /** * @see _.some */ some( predicate?: string|any[] ): boolean; /** * @see _.some */ some( predicate?: TObject ): boolean; } interface LoDashExplicitArrayWrapper { /** * @see _.some */ some( predicate?: ListIterator|NumericDictionaryIterator ): LoDashExplicitWrapper; /** * @see _.some */ some( predicate?: string|any[] ): LoDashExplicitWrapper; /** * @see _.some */ some( predicate?: TObject ): LoDashExplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.some */ some( predicate?: ListIterator|DictionaryIterator|NumericDictionaryIterator ): LoDashExplicitWrapper; /** * @see _.some */ some( predicate?: string|any[] ): LoDashExplicitWrapper; /** * @see _.some */ some( predicate?: TObject ): LoDashExplicitWrapper; } //_.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( collection: List, iteratee?: ListIterator ): T[]; /** * @see _.sortBy */ sortBy( collection: Dictionary, iteratee?: DictionaryIterator ): T[]; /** * @see _.sortBy */ sortBy( collection: List|Dictionary, iteratee: string ): T[]; /** * @see _.sortBy */ sortBy( collection: List|Dictionary, whereValue: W ): T[]; /** * @see _.sortBy */ sortBy( collection: List|Dictionary ): T[]; /** * @see _.sortBy */ sortBy( collection: (Array|List), iteratees: (ListIterator|string|Object)[]): T[]; /** * @see _.sortBy */ sortBy( collection: (Array|List), ...iteratees: (ListIterator|Object|string)[]): T[]; } interface LoDashImplicitArrayWrapper { /** * @see _.sortBy */ sortBy( iteratee?: ListIterator ): LoDashImplicitArrayWrapper; /** * @see _.sortBy */ sortBy(iteratee: string): LoDashImplicitArrayWrapper; /** * @see _.sortBy */ sortBy(whereValue: W): LoDashImplicitArrayWrapper; /** * @see _.sortBy */ sortBy(): LoDashImplicitArrayWrapper; /** * @see _.sortBy */ sortBy(...iteratees: (ListIterator|Object|string)[]): LoDashImplicitArrayWrapper; /** * @see _.sortBy **/ sortBy(iteratees: (ListIterator|string|Object)[]): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.sortBy */ sortBy( iteratee?: ListIterator|DictionaryIterator ): LoDashImplicitArrayWrapper; /** * @see _.sortBy */ sortBy(iteratee: string): LoDashImplicitArrayWrapper; /** * @see _.sortBy */ sortBy(whereValue: W): LoDashImplicitArrayWrapper; /** * @see _.sortBy */ sortBy(): LoDashImplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.sortBy */ sortBy( iteratee?: ListIterator ): LoDashExplicitArrayWrapper; /** * @see _.sortBy */ sortBy(iteratee: string): LoDashExplicitArrayWrapper; /** * @see _.sortBy */ sortBy(whereValue: W): LoDashExplicitArrayWrapper; /** * @see _.sortBy */ sortBy(): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.sortBy */ sortBy( iteratee?: ListIterator|DictionaryIterator ): LoDashExplicitArrayWrapper; /** * @see _.sortBy */ sortBy(iteratee: string): LoDashExplicitArrayWrapper; /** * @see _.sortBy */ sortBy(whereValue: W): LoDashExplicitArrayWrapper; /** * @see _.sortBy */ sortBy(): LoDashExplicitArrayWrapper; } //_.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( collection: List, iteratees: ListIterator|string|W|(ListIterator|string|W)[], orders?: boolean|string|(boolean|string)[] ): T[]; /** * @see _.orderBy */ orderBy( collection: List, iteratees: ListIterator|string|Object|(ListIterator|string|Object)[], orders?: boolean|string|(boolean|string)[] ): T[]; /** * @see _.orderBy */ orderBy( collection: NumericDictionary, iteratees: NumericDictionaryIterator|string|W|(NumericDictionaryIterator|string|W)[], orders?: boolean|string|(boolean|string)[] ): T[]; /** * @see _.orderBy */ orderBy( collection: NumericDictionary, iteratees: NumericDictionaryIterator|string|Object|(NumericDictionaryIterator|string|Object)[], orders?: boolean|string|(boolean|string)[] ): T[]; /** * @see _.orderBy */ orderBy( collection: Dictionary, iteratees: DictionaryIterator|string|W|(DictionaryIterator|string|W)[], orders?: boolean|string|(boolean|string)[] ): T[]; /** * @see _.orderBy */ orderBy( collection: Dictionary, iteratees: DictionaryIterator|string|Object|(DictionaryIterator|string|Object)[], orders?: boolean|string|(boolean|string)[] ): T[]; } interface LoDashImplicitWrapper { /** * @see _.orderBy */ orderBy( iteratees: ListIterator|string|(ListIterator|string)[], orders?: boolean|string|(boolean|string)[] ): LoDashImplicitArrayWrapper; } interface LoDashImplicitArrayWrapper { /** * @see _.orderBy */ orderBy( iteratees: ListIterator|string|W|(ListIterator|string|W)[], orders?: boolean|string|(boolean|string)[] ): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.orderBy */ orderBy( iteratees: ListIterator|string|W|(ListIterator|string|W)[], orders?: boolean|string|(boolean|string)[] ): LoDashImplicitArrayWrapper; /** * @see _.orderBy */ orderBy( iteratees: ListIterator|string|Object|(ListIterator|string|Object)[], orders?: boolean|string|(boolean|string)[] ): LoDashImplicitArrayWrapper; /** * @see _.orderBy */ orderBy( iteratees: NumericDictionaryIterator|string|W|(NumericDictionaryIterator|string|W)[], orders?: boolean|string|(boolean|string)[] ): LoDashImplicitArrayWrapper; /** * @see _.orderBy */ orderBy( iteratees: NumericDictionaryIterator|string|Object|(NumericDictionaryIterator|string|Object)[], orders?: boolean|string|(boolean|string)[] ): LoDashImplicitArrayWrapper; /** * @see _.orderBy */ orderBy( iteratees: DictionaryIterator|string|W|(DictionaryIterator|string|W)[], orders?: boolean|string|(boolean|string)[] ): LoDashImplicitArrayWrapper; /** * @see _.orderBy */ orderBy( iteratees: DictionaryIterator|string|Object|(DictionaryIterator|string|Object)[], orders?: boolean|string|(boolean|string)[] ): LoDashImplicitArrayWrapper; } interface LoDashExplicitWrapper { /** * @see _.orderBy */ orderBy( iteratees: ListIterator|string|(ListIterator|string)[], orders?: boolean|string|(boolean|string)[] ): LoDashExplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.orderBy */ orderBy( iteratees: ListIterator|string|W|(ListIterator|string|W)[], orders?: boolean|string|(boolean|string)[] ): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.orderBy */ orderBy( iteratees: ListIterator|string|W|(ListIterator|string|W)[], orders?: boolean|string|(boolean|string)[] ): LoDashExplicitArrayWrapper; /** * @see _.orderBy */ orderBy( iteratees: ListIterator|string|Object|(ListIterator|string|Object)[], orders?: boolean|string|(boolean|string)[] ): LoDashExplicitArrayWrapper; /** * @see _.orderBy */ orderBy( iteratees: NumericDictionaryIterator|string|W|(NumericDictionaryIterator|string|W)[], orders?: boolean|string|(boolean|string)[] ): LoDashExplicitArrayWrapper; /** * @see _.orderBy */ orderBy( iteratees: NumericDictionaryIterator|string|Object|(NumericDictionaryIterator|string|Object)[], orders?: boolean|string|(boolean|string)[] ): LoDashExplicitArrayWrapper; /** * @see _.orderBy */ orderBy( iteratees: DictionaryIterator|string|W|(DictionaryIterator|string|W)[], orders?: boolean|string|(boolean|string)[] ): LoDashExplicitArrayWrapper; /** * @see _.orderBy */ orderBy( iteratees: DictionaryIterator|string|Object|(DictionaryIterator|string|Object)[], orders?: boolean|string|(boolean|string)[] ): LoDashExplicitArrayWrapper; } /******** * 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 { /** * @see _.now */ now(): number; } interface LoDashExplicitWrapperBase { /** * @see _.now */ now(): LoDashExplicitWrapper; } /************* * 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( n: number, func: TFunc ): TFunc; } interface LoDashImplicitWrapper { /** * @see _.after **/ after(func: TFunc): LoDashImplicitObjectWrapper; } interface LoDashExplicitWrapper { /** * @see _.after **/ after(func: TFunc): LoDashExplicitObjectWrapper; } //_.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( func: Function, n?: number ): TResult; ary( func: T, n?: number ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.ary */ ary(n?: number): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.ary */ ary(n?: number): LoDashExplicitObjectWrapper; } //_.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( n: number, func: TFunc ): TFunc; } interface LoDashImplicitWrapper { /** * @see _.before **/ before(func: TFunc): LoDashImplicitObjectWrapper; } interface LoDashExplicitWrapper { /** * @see _.before **/ before(func: TFunc): LoDashExplicitObjectWrapper; } //_.bind interface FunctionBind { placeholder: any; ( func: T, thisArg: any, ...partials: any[] ): TResult; ( 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 { /** * @see _.bind */ bind( thisArg: any, ...partials: any[] ): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.bind */ bind( thisArg: any, ...partials: any[] ): LoDashExplicitObjectWrapper; } //_.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( object: T, ...methodNames: (string|string[])[] ): T; } interface LoDashImplicitObjectWrapper { /** * @see _.bindAll */ bindAll(...methodNames: (string|string[])[]): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.bindAll */ bindAll(...methodNames: (string|string[])[]): LoDashExplicitObjectWrapper; } //_.bindKey interface FunctionBindKey { placeholder: any; ( object: T, key: any, ...partials: any[] ): TResult; ( 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 { /** * @see _.bindKey */ bindKey( key: any, ...partials: any[] ): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.bindKey */ bindKey( key: any, ...partials: any[] ): LoDashExplicitObjectWrapper; } //_.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, thisArg?: any, argCount?: number): () => any; /** * @see _.createCallback **/ createCallback( func: Dictionary, thisArg?: any, argCount?: number): () => boolean; } interface LoDashImplicitWrapper { /** * @see _.createCallback **/ createCallback( thisArg?: any, argCount?: number): LoDashImplicitObjectWrapper<() => any>; } interface LoDashImplicitObjectWrapper { /** * @see _.createCallback **/ createCallback( thisArg?: any, 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(func: (t1: T1) => R): CurriedFunction1; /** * 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(func: (t1: T1, t2: T2) => R): CurriedFunction2; /** * 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(func: (t1: T1, t2: T2, t3: T3) => R): CurriedFunction3; /** * 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(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R): CurriedFunction4; /** * 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(func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R): CurriedFunction5; /** * 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( func: Function, arity?: number): TResult; } interface CurriedFunction1 { (): CurriedFunction1; (t1: T1): R; } interface CurriedFunction2 { (): CurriedFunction2; (t1: T1): CurriedFunction1; (t1: T1, t2: T2): R; } interface CurriedFunction3 { (): CurriedFunction3; (t1: T1): CurriedFunction2; (t1: T1, t2: T2): CurriedFunction1; (t1: T1, t2: T2, t3: T3): R; } interface CurriedFunction4 { (): CurriedFunction4; (t1: T1): CurriedFunction3; (t1: T1, t2: T2): CurriedFunction2; (t1: T1, t2: T2, t3: T3): CurriedFunction1; (t1: T1, t2: T2, t3: T3, t4: T4): R; } interface CurriedFunction5 { (): CurriedFunction5; (t1: T1): CurriedFunction4; (t1: T1, t2: T2): CurriedFunction3; (t1: T1, t2: T2, t3: T3): CurriedFunction2; (t1: T1, t2: T2, t3: T3, t4: T4): CurriedFunction1; (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5): R; } interface LoDashImplicitObjectWrapper { /** * @see _.curry **/ curry(arity?: number): LoDashImplicitObjectWrapper; } //_.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(func: (t1: T1) => R): CurriedFunction1; /** * 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(func: (t1: T1, t2: T2) => R): CurriedFunction2; /** * 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(func: (t1: T1, t2: T2, t3: T3) => R): CurriedFunction3; /** * 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(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R): CurriedFunction4; /** * 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(func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R): CurriedFunction5; /** * 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( func: Function, arity?: number): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.curryRight **/ curryRight(arity?: number): LoDashImplicitObjectWrapper; } //_.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. 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( func: T, wait?: number, options?: DebounceSettings ): T & Cancelable; } interface LoDashImplicitObjectWrapper { /** * @see _.debounce */ debounce( wait?: number, options?: DebounceSettings ): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.debounce */ debounce( wait?: number, options?: DebounceSettings ): LoDashExplicitObjectWrapper; } //_.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( func: T, ...args: any[] ): number; } interface LoDashImplicitObjectWrapper { /** * @see _.defer */ defer(...args: any[]): LoDashImplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.defer */ defer(...args: any[]): LoDashExplicitWrapper; } //_.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( func: T, wait: number, ...args: any[] ): number; } interface LoDashImplicitObjectWrapper { /** * @see _.delay */ delay( wait: number, ...args: any[] ): LoDashImplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.delay */ delay( wait: number, ...args: any[] ): LoDashExplicitWrapper; } 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(func: T): T; } interface LoDashImplicitObjectWrapper { /** * @see _.flip */ flip(): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.flip */ flip(): LoDashExplicitObjectWrapper; } //_.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. */ flow(...funcs: Function[]): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.flow */ flow(...funcs: Function[]): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.flow */ flow(...funcs: Function[]): LoDashExplicitObjectWrapper; } //_.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(...funcs: Function[]): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.flowRight */ flowRight(...funcs: Function[]): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.flowRight */ flowRight(...funcs: Function[]): LoDashExplicitObjectWrapper; } //_.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: { (func: T, resolver?: Function): T & MemoizedFunction; Cache: MapCache; } } interface LoDashImplicitObjectWrapper { /** * @see _.memoize */ memoize(resolver?: Function): LoDashImplicitObjectWrapper; } //_.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( func: T, ...transforms: Function[] ): TResult; /** * @see _.overArgs */ overArgs( func: T, transforms: Function[] ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.overArgs */ overArgs(...transforms: Function[]): LoDashImplicitObjectWrapper; /** * @see _.overArgs */ overArgs(transforms: Function[]): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.overArgs */ overArgs(...transforms: Function[]): LoDashExplicitObjectWrapper; /** * @see _.overArgs */ overArgs(transforms: Function[]): LoDashExplicitObjectWrapper; } //_.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(predicate: T): (...args: any[]) => boolean; /** * @see _.negate */ negate(predicate: T): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.negate */ negate(): LoDashImplicitObjectWrapper<(...args: any[]) => boolean>; /** * @see _.negate */ negate(): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.negate */ negate(): LoDashExplicitObjectWrapper<(...args: any[]) => boolean>; /** * @see _.negate */ negate(): LoDashExplicitObjectWrapper; } //_.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(func: T): T; } interface LoDashImplicitObjectWrapper { /** * @see _.once */ once(): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.once */ once(): LoDashExplicitObjectWrapper; } //_.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; } interface Function1 { (t1: T1): R; } interface Function2 { (t1: T1, t2: T2): R; } interface Function3 { (t1: T1, t2: T2, t3: T3): R; } interface Function4 { (t1: T1, t2: T2, t3: T3, t4: T4): R; } interface Partial { // arity 0 (func: Function0): Function0; // arity 1 (func: Function1): Function1; (func: Function1, arg1: T1): Function0; // arity 2 (func: Function2): Function2; (func: Function2, arg1: T1): Function1< T2, R>; (func: Function2, plc1: PH, arg2: T2): Function1; (func: Function2, arg1: T1, arg2: T2): Function0< R>; // arity 3 (func: Function3): Function3; (func: Function3, arg1: T1): Function2< T2, T3, R>; (func: Function3, plc1: PH, arg2: T2): Function2; (func: Function3, arg1: T1, arg2: T2): Function1< T3, R>; (func: Function3, plc1: PH, plc2: PH, arg3: T3): Function2; (func: Function3, arg1: T1, plc2: PH, arg3: T3): Function1< T2, R>; (func: Function3, plc1: PH, arg2: T2, arg3: T3): Function1; (func: Function3, arg1: T1, arg2: T2, arg3: T3): Function0< R>; // arity 4 (func: Function4): Function4; (func: Function4, arg1: T1): Function3< T2, T3, T4, R>; (func: Function4, plc1: PH, arg2: T2): Function3; (func: Function4, arg1: T1, arg2: T2): Function2< T3, T4, R>; (func: Function4, plc1: PH, plc2: PH, arg3: T3): Function3; (func: Function4, arg1: T1, plc2: PH, arg3: T3): Function2< T2, T4, R>; (func: Function4, plc1: PH, arg2: T2, arg3: T3): Function2; (func: Function4, arg1: T1, arg2: T2, arg3: T3): Function1< T4, R>; (func: Function4, plc1: PH, plc2: PH, plc3: PH, arg4: T4): Function3; (func: Function4, arg1: T1, plc2: PH, plc3: PH, arg4: T4): Function2< T2, T3, R>; (func: Function4, plc1: PH, arg2: T2, plc3: PH, arg4: T4): Function2; (func: Function4, arg1: T1, arg2: T2, plc3: PH, arg4: T4): Function1< T3, R>; (func: Function4, plc1: PH, plc2: PH, arg3: T3, arg4: T4): Function2; (func: Function4, arg1: T1, plc2: PH, arg3: T3, arg4: T4): Function1< T2, R>; (func: Function4, plc1: PH, arg2: T2, arg3: T3, arg4: T4): Function1; (func: Function4, 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 (func: Function0): Function0; // arity 1 (func: Function1): Function1; (func: Function1, arg1: T1): Function0; // arity 2 (func: Function2): Function2; (func: Function2, arg1: T1, plc2: PH): Function1< T2, R>; (func: Function2, arg2: T2): Function1; (func: Function2, arg1: T1, arg2: T2): Function0< R>; // arity 3 (func: Function3): Function3; (func: Function3, arg1: T1, plc2: PH, plc3: PH): Function2< T2, T3, R>; (func: Function3, arg2: T2, plc3: PH): Function2; (func: Function3, arg1: T1, arg2: T2, plc3: PH): Function1< T3, R>; (func: Function3, arg3: T3): Function2; (func: Function3, arg1: T1, plc2: PH, arg3: T3): Function1< T2, R>; (func: Function3, arg2: T2, arg3: T3): Function1; (func: Function3, arg1: T1, arg2: T2, arg3: T3): Function0< R>; // arity 4 (func: Function4): Function4; (func: Function4, arg1: T1, plc2: PH, plc3: PH, plc4: PH): Function3< T2, T3, T4, R>; (func: Function4, arg2: T2, plc3: PH, plc4: PH): Function3; (func: Function4, arg1: T1, arg2: T2, plc3: PH, plc4: PH): Function2< T3, T4, R>; (func: Function4, arg3: T3, plc4: PH): Function3; (func: Function4, arg1: T1, plc2: PH, arg3: T3, plc4: PH): Function2< T2, T4, R>; (func: Function4, arg2: T2, arg3: T3, plc4: PH): Function2; (func: Function4, arg1: T1, arg2: T2, arg3: T3, plc4: PH): Function1< T4, R>; (func: Function4, arg4: T4): Function3; (func: Function4, arg1: T1, plc2: PH, plc3: PH, arg4: T4): Function2< T2, T3, R>; (func: Function4, arg2: T2, plc3: PH, arg4: T4): Function2; (func: Function4, arg1: T1, arg2: T2, plc3: PH, arg4: T4): Function1< T3, R>; (func: Function4, arg3: T3, arg4: T4): Function2; (func: Function4, arg1: T1, plc2: PH, arg3: T3, arg4: T4): Function1< T2, R>; (func: Function4, arg2: T2, arg3: T3, arg4: T4): Function1; (func: Function4, 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(func: Function, indexes: number[]): TResult; /** * @see _.rearg */ rearg(func: Function, ...indexes: number[]): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.rearg */ rearg(indexes: number[]): LoDashImplicitObjectWrapper; /** * @see _.rearg */ rearg(...indexes: number[]): LoDashImplicitObjectWrapper; } //_.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( func: Function, start?: number ): TResult; /** * @see _.rest */ rest( func: TFunc, start?: number ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.rest */ rest(start?: number): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.rest */ rest(start?: number): LoDashExplicitObjectWrapper; } //_.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(func: F): T; /** * @see _.spread */ spread(func: Function): T; } interface LoDashImplicitObjectWrapper { /** * @see _.spread */ spread(): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.spread */ spread(): LoDashExplicitObjectWrapper; } //_.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. 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( func: T, wait?: number, options?: ThrottleSettings ): T & Cancelable; } interface LoDashImplicitObjectWrapper { /** * @see _.throttle */ throttle( wait?: number, options?: ThrottleSettings ): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.throttle */ throttle( wait?: number, options?: ThrottleSettings ): LoDashExplicitObjectWrapper; } //_.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(func: T): T; } interface LoDashImplicitObjectWrapper { /** * @see _.unary */ unary(): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.unary */ unary(): LoDashExplicitObjectWrapper; } //_.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( value: V, wrapper: W ): R; /** * @see _.wrap */ wrap( value: V, wrapper: Function ): R; /** * @see _.wrap */ wrap( value: any, wrapper: Function ): R; } interface LoDashImplicitWrapper { /** * @see _.wrap */ wrap(wrapper: W): LoDashImplicitObjectWrapper; /** * @see _.wrap */ wrap(wrapper: Function): LoDashImplicitObjectWrapper; } interface LoDashImplicitArrayWrapper { /** * @see _.wrap */ wrap(wrapper: W): LoDashImplicitObjectWrapper; /** * @see _.wrap */ wrap(wrapper: Function): LoDashImplicitObjectWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.wrap */ wrap(wrapper: W): LoDashImplicitObjectWrapper; /** * @see _.wrap */ wrap(wrapper: Function): LoDashImplicitObjectWrapper; } interface LoDashExplicitWrapper { /** * @see _.wrap */ wrap(wrapper: W): LoDashExplicitObjectWrapper; /** * @see _.wrap */ wrap(wrapper: Function): LoDashExplicitObjectWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.wrap */ wrap(wrapper: W): LoDashExplicitObjectWrapper; /** * @see _.wrap */ wrap(wrapper: Function): LoDashExplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.wrap */ wrap(wrapper: W): LoDashExplicitObjectWrapper; /** * @see _.wrap */ wrap(wrapper: Function): LoDashExplicitObjectWrapper; } /******** * Lang * ********/ //_.clone interface LoDashStatic { /** * Creates a shallow clone of `value`. * * **Note:** This method is loosely based on the * [structured clone algorithm](https://mdn.io/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. * * @static * @memberOf _ * @category Lang * @param {*} value The value to clone. * @returns {*} Returns the cloned value. * @example * * var objects = [{ 'a': 1 }, { 'b': 2 }]; * * var shallow = _.clone(objects); * console.log(shallow[0] === objects[0]); * // => true */ clone(value: T): T; } interface LoDashImplicitWrapper { /** * @see _.clone */ clone(): T; } interface LoDashImplicitArrayWrapper { /** * @see _.clone */ clone(): T[]; } interface LoDashImplicitObjectWrapper { /** * @see _.clone */ clone(): T; } //_.cloneDeep interface LoDashStatic { /** * This method is like `_.clone` except that it recursively clones `value`. * * @static * @memberOf _ * @category Lang * @param {*} value The value to recursively clone. * @returns {*} Returns the deep cloned value. * @example * * var objects = [{ 'a': 1 }, { 'b': 2 }]; * * var deep = _.cloneDeep(objects); * console.log(deep[0] === objects[0]); * // => false */ cloneDeep(value: T): T; } interface LoDashImplicitWrapper { /** * @see _.cloneDeep */ cloneDeep(): T; } interface LoDashImplicitArrayWrapper { /** * @see _.cloneDeep */ cloneDeep(): T[]; } interface LoDashImplicitObjectWrapper { /** * @see _.cloneDeep */ cloneDeep(): T; } //_.cloneWith interface LoDashStatic { /** * Creates a shallow clone of `value`. * * **Note:** This method is loosely based on the * [structured clone algorithm](https://mdn.io/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. * * @static * @memberOf _ * @category Lang * @param {*} value The value to clone. * @returns {*} Returns the cloned value. * @example * * var objects = [{ 'a': 1 }, { 'b': 2 }]; * * var shallow = _.clone(objects); * console.log(shallow[0] === objects[0]); * // => true */ clone( value: T, customizer: (value: any) => any): T; } interface LoDashImplicitWrapper { /** * @see _.clone */ clone(customizer: (value: any) => any): T; } interface LoDashImplicitArrayWrapper { /** * @see _.clone */ clone(customizer: (value: any) => any): T[]; } interface LoDashImplicitObjectWrapper { /** * @see _.clone */ clone(customizer: (value: any) => any): T; } //_.cloneDeepWith interface LoDashStatic { /** * Creates a deep clone of value. If customizer is provided it’s invoked to produce the cloned values. If * customizer returns undefined cloning is handled by the method instead. The customizer is bound to thisArg * and invoked with up to three argument; (value [, index|key, object]). * Note: This method is loosely based on the structured clone algorithm. The enumerable properties of arguments * objects and objects created by constructors other than Object are cloned to plain Object objects. An empty * object is returned for uncloneable values such as functions, DOM nodes, Maps, Sets, and WeakMaps. * @param value The value to deep clone. * @param customizer The function to customize cloning values. * @param thisArg The this binding of customizer. * @return Returns the deep cloned value. */ cloneDeep( value: T, customizer: (value: any) => any): T; } interface LoDashImplicitWrapper { /** * @see _.cloneDeep */ cloneDeep(customizer: (value: any) => any): T; } interface LoDashImplicitArrayWrapper { /** * @see _.cloneDeep */ cloneDeep(customizer: (value: any) => any): T[]; } interface LoDashImplicitObjectWrapper { /** * @see _.cloneDeep */ cloneDeep(customizer: (value: any) => any): T; } //_.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 { /** * @see _.isEqual */ eq( other: any ): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.isEqual */ eq( other: any ): LoDashExplicitWrapper; } //_.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 { /** * @see _.gt */ gt(other: any): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.gt */ gt(other: any): LoDashExplicitWrapper; } //_.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 { /** * @see _.gte */ gte(other: any): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.gte */ gte(other: any): LoDashExplicitWrapper; } //_.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 { /** * @see _.isArguments */ isArguments(): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.isArguments */ isArguments(): LoDashExplicitWrapper; } //_.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(value?: any): value is T[]; } interface LoDashImplicitWrapperBase { /** * @see _.isArray */ isArray(): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.isArray */ isArray(): LoDashExplicitWrapper; } //_.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(value?: any): value is T[]; } interface LoDashImplicitWrapperBase { /** * @see _.isArrayLike */ isArrayLike(): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.isArrayLike */ isArrayLike(): LoDashExplicitWrapper; } //_.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(value?: any): value is T[]; } interface LoDashImplicitWrapperBase { /** * @see _.isArrayLikeObject */ isArrayLikeObject(): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.isArrayLikeObject */ isArrayLikeObject(): LoDashExplicitWrapper; } //_.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 { /** * @see _.isBoolean */ isBoolean(): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.isBoolean */ isBoolean(): LoDashExplicitWrapper; } //_.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 { /** * @see _.isDate */ isDate(): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.isDate */ isDate(): LoDashExplicitWrapper; } //_.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 { /** * @see _.isElement */ isElement(): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.isElement */ isElement(): LoDashExplicitWrapper; } //_.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 { /** * @see _.isEmpty */ isEmpty(): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.isEmpty */ isEmpty(): LoDashExplicitWrapper; } //_.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 { /** * @see _.isEqual */ isEqual( other: any ): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.isEqual */ isEqual( other: any ): LoDashExplicitWrapper; } // _.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 { /** * @see _.isEqualWith */ isEqualWith( other: any, customizer: IsEqualCustomizer ): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.isEqualWith */ isEqualWith( other: any, customizer: IsEqualCustomizer ): LoDashExplicitWrapper; } //_.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 { /** * @see _.isError */ isError(): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.isError */ isError(): LoDashExplicitWrapper; } //_.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 { /** * @see _.isFinite */ isFinite(): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.isFinite */ isFinite(): LoDashExplicitWrapper; } //_.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 { /** * @see _.isFunction */ isFunction(): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.isFunction */ isFunction(): LoDashExplicitWrapper; } //_.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 { /** * @see _.isInteger */ isInteger(): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.isInteger */ isInteger(): LoDashExplicitWrapper; } //_.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 { /** * @see _.isLength */ isLength(): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.isLength */ isLength(): LoDashExplicitWrapper; } //_.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 { /** * @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 { /** * @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 { /** * @see _.isNaN */ isNaN(): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.isNaN */ isNaN(): LoDashExplicitWrapper; } //_.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 { /** * see _.isNative */ isNative(): boolean; } interface LoDashExplicitWrapperBase { /** * see _.isNative */ isNative(): LoDashExplicitWrapper; } //_.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 { /** * see _.isNil */ isNil(): boolean; } interface LoDashExplicitWrapperBase { /** * see _.isNil */ isNil(): LoDashExplicitWrapper; } //_.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 { /** * see _.isNull */ isNull(): boolean; } interface LoDashExplicitWrapperBase { /** * see _.isNull */ isNull(): LoDashExplicitWrapper; } //_.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 { /** * see _.isNumber */ isNumber(): boolean; } interface LoDashExplicitWrapperBase { /** * see _.isNumber */ isNumber(): LoDashExplicitWrapper; } //_.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 { /** * see _.isObject */ isObject(): boolean; } interface LoDashExplicitWrapperBase { /** * see _.isObject */ isObject(): LoDashExplicitWrapper; } //_.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 { /** * see _.isObjectLike */ isObjectLike(): boolean; } interface LoDashExplicitWrapperBase { /** * see _.isObjectLike */ isObjectLike(): LoDashExplicitWrapper; } //_.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 { /** * see _.isPlainObject */ isPlainObject(): boolean; } interface LoDashExplicitWrapperBase { /** * see _.isPlainObject */ isPlainObject(): LoDashExplicitWrapper; } //_.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 { /** * see _.isRegExp */ isRegExp(): boolean; } interface LoDashExplicitWrapperBase { /** * see _.isRegExp */ isRegExp(): LoDashExplicitWrapper; } //_.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 { /** * see _.isSafeInteger */ isSafeInteger(): boolean; } interface LoDashExplicitWrapperBase { /** * see _.isSafeInteger */ isSafeInteger(): LoDashExplicitWrapper; } //_.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 { /** * see _.isString */ isString(): boolean; } interface LoDashExplicitWrapperBase { /** * see _.isString */ isString(): LoDashExplicitWrapper; } //_.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 { /** * see _.isSymbol */ isSymbol(): boolean; } interface LoDashExplicitWrapperBase { /** * see _.isSymbol */ isSymbol(): LoDashExplicitWrapper; } //_.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 { /** * see _.isTypedArray */ isTypedArray(): boolean; } interface LoDashExplicitWrapperBase { /** * see _.isTypedArray */ isTypedArray(): LoDashExplicitWrapper; } //_.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 { /** * see _.isUndefined */ isUndefined(): boolean; } interface LoDashExplicitWrapperBase { /** * see _.isUndefined */ isUndefined(): LoDashExplicitWrapper; } //_.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 { /** * @see _.lt */ lt(other: any): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.lt */ lt(other: any): LoDashExplicitWrapper; } //_.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 { /** * @see _.lte */ lte(other: any): boolean; } interface LoDashExplicitWrapperBase { /** * @see _.lte */ lte(other: any): LoDashExplicitWrapper; } //_.toArray interface LoDashStatic { /** * Converts value to an array. * * @param value The value to convert. * @return Returns the converted array. */ toArray(value: List|Dictionary|NumericDictionary): T[]; /** * @see _.toArray */ toArray(value: TValue): TResult[]; /** * @see _.toArray */ toArray(value?: any): TResult[]; } interface LoDashImplicitWrapper { /** * @see _.toArray */ toArray(): LoDashImplicitArrayWrapper; } interface LoDashImplicitArrayWrapper { /** * @see _.toArray */ toArray(): LoDashImplicitArrayWrapper; } interface LoDashImplicitObjectWrapper { /** * @see _.toArray */ toArray(): LoDashImplicitArrayWrapper; } interface LoDashExplicitWrapper { /** * @see _.toArray */ toArray(): LoDashExplicitArrayWrapper; } interface LoDashExplicitArrayWrapper { /** * @see _.toArray */ toArray(): LoDashExplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.toArray */ toArray(): LoDashExplicitArrayWrapper; } //_.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(value?: any): TResult; } interface LoDashImplicitWrapperBase { /** * @see _.toPlainObject */ toPlainObject(): LoDashImplicitObjectWrapper; } //_.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 { /** * @see _.toInteger */ toInteger(): LoDashImplicitWrapper; } interface LoDashExplicitWrapperBase { /** * @see _.toInteger */ toInteger(): LoDashExplicitWrapper; } //_.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 { /** * @see _.toLength */ toLength(): LoDashImplicitWrapper; } interface LoDashExplicitWrapperBase { /** * @see _.toLength */ toLength(): LoDashExplicitWrapper; } //_.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 { /** * @see _.toNumber */ toNumber(): LoDashImplicitWrapper; } interface LoDashExplicitWrapperBase { /** * @see _.toNumber */ toNumber(): LoDashExplicitWrapper; } //_.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 { /** * @see _.toSafeInteger */ toSafeInteger(): LoDashImplicitWrapper; } interface LoDashExplicitWrapperBase { /** * @see _.toSafeInteger */ toSafeInteger(): LoDashExplicitWrapper; } //_.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 { /** * @see _.add */ add(addend: number): number; } interface LoDashExplicitWrapper { /** * @see _.add */ add(addend: number): LoDashExplicitWrapper; } //_.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 { /** * @see _.ceil */ ceil(precision?: number): number; } interface LoDashExplicitWrapper { /** * @see _.ceil */ ceil(precision?: number): LoDashExplicitWrapper; } //_.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 { /** * @see _.floor */ floor(precision?: number): number; } interface LoDashExplicitWrapper { /** * @see _.floor */ floor(precision?: number): LoDashExplicitWrapper; } //_.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( collection: List ): T; } interface LoDashImplicitArrayWrapper { /** * @see _.max */ max(): T; } interface LoDashImplicitObjectWrapper { /** * @see _.max */ max(): 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( collection: List, iteratee?: ListIterator ): T; /** * @see _.maxBy */ maxBy( collection: Dictionary, iteratee?: DictionaryIterator ): T; /** * @see _.maxBy */ maxBy( collection: List|Dictionary, iteratee?: string ): T; /** * @see _.maxBy */ maxBy( collection: List|Dictionary, whereValue?: TObject ): T; } interface LoDashImplicitArrayWrapper { /** * @see _.maxBy */ maxBy( iteratee?: ListIterator ): T; /** * @see _.maxBy */ maxBy( iteratee?: string ): T; /** * @see _.maxBy */ maxBy( whereValue?: TObject ): T; } interface LoDashImplicitObjectWrapper { /** * @see _.maxBy */ maxBy( iteratee?: ListIterator|DictionaryIterator, thisArg?: any ): T; /** * @see _.maxBy */ maxBy( iteratee?: string, thisArg?: any ): T; /** * @see _.maxBy */ maxBy( 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( collection: List ): number; } interface LoDashImplicitArrayWrapper { /** * @see _.mean */ mean(): 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( collection: List ): T; } interface LoDashImplicitArrayWrapper { /** * @see _.min */ min(): T; } interface LoDashImplicitObjectWrapper { /** * @see _.min */ min(): 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( collection: List, iteratee?: ListIterator ): T; /** * @see _.minBy */ minBy( collection: Dictionary, iteratee?: DictionaryIterator ): T; /** * @see _.minBy */ minBy( collection: List|Dictionary, iteratee?: string ): T; /** * @see _.minBy */ minBy( collection: List|Dictionary, whereValue?: TObject ): T; } interface LoDashImplicitArrayWrapper { /** * @see _.minBy */ minBy( iteratee?: ListIterator ): T; /** * @see _.minBy */ minBy( iteratee?: string ): T; /** * @see _.minBy */ minBy( whereValue?: TObject ): T; } interface LoDashImplicitObjectWrapper { /** * @see _.minBy */ minBy( iteratee?: ListIterator|DictionaryIterator, thisArg?: any ): T; /** * @see _.minBy */ minBy( iteratee?: string, thisArg?: any ): T; /** * @see _.minBy */ minBy( 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 { /** * @see _.round */ round(precision?: number): number; } interface LoDashExplicitWrapper { /** * @see _.round */ round(precision?: number): LoDashExplicitWrapper; } //_.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(collection: List): number; /** * @see _.sum */ sum(collection: List|Dictionary): number; } interface LoDashImplicitArrayWrapper { /** * @see _.sum */ sum(): number; } interface LoDashImplicitObjectWrapper { /** * @see _.sum **/ sum(): number; /** * @see _.sum */ sum(): number; } interface LoDashExplicitArrayWrapper { /** * @see _.sum */ sum(): LoDashExplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.sum */ sum(): LoDashExplicitWrapper; /** * @see _.sum */ sum(): LoDashExplicitWrapper; } //_.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( collection: List, iteratee: ListIterator ): number; /** * @see _.sumBy **/ sumBy( collection: Dictionary, iteratee: DictionaryIterator ): number; /** * @see _.sumBy */ sumBy( collection: List|Dictionary, iteratee: string ): number; /** * @see _.sumBy */ sumBy(collection: List|Dictionary): number; /** * @see _.sumBy */ sumBy(collection: List|Dictionary): number; } interface LoDashImplicitArrayWrapper { /** * @see _.sumBy */ sumBy( iteratee: ListIterator ): number; /** * @see _.sumBy */ sumBy(iteratee: string): number; /** * @see _.sumBy */ sumBy(): number; } interface LoDashImplicitObjectWrapper { /** * @see _.sumBy **/ sumBy( iteratee: ListIterator|DictionaryIterator ): number; /** * @see _.sumBy */ sumBy(iteratee: string): number; /** * @see _.sumBy */ sumBy(): number; } interface LoDashExplicitArrayWrapper { /** * @see _.sumBy */ sumBy( iteratee: ListIterator ): LoDashExplicitWrapper; /** * @see _.sumBy */ sumBy(iteratee: string): LoDashExplicitWrapper; /** * @see _.sumBy */ sumBy(): LoDashExplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.sumBy */ sumBy( iteratee: ListIterator|DictionaryIterator ): LoDashExplicitWrapper; /** * @see _.sumBy */ sumBy(iteratee: string): LoDashExplicitWrapper; /** * @see _.sumBy */ sumBy(): LoDashExplicitWrapper; } /********** * 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 { /** * @see _.subtract */ subtract( subtrahend: number ): number; } interface LoDashExplicitWrapper { /** * @see _.subtract */ subtract( subtrahend: number ): LoDashExplicitWrapper; } //_.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 { /** * @see _.clamp */ clamp( lower: number, upper: number ): number; } interface LoDashExplicitWrapper { /** * @see _.clamp */ clamp( lower: number, upper: number ): LoDashExplicitWrapper; } //_.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 { /** * @see _.inRange */ inRange( start: number, end: number ): boolean; /** * @see _.inRange */ inRange(end: number): boolean; } interface LoDashExplicitWrapper { /** * @see _.inRange */ inRange( start: number, end: number ): LoDashExplicitWrapper; /** * @see _.inRange */ inRange(end: number): LoDashExplicitWrapper; } //_.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 { /** * @see _.random */ random( max?: number, floating?: boolean ): number; /** * @see _.random */ random(floating?: boolean): number; } interface LoDashExplicitWrapper { /** * @see _.random */ random( max?: number, floating?: boolean ): LoDashExplicitWrapper; /** * @see _.random */ random(floating?: boolean): LoDashExplicitWrapper; } /********** * 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( object: TObject, source: TSource ): TResult; /** * @see assign */ assign( object: TObject, source1: TSource1, source2: TSource2 ): TResult; /** * @see assign */ assign( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3 ): TResult; /** * @see assign */ assign ( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4 ): TResult; /** * @see _.assign */ assign(object: TObject): TObject; /** * @see _.assign */ assign( object: TObject, ...otherArgs: any[] ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.assign */ assign( source: TSource ): LoDashImplicitObjectWrapper; /** * @see assign */ assign( source1: TSource1, source2: TSource2 ): LoDashImplicitObjectWrapper; /** * @see assign */ assign( source1: TSource1, source2: TSource2, source3: TSource3 ): LoDashImplicitObjectWrapper; /** * @see assign */ assign( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4 ): LoDashImplicitObjectWrapper; /** * @see _.assign */ assign(): LoDashImplicitObjectWrapper; /** * @see _.assign */ assign(...otherArgs: any[]): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.assign */ assign( source: TSource ): LoDashExplicitObjectWrapper; /** * @see assign */ assign( source1: TSource1, source2: TSource2 ): LoDashExplicitObjectWrapper; /** * @see assign */ assign( source1: TSource1, source2: TSource2, source3: TSource3 ): LoDashExplicitObjectWrapper; /** * @see assign */ assign( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4 ): LoDashExplicitObjectWrapper; /** * @see _.assign */ assign(): LoDashExplicitObjectWrapper; /** * @see _.assign */ assign(...otherArgs: any[]): LoDashExplicitObjectWrapper; } //_.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( object: TObject, source: TSource, customizer: AssignCustomizer ): TResult; /** * @see assignWith */ assignWith( object: TObject, source1: TSource1, source2: TSource2, customizer: AssignCustomizer ): TResult; /** * @see assignWith */ assignWith( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, customizer: AssignCustomizer ): TResult; /** * @see assignWith */ assignWith ( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: AssignCustomizer ): TResult; /** * @see _.assignWith */ assignWith(object: TObject): TObject; /** * @see _.assignWith */ assignWith( object: TObject, ...otherArgs: any[] ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.assignWith */ assignWith( source: TSource, customizer: AssignCustomizer ): LoDashImplicitObjectWrapper; /** * @see assignWith */ assignWith( source1: TSource1, source2: TSource2, customizer: AssignCustomizer ): LoDashImplicitObjectWrapper; /** * @see assignWith */ assignWith( source1: TSource1, source2: TSource2, source3: TSource3, customizer: AssignCustomizer ): LoDashImplicitObjectWrapper; /** * @see assignWith */ assignWith( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: AssignCustomizer ): LoDashImplicitObjectWrapper; /** * @see _.assignWith */ assignWith(): LoDashImplicitObjectWrapper; /** * @see _.assignWith */ assignWith(...otherArgs: any[]): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.assignWith */ assignWith( source: TSource, customizer: AssignCustomizer ): LoDashExplicitObjectWrapper; /** * @see assignWith */ assignWith( source1: TSource1, source2: TSource2, customizer: AssignCustomizer ): LoDashExplicitObjectWrapper; /** * @see assignWith */ assignWith( source1: TSource1, source2: TSource2, source3: TSource3, customizer: AssignCustomizer ): LoDashExplicitObjectWrapper; /** * @see assignWith */ assignWith( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: AssignCustomizer ): LoDashExplicitObjectWrapper; /** * @see _.assignWith */ assignWith(): LoDashExplicitObjectWrapper; /** * @see _.assignWith */ assignWith(...otherArgs: any[]): LoDashExplicitObjectWrapper; } //_.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( object: TObject, source: TSource ): TResult; /** * @see assignIn */ assignIn( object: TObject, source1: TSource1, source2: TSource2 ): TResult; /** * @see assignIn */ assignIn( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3 ): TResult; /** * @see assignIn */ assignIn ( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4 ): TResult; /** * @see _.assignIn */ assignIn(object: TObject): TObject; /** * @see _.assignIn */ assignIn( object: TObject, ...otherArgs: any[] ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.assignIn */ assignIn( source: TSource ): LoDashImplicitObjectWrapper; /** * @see assignIn */ assignIn( source1: TSource1, source2: TSource2 ): LoDashImplicitObjectWrapper; /** * @see assignIn */ assignIn( source1: TSource1, source2: TSource2, source3: TSource3 ): LoDashImplicitObjectWrapper; /** * @see assignIn */ assignIn( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4 ): LoDashImplicitObjectWrapper; /** * @see _.assignIn */ assignIn(): LoDashImplicitObjectWrapper; /** * @see _.assignIn */ assignIn(...otherArgs: any[]): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.assignIn */ assignIn( source: TSource ): LoDashExplicitObjectWrapper; /** * @see assignIn */ assignIn( source1: TSource1, source2: TSource2 ): LoDashExplicitObjectWrapper; /** * @see assignIn */ assignIn( source1: TSource1, source2: TSource2, source3: TSource3 ): LoDashExplicitObjectWrapper; /** * @see assignIn */ assignIn( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4 ): LoDashExplicitObjectWrapper; /** * @see _.assignIn */ assignIn(): LoDashExplicitObjectWrapper; /** * @see _.assignIn */ assignIn(...otherArgs: any[]): LoDashExplicitObjectWrapper; } //_.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( object: TObject, source: TSource, customizer: AssignCustomizer ): TResult; /** * @see assignInWith */ assignInWith( object: TObject, source1: TSource1, source2: TSource2, customizer: AssignCustomizer ): TResult; /** * @see assignInWith */ assignInWith( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, customizer: AssignCustomizer ): TResult; /** * @see assignInWith */ assignInWith ( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: AssignCustomizer ): TResult; /** * @see _.assignInWith */ assignInWith(object: TObject): TObject; /** * @see _.assignInWith */ assignInWith( object: TObject, ...otherArgs: any[] ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.assignInWith */ assignInWith( source: TSource, customizer: AssignCustomizer ): LoDashImplicitObjectWrapper; /** * @see assignInWith */ assignInWith( source1: TSource1, source2: TSource2, customizer: AssignCustomizer ): LoDashImplicitObjectWrapper; /** * @see assignInWith */ assignInWith( source1: TSource1, source2: TSource2, source3: TSource3, customizer: AssignCustomizer ): LoDashImplicitObjectWrapper; /** * @see assignInWith */ assignInWith( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: AssignCustomizer ): LoDashImplicitObjectWrapper; /** * @see _.assignInWith */ assignInWith(): LoDashImplicitObjectWrapper; /** * @see _.assignInWith */ assignInWith(...otherArgs: any[]): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.assignInWith */ assignInWith( source: TSource, customizer: AssignCustomizer ): LoDashExplicitObjectWrapper; /** * @see assignInWith */ assignInWith( source1: TSource1, source2: TSource2, customizer: AssignCustomizer ): LoDashExplicitObjectWrapper; /** * @see assignInWith */ assignInWith( source1: TSource1, source2: TSource2, source3: TSource3, customizer: AssignCustomizer ): LoDashExplicitObjectWrapper; /** * @see assignInWith */ assignInWith( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: AssignCustomizer ): LoDashExplicitObjectWrapper; /** * @see _.assignInWith */ assignInWith(): LoDashExplicitObjectWrapper; /** * @see _.assignInWith */ assignInWith(...otherArgs: any[]): LoDashExplicitObjectWrapper; } //_.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( prototype: T, properties?: U ): T & U; } interface LoDashImplicitObjectWrapper { /** * @see _.create */ create(properties?: U): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.create */ create(properties?: U): LoDashExplicitObjectWrapper; } //_.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( object: Obj, ...sources: {}[] ): TResult; /** * @see _.defaults */ defaults( object: Obj, source1: S1, ...sources: {}[] ): TResult; /** * @see _.defaults */ defaults( object: Obj, source1: S1, source2: S2, ...sources: {}[] ): TResult; /** * @see _.defaults */ defaults( object: Obj, source1: S1, source2: S2, source3: S3, ...sources: {}[] ): TResult; /** * @see _.defaults */ defaults( object: Obj, source1: S1, source2: S2, source3: S3, source4: S4, ...sources: {}[] ): TResult; /** * @see _.defaults */ defaults( object: {}, ...sources: {}[] ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.defaults */ defaults( source1: S1, ...sources: {}[] ): LoDashImplicitObjectWrapper; /** * @see _.defaults */ defaults( source1: S1, source2: S2, ...sources: {}[] ): LoDashImplicitObjectWrapper; /** * @see _.defaults */ defaults( source1: S1, source2: S2, source3: S3, ...sources: {}[] ): LoDashImplicitObjectWrapper; /** * @see _.defaults */ defaults( source1: S1, source2: S2, source3: S3, source4: S4, ...sources: {}[] ): LoDashImplicitObjectWrapper; /** * @see _.defaults */ defaults(): LoDashImplicitObjectWrapper; /** * @see _.defaults */ defaults(...sources: {}[]): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.defaults */ defaults( source1: S1, ...sources: {}[] ): LoDashExplicitObjectWrapper; /** * @see _.defaults */ defaults( source1: S1, source2: S2, ...sources: {}[] ): LoDashExplicitObjectWrapper; /** * @see _.defaults */ defaults( source1: S1, source2: S2, source3: S3, ...sources: {}[] ): LoDashExplicitObjectWrapper; /** * @see _.defaults */ defaults( source1: S1, source2: S2, source3: S3, source4: S4, ...sources: {}[] ): LoDashExplicitObjectWrapper; /** * @see _.defaults */ defaults(): LoDashExplicitObjectWrapper; /** * @see _.defaults */ defaults(...sources: {}[]): LoDashExplicitObjectWrapper; } //_.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( object: T, ...sources: any[]): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.defaultsDeep **/ defaultsDeep(...sources: any[]): LoDashImplicitObjectWrapper } //_.extend interface LoDashStatic { /** * @see assign */ extend( object: TObject, source: TSource, customizer?: AssignCustomizer, thisArg?: any ): TResult; /** * @see assign */ extend( object: TObject, source1: TSource1, source2: TSource2, customizer?: AssignCustomizer, thisArg?: any ): TResult; /** * @see assign */ extend( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, customizer?: AssignCustomizer, thisArg?: any ): TResult; /** * @see assign */ extend ( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer?: AssignCustomizer, thisArg?: any ): TResult; /** * @see _.assign */ extend(object: TObject): TObject; /** * @see _.assign */ extend( object: TObject, ...otherArgs: any[] ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.assign */ extend( source: TSource, customizer?: AssignCustomizer, thisArg?: any ): LoDashImplicitObjectWrapper; /** * @see assign */ extend( source1: TSource1, source2: TSource2, customizer?: AssignCustomizer, thisArg?: any ): LoDashImplicitObjectWrapper; /** * @see assign */ extend( source1: TSource1, source2: TSource2, source3: TSource3, customizer?: AssignCustomizer, thisArg?: any ): LoDashImplicitObjectWrapper; /** * @see assign */ extend( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer?: AssignCustomizer, thisArg?: any ): LoDashImplicitObjectWrapper; /** * @see _.assign */ extend(): LoDashImplicitObjectWrapper; /** * @see _.assign */ extend(...otherArgs: any[]): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.assign */ extend( source: TSource, customizer?: AssignCustomizer, thisArg?: any ): LoDashExplicitObjectWrapper; /** * @see assign */ extend( source1: TSource1, source2: TSource2, customizer?: AssignCustomizer, thisArg?: any ): LoDashExplicitObjectWrapper; /** * @see assign */ extend( source1: TSource1, source2: TSource2, source3: TSource3, customizer?: AssignCustomizer, thisArg?: any ): LoDashExplicitObjectWrapper; /** * @see assign */ extend( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer?: AssignCustomizer, thisArg?: any ): LoDashExplicitObjectWrapper; /** * @see _.assign */ extend(): LoDashExplicitObjectWrapper; /** * @see _.assign */ extend(...otherArgs: any[]): LoDashExplicitObjectWrapper; } //_.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( object: TObject, predicate?: DictionaryIterator, thisArg?: any ): string; /** * @see _.findKey */ findKey( object: TObject, predicate?: ObjectIterator, thisArg?: any ): string; /** * @see _.findKey */ findKey( object: TObject, predicate?: string, thisArg?: any ): string; /** * @see _.findKey */ findKey, TObject>( object: TObject, predicate?: TWhere ): string; } interface LoDashImplicitObjectWrapper { /** * @see _.findKey */ findKey( predicate?: DictionaryIterator, thisArg?: any ): string; /** * @see _.findKey */ findKey( predicate?: ObjectIterator, thisArg?: any ): string; /** * @see _.findKey */ findKey( predicate?: string, thisArg?: any ): string; /** * @see _.findKey */ findKey>( predicate?: TWhere ): string; } interface LoDashExplicitObjectWrapper { /** * @see _.findKey */ findKey( predicate?: DictionaryIterator, thisArg?: any ): LoDashExplicitWrapper; /** * @see _.findKey */ findKey( predicate?: ObjectIterator, thisArg?: any ): LoDashExplicitWrapper; /** * @see _.findKey */ findKey( predicate?: string, thisArg?: any ): LoDashExplicitWrapper; /** * @see _.findKey */ findKey>( predicate?: TWhere ): LoDashExplicitWrapper; } //_.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( object: TObject, predicate?: DictionaryIterator, thisArg?: any ): string; /** * @see _.findLastKey */ findLastKey( object: TObject, predicate?: ObjectIterator, thisArg?: any ): string; /** * @see _.findLastKey */ findLastKey( object: TObject, predicate?: string, thisArg?: any ): string; /** * @see _.findLastKey */ findLastKey, TObject>( object: TObject, predicate?: TWhere ): string; } interface LoDashImplicitObjectWrapper { /** * @see _.findLastKey */ findLastKey( predicate?: DictionaryIterator, thisArg?: any ): string; /** * @see _.findLastKey */ findLastKey( predicate?: ObjectIterator, thisArg?: any ): string; /** * @see _.findLastKey */ findLastKey( predicate?: string, thisArg?: any ): string; /** * @see _.findLastKey */ findLastKey>( predicate?: TWhere ): string; } interface LoDashExplicitObjectWrapper { /** * @see _.findLastKey */ findLastKey( predicate?: DictionaryIterator, thisArg?: any ): LoDashExplicitWrapper; /** * @see _.findLastKey */ findLastKey( predicate?: ObjectIterator, thisArg?: any ): LoDashExplicitWrapper; /** * @see _.findLastKey */ findLastKey( predicate?: string, thisArg?: any ): LoDashExplicitWrapper; /** * @see _.findLastKey */ findLastKey>( predicate?: TWhere ): LoDashExplicitWrapper; } //_.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( object: Dictionary, iteratee?: DictionaryIterator, thisArg?: any ): Dictionary; /** * @see _.forIn */ forIn( object: T, iteratee?: ObjectIterator, thisArg?: any ): T; } interface LoDashImplicitObjectWrapper { /** * @see _.forIn */ forIn( iteratee?: DictionaryIterator, thisArg?: any ): _.LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.forIn */ forIn( iteratee?: DictionaryIterator, thisArg?: any ): _.LoDashExplicitObjectWrapper; } //_.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( object: Dictionary, iteratee?: DictionaryIterator, thisArg?: any ): Dictionary; /** * @see _.forInRight */ forInRight( object: T, iteratee?: ObjectIterator, thisArg?: any ): T; } interface LoDashImplicitObjectWrapper { /** * @see _.forInRight */ forInRight( iteratee?: DictionaryIterator, thisArg?: any ): _.LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.forInRight */ forInRight( iteratee?: DictionaryIterator, thisArg?: any ): _.LoDashExplicitObjectWrapper; } //_.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( object: Dictionary, iteratee?: DictionaryIterator, thisArg?: any ): Dictionary; /** * @see _.forOwn */ forOwn( object: T, iteratee?: ObjectIterator, thisArg?: any ): T; } interface LoDashImplicitObjectWrapper { /** * @see _.forOwn */ forOwn( iteratee?: DictionaryIterator, thisArg?: any ): _.LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.forOwn */ forOwn( iteratee?: DictionaryIterator, thisArg?: any ): _.LoDashExplicitObjectWrapper; } //_.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( object: Dictionary, iteratee?: DictionaryIterator, thisArg?: any ): Dictionary; /** * @see _.forOwnRight */ forOwnRight( object: T, iteratee?: ObjectIterator, thisArg?: any ): T; } interface LoDashImplicitObjectWrapper { /** * @see _.forOwnRight */ forOwnRight( iteratee?: DictionaryIterator, thisArg?: any ): _.LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.forOwnRight */ forOwnRight( iteratee?: DictionaryIterator, thisArg?: any ): _.LoDashExplicitObjectWrapper; } //_.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(object: any): string[]; } interface LoDashImplicitObjectWrapper { /** * @see _.functions */ functions(): _.LoDashImplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.functions */ functions(): _.LoDashExplicitArrayWrapper; } //_.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(object: any): string[]; } interface LoDashImplicitObjectWrapper { /** * @see _.functionsIn */ functionsIn(): _.LoDashImplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.functionsIn */ functionsIn(): _.LoDashExplicitArrayWrapper; } //_.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(object: Object, path: string|number|boolean|Array, defaultValue?:TResult ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.get **/ get(path: string|number|boolean|Array, defaultValue?: TResult ): TResult; } //_.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( object: T, path: StringRepresentable|StringRepresentable[] ): boolean; } interface LoDashImplicitObjectWrapper { /** * @see _.has */ has(path: StringRepresentable|StringRepresentable[]): boolean; } interface LoDashExplicitObjectWrapper { /** * @see _.has */ has(path: StringRepresentable|StringRepresentable[]): LoDashExplicitWrapper; } //_.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( object: T, path: StringRepresentable|StringRepresentable[] ): boolean; } interface LoDashImplicitObjectWrapper { /** * @see _.hasIn */ hasIn(path: StringRepresentable|StringRepresentable[]): boolean; } interface LoDashExplicitObjectWrapper { /** * @see _.hasIn */ hasIn(path: StringRepresentable|StringRepresentable[]): LoDashExplicitWrapper; } //_.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( object: T, multiValue?: boolean ): TResult; /** * @see _.invert */ invert( object: Object, multiValue?: boolean ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.invert */ invert(multiValue?: boolean): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.invert */ invert(multiValue?: boolean): LoDashExplicitObjectWrapper; } //_.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 { /** * @see _.keys */ keys(): LoDashImplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.keys */ keys(): LoDashExplicitArrayWrapper; } //_.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 { /** * @see _.keysIn */ keysIn(): LoDashImplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.keysIn */ keysIn(): LoDashExplicitArrayWrapper; } //_.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( object: List, iteratee?: ListIterator, thisArg?: any ): Dictionary; /** * @see _.mapKeys */ mapKeys( object: Dictionary, iteratee?: DictionaryIterator, thisArg?: any ): Dictionary; /** * @see _.mapKeys */ mapKeys( object: List|Dictionary, iteratee?: TObject ): Dictionary; /** * @see _.mapKeys */ mapKeys( object: List|Dictionary, iteratee?: string, thisArg?: any ): Dictionary; } interface LoDashImplicitArrayWrapper { /** * @see _.mapKeys */ mapKeys( iteratee?: ListIterator, thisArg?: any ): LoDashImplicitObjectWrapper>; /** * @see _.mapKeys */ mapKeys( iteratee?: TObject ): LoDashImplicitObjectWrapper>; /** * @see _.mapKeys */ mapKeys( iteratee?: string, thisArg?: any ): LoDashImplicitObjectWrapper>; } interface LoDashImplicitObjectWrapper { /** * @see _.mapKeys */ mapKeys( iteratee?: ListIterator|DictionaryIterator, thisArg?: any ): LoDashImplicitObjectWrapper>; /** * @see _.mapKeys */ mapKeys( iteratee?: TObject ): LoDashImplicitObjectWrapper>; /** * @see _.mapKeys */ mapKeys( iteratee?: string, thisArg?: any ): LoDashImplicitObjectWrapper>; } interface LoDashExplicitArrayWrapper { /** * @see _.mapKeys */ mapKeys( iteratee?: ListIterator, thisArg?: any ): LoDashExplicitObjectWrapper>; /** * @see _.mapKeys */ mapKeys( iteratee?: TObject ): LoDashExplicitObjectWrapper>; /** * @see _.mapKeys */ mapKeys( iteratee?: string, thisArg?: any ): LoDashExplicitObjectWrapper>; } interface LoDashExplicitObjectWrapper { /** * @see _.mapKeys */ mapKeys( iteratee?: ListIterator|DictionaryIterator, thisArg?: any ): LoDashExplicitObjectWrapper>; /** * @see _.mapKeys */ mapKeys( iteratee?: TObject ): LoDashExplicitObjectWrapper>; /** * @see _.mapKeys */ mapKeys( iteratee?: string, thisArg?: any ): LoDashExplicitObjectWrapper>; } //_.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(obj: Dictionary, callback: ObjectIterator, thisArg?: any): Dictionary; mapValues(obj: Dictionary, where: Dictionary): Dictionary; mapValues(obj: T, pluck: string): TMapped; mapValues(obj: T, callback: ObjectIterator, thisArg?: any): T; } interface LoDashImplicitObjectWrapper { /** * @see _.mapValues * TValue is the type of the property values of T. * TResult is the type output by the ObjectIterator function */ mapValues(callback: ObjectIterator, thisArg?: any): LoDashImplicitObjectWrapper>; /** * @see _.mapValues * TResult is the type of the property specified by pluck. * T should be a Dictionary> */ mapValues(pluck: string): LoDashImplicitObjectWrapper>; /** * @see _.mapValues * TResult is the type of the properties on the object specified by pluck. * T should be a Dictionary>> */ mapValues(pluck: string, where: Dictionary): LoDashImplicitArrayWrapper>; /** * @see _.mapValues * TResult is the type of the properties of each object in the values of T * T should be a Dictionary> */ mapValues(where: Dictionary): LoDashImplicitArrayWrapper; } //_.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( object: TObject, source: TSource ): TObject & TSource; /** * @see _.merge */ merge( object: TObject, source1: TSource1, source2: TSource2 ): TObject & TSource1 & TSource2; /** * @see _.merge */ merge( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3 ): TObject & TSource1 & TSource2 & TSource3; /** * @see _.merge */ merge( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4 ): TObject & TSource1 & TSource2 & TSource3 & TSource4; /** * @see _.merge */ merge( object: any, ...otherArgs: any[] ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.merge */ merge( source: TSource ): LoDashImplicitObjectWrapper; /** * @see _.merge */ merge( source1: TSource1, source2: TSource2 ): LoDashImplicitObjectWrapper; /** * @see _.merge */ merge( source1: TSource1, source2: TSource2, source3: TSource3 ): LoDashImplicitObjectWrapper; /** * @see _.merge */ merge( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4 ): LoDashImplicitObjectWrapper; /** * @see _.merge */ merge( ...otherArgs: any[] ): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.merge */ merge( source: TSource ): LoDashExplicitObjectWrapper; /** * @see _.merge */ merge( source1: TSource1, source2: TSource2 ): LoDashExplicitObjectWrapper; /** * @see _.merge */ merge( source1: TSource1, source2: TSource2, source3: TSource3 ): LoDashExplicitObjectWrapper; /** * @see _.merge */ merge( ): LoDashExplicitObjectWrapper; /** * @see _.merge */ merge( ...otherArgs: any[] ): LoDashExplicitObjectWrapper; } //_.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( object: TObject, source: TSource, customizer: MergeWithCustomizer ): TObject & TSource; /** * @see _.mergeWith */ mergeWith( object: TObject, source1: TSource1, source2: TSource2, customizer: MergeWithCustomizer ): TObject & TSource1 & TSource2; /** * @see _.mergeWith */ mergeWith( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, customizer: MergeWithCustomizer ): TObject & TSource1 & TSource2 & TSource3; /** * @see _.mergeWith */ mergeWith( object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: MergeWithCustomizer ): TObject & TSource1 & TSource2 & TSource3 & TSource4; /** * @see _.mergeWith */ mergeWith( object: any, ...otherArgs: any[] ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.mergeWith */ mergeWith( source: TSource, customizer: MergeWithCustomizer ): LoDashImplicitObjectWrapper; /** * @see _.mergeWith */ mergeWith( source1: TSource1, source2: TSource2, customizer: MergeWithCustomizer ): LoDashImplicitObjectWrapper; /** * @see _.mergeWith */ mergeWith( source1: TSource1, source2: TSource2, source3: TSource3, customizer: MergeWithCustomizer ): LoDashImplicitObjectWrapper; /** * @see _.mergeWith */ mergeWith( source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: MergeWithCustomizer ): LoDashImplicitObjectWrapper; /** * @see _.mergeWith */ mergeWith( ...otherArgs: any[] ): LoDashImplicitObjectWrapper; } //_.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( object: T, ...predicate: (StringRepresentable|StringRepresentable[])[] ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.omit */ omit( ...predicate: (StringRepresentable|StringRepresentable[])[] ): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.omit */ omit( ...predicate: (StringRepresentable|StringRepresentable[])[] ): LoDashExplicitObjectWrapper; } //_.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( object: T, predicate: ObjectIterator ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.omitBy */ omitBy( predicate: ObjectIterator ): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.omitBy */ omitBy( predicate: ObjectIterator ): LoDashExplicitObjectWrapper; } //_.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( object: T, ...predicate: (StringRepresentable|StringRepresentable[])[] ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.pick */ pick( ...predicate: (StringRepresentable|StringRepresentable[])[] ): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.pick */ pick( ...predicate: (StringRepresentable|StringRepresentable[])[] ): LoDashExplicitObjectWrapper; } //_.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( object: T, predicate: ObjectIterator ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.pickBy */ pickBy( predicate: ObjectIterator ): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.pickBy */ pickBy( predicate: ObjectIterator ): LoDashExplicitObjectWrapper; } //_.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( object: TObject, path: number|string|boolean|Array, defaultValue?: TResult ): TResult; } interface LoDashImplicitWrapperBase { /** * @see _.result */ result( path: number|string|boolean|Array, defaultValue?: TResult ): TResult; } //_.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( object: Object, path: StringRepresentable|StringRepresentable[], value: any ): TResult; /** * @see _.set */ set( object: Object, path: StringRepresentable|StringRepresentable[], value: V ): TResult; /** * @see _.set */ set( object: O, path: StringRepresentable|StringRepresentable[], value: V ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.set */ set( path: StringRepresentable|StringRepresentable[], value: any ): LoDashImplicitObjectWrapper; /** * @see _.set */ set( path: StringRepresentable|StringRepresentable[], value: V ): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.set */ set( path: StringRepresentable|StringRepresentable[], value: any ): LoDashExplicitObjectWrapper; /** * @see _.set */ set( path: StringRepresentable|StringRepresentable[], value: V ): LoDashExplicitObjectWrapper; } //_.setWith interface SetWithCustomizer { (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( object: Object, path: StringRepresentable|StringRepresentable[], value: any, customizer?: SetWithCustomizer ): TResult; /** * @see _.setWith */ setWith( object: Object, path: StringRepresentable|StringRepresentable[], value: V, customizer?: SetWithCustomizer ): TResult; /** * @see _.setWith */ setWith( object: O, path: StringRepresentable|StringRepresentable[], value: V, customizer?: SetWithCustomizer ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.setWith */ setWith( path: StringRepresentable|StringRepresentable[], value: any, customizer?: SetWithCustomizer ): LoDashImplicitObjectWrapper; /** * @see _.setWith */ setWith( path: StringRepresentable|StringRepresentable[], value: V, customizer?: SetWithCustomizer ): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.setWith */ setWith( path: StringRepresentable|StringRepresentable[], value: any, customizer?: SetWithCustomizer ): LoDashExplicitObjectWrapper; /** * @see _.setWith */ setWith( path: StringRepresentable|StringRepresentable[], value: V, customizer?: SetWithCustomizer ): LoDashExplicitObjectWrapper; } //_.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(object?: T): any[][]; toPairs(object?: T): TResult[][]; } interface LoDashImplicitObjectWrapper { /** * @see _.toPairs */ toPairs(): LoDashImplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.toPairs */ toPairs(): LoDashExplicitArrayWrapper; } //_.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(object?: T): any[][]; toPairsIn(object?: T): TResult[][]; } interface LoDashImplicitObjectWrapper { /** * @see _.toPairsIn */ toPairsIn(): LoDashImplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.toPairsIn */ toPairsIn(): LoDashExplicitArrayWrapper; } //_.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( object: T[], iteratee?: MemoVoidArrayIterator, accumulator?: TResult[], thisArg?: any ): TResult[]; /** * @see _.transform */ transform( object: T[], iteratee?: MemoVoidArrayIterator>, accumulator?: Dictionary, thisArg?: any ): Dictionary; /** * @see _.transform */ transform( object: Dictionary, iteratee?: MemoVoidDictionaryIterator>, accumulator?: Dictionary, thisArg?: any ): Dictionary; /** * @see _.transform */ transform( object: Dictionary, iteratee?: MemoVoidDictionaryIterator, accumulator?: TResult[], thisArg?: any ): TResult[]; } interface LoDashImplicitArrayWrapper { /** * @see _.transform */ transform( iteratee?: MemoVoidArrayIterator, accumulator?: TResult[], thisArg?: any ): LoDashImplicitArrayWrapper; /** * @see _.transform */ transform( iteratee?: MemoVoidArrayIterator>, accumulator?: Dictionary, thisArg?: any ): LoDashImplicitObjectWrapper>; } interface LoDashImplicitObjectWrapper { /** * @see _.transform */ transform( iteratee?: MemoVoidDictionaryIterator>, accumulator?: Dictionary, thisArg?: any ): LoDashImplicitObjectWrapper>; /** * @see _.transform */ transform( iteratee?: MemoVoidDictionaryIterator, accumulator?: TResult[], thisArg?: any ): LoDashImplicitArrayWrapper; } //_.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( object: T, path: StringRepresentable|StringRepresentable[] ): boolean; } interface LoDashImplicitObjectWrapper { /** * @see _.unset */ unset(path: StringRepresentable|StringRepresentable[]): LoDashImplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.unset */ unset(path: StringRepresentable|StringRepresentable[]): LoDashExplicitWrapper; } //_.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(object?: any): T[]; } interface LoDashImplicitObjectWrapper { /** * @see _.values */ values(): LoDashImplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.values */ values(): LoDashExplicitArrayWrapper; } //_.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(object?: any): T[]; } interface LoDashImplicitObjectWrapper { /** * @see _.valuesIn */ valuesIn(): LoDashImplicitArrayWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.valuesIn */ valuesIn(): LoDashExplicitArrayWrapper; } /********** * 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 { /** * @see _.camelCase */ camelCase(): string; } interface LoDashExplicitWrapper { /** * @see _.camelCase */ camelCase(): LoDashExplicitWrapper; } //_.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 { /** * @see _.capitalize */ capitalize(): string; } interface LoDashExplicitWrapper { /** * @see _.capitalize */ capitalize(): LoDashExplicitWrapper; } //_.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 { /** * @see _.deburr */ deburr(): string; } interface LoDashExplicitWrapper { /** * @see _.deburr */ deburr(): LoDashExplicitWrapper; } //_.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 { /** * @see _.endsWith */ endsWith( target?: string, position?: number ): boolean; } interface LoDashExplicitWrapper { /** * @see _.endsWith */ endsWith( target?: string, position?: number ): LoDashExplicitWrapper; } // _.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 { /** * @see _.escape */ escape(): string; } interface LoDashExplicitWrapper { /** * @see _.escape */ escape(): LoDashExplicitWrapper; } // _.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 { /** * @see _.escapeRegExp */ escapeRegExp(): string; } interface LoDashExplicitWrapper { /** * @see _.escapeRegExp */ escapeRegExp(): LoDashExplicitWrapper; } //_.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 { /** * @see _.kebabCase */ kebabCase(): string; } interface LoDashExplicitWrapper { /** * @see _.kebabCase */ kebabCase(): LoDashExplicitWrapper; } //_.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 { /** * @see _.lowerCase */ lowerCase(): string; } interface LoDashExplicitWrapper { /** * @see _.lowerCase */ lowerCase(): LoDashExplicitWrapper; } //_.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 { /** * @see _.lowerFirst */ lowerFirst(): string; } interface LoDashExplicitWrapper { /** * @see _.lowerFirst */ lowerFirst(): LoDashExplicitWrapper; } //_.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 { /** * @see _.pad */ pad( length?: number, chars?: string ): string; } interface LoDashExplicitWrapper { /** * @see _.pad */ pad( length?: number, chars?: string ): LoDashExplicitWrapper; } //_.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 { /** * @see _.padEnd */ padEnd( length?: number, chars?: string ): string; } interface LoDashExplicitWrapper { /** * @see _.padEnd */ padEnd( length?: number, chars?: string ): LoDashExplicitWrapper; } //_.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 { /** * @see _.padStart */ padStart( length?: number, chars?: string ): string; } interface LoDashExplicitWrapper { /** * @see _.padStart */ padStart( length?: number, chars?: string ): LoDashExplicitWrapper; } //_.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 { /** * @see _.parseInt */ parseInt(radix?: number): number; } interface LoDashExplicitWrapper { /** * @see _.parseInt */ parseInt(radix?: number): LoDashExplicitWrapper; } //_.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 { /** * @see _.repeat */ repeat(n?: number): string; } interface LoDashExplicitWrapper { /** * @see _.repeat */ repeat(n?: number): LoDashExplicitWrapper; } //_.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 { /** * @see _.replace */ replace( pattern?: RegExp|string, replacement?: Function|string ): string; /** * @see _.replace */ replace( replacement?: Function|string ): string; } interface LoDashImplicitObjectWrapper { /** * @see _.replace */ replace( pattern?: RegExp|string, replacement?: Function|string ): string; /** * @see _.replace */ replace( replacement?: Function|string ): string; } interface LoDashExplicitWrapper { /** * @see _.replace */ replace( pattern?: RegExp|string, replacement?: Function|string ): LoDashExplicitWrapper; /** * @see _.replace */ replace( replacement?: Function|string ): LoDashExplicitWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.replace */ replace( pattern?: RegExp|string, replacement?: Function|string ): LoDashExplicitWrapper; /** * @see _.replace */ replace( replacement?: Function|string ): LoDashExplicitWrapper; } //_.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 { /** * @see _.snakeCase */ snakeCase(): string; } interface LoDashExplicitWrapper { /** * @see _.snakeCase */ snakeCase(): LoDashExplicitWrapper; } //_.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 { /** * @see _.split */ split( separator?: RegExp|string, limit?: number ): LoDashImplicitArrayWrapper; } interface LoDashExplicitWrapper { /** * @see _.split */ split( separator?: RegExp|string, limit?: number ): LoDashExplicitArrayWrapper; } //_.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 { /** * @see _.startCase */ startCase(): string; } interface LoDashExplicitWrapper { /** * @see _.startCase */ startCase(): LoDashExplicitWrapper; } //_.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 { /** * @see _.startsWith */ startsWith( target?: string, position?: number ): boolean; } interface LoDashExplicitWrapper { /** * @see _.startsWith */ startsWith( target?: string, position?: number ): LoDashExplicitWrapper; } //_.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 { /** * @see _.template */ template(options?: TemplateOptions): TemplateExecutor; } interface LoDashExplicitWrapper { /** * @see _.template */ template(options?: TemplateOptions): LoDashExplicitObjectWrapper; } //_.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 { /** * @see _.toLower */ toLower(): string; } interface LoDashExplicitWrapper { /** * @see _.toLower */ toLower(): LoDashExplicitWrapper; } //_.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 { /** * @see _.toUpper */ toUpper(): string; } interface LoDashExplicitWrapper { /** * @see _.toUpper */ toUpper(): LoDashExplicitWrapper; } //_.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 { /** * @see _.trim */ trim(chars?: string): string; } interface LoDashExplicitWrapper { /** * @see _.trim */ trim(chars?: string): LoDashExplicitWrapper; } //_.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 { /** * @see _.trimEnd */ trimEnd(chars?: string): string; } interface LoDashExplicitWrapper { /** * @see _.trimEnd */ trimEnd(chars?: string): LoDashExplicitWrapper; } //_.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 { /** * @see _.trimStart */ trimStart(chars?: string): string; } interface LoDashExplicitWrapper { /** * @see _.trimStart */ trimStart(chars?: string): LoDashExplicitWrapper; } //_.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 { /** * @see _.truncate */ truncate(options?: TruncateOptions): string; } interface LoDashExplicitWrapper { /** * @see _.truncate */ truncate(options?: TruncateOptions): LoDashExplicitWrapper; } //_.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 { /** * @see _.unescape */ unescape(): string; } interface LoDashExplicitWrapper { /** * @see _.unescape */ unescape(): LoDashExplicitWrapper; } //_.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 { /** * @see _.upperCase */ upperCase(): string; } interface LoDashExplicitWrapper { /** * @see _.upperCase */ upperCase(): LoDashExplicitWrapper; } //_.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 { /** * @see _.upperFirst */ upperFirst(): string; } interface LoDashExplicitWrapper { /** * @see _.upperFirst */ upperFirst(): LoDashExplicitWrapper; } //_.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 { /** * @see _.words */ words(pattern?: string|RegExp): string[]; } interface LoDashExplicitWrapper { /** * @see _.words */ words(pattern?: string|RegExp): LoDashExplicitArrayWrapper; } /*********** * 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(func: (...args: any[]) => TResult, ...args: any[]): TResult|Error; } interface LoDashImplicitObjectWrapper { /** * @see _.attempt */ attempt(...args: any[]): TResult|Error; } interface LoDashExplicitObjectWrapper { /** * @see _.attempt */ attempt(...args: any[]): LoDashExplicitObjectWrapper; } //_.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(value: T): () => T; } interface LoDashImplicitWrapperBase { /** * @see _.constant */ constant(): LoDashImplicitObjectWrapper<() => TResult>; } interface LoDashExplicitWrapperBase { /** * @see _.constant */ constant(): LoDashExplicitObjectWrapper<() => TResult>; } //_.identity interface LoDashStatic { /** * This method returns the first argument provided to it. * @param value Any value. * @return Returns value. */ identity(value?: T): T; } interface LoDashImplicitWrapper { /** * @see _.identity */ identity(): T; } interface LoDashImplicitArrayWrapper { /** * @see _.identity */ identity(): T[]; } interface LoDashImplicitObjectWrapper { /** * @see _.identity */ identity(): 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( func: Function, thisArg?: any ): (...args: any[]) => TResult; /** * @see _.iteratee */ iteratee( func: string, thisArg?: any ): (object: any) => TResult; /** * @see _.iteratee */ iteratee( func: Object, thisArg?: any ): (object: any) => boolean; /** * @see _.iteratee */ iteratee(): (value: TResult) => TResult; } interface LoDashImplicitWrapper { /** * @see _.iteratee */ iteratee(thisArg?: any): LoDashImplicitObjectWrapper<(object: any) => TResult>; } interface LoDashImplicitObjectWrapper { /** * @see _.iteratee */ iteratee(thisArg?: any): LoDashImplicitObjectWrapper<(object: any) => boolean>; /** * @see _.iteratee */ iteratee(thisArg?: any): LoDashImplicitObjectWrapper<(...args: any[]) => TResult>; } interface LoDashExplicitWrapper { /** * @see _.iteratee */ iteratee(thisArg?: any): LoDashExplicitObjectWrapper<(object: any) => TResult>; } interface LoDashExplicitObjectWrapper { /** * @see _.iteratee */ iteratee(thisArg?: any): LoDashExplicitObjectWrapper<(object: any) => boolean>; /** * @see _.iteratee */ iteratee(thisArg?: any): 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(source: T): (value: any) => boolean; /** * @see _.matches */ matches(source: T): (value: V) => boolean; } interface LoDashImplicitWrapperBase { /** * @see _.matches */ matches(): LoDashImplicitObjectWrapper<(value: V) => boolean>; } interface LoDashExplicitWrapperBase { /** * @see _.matches */ matches(): 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( path: StringRepresentable|StringRepresentable[], srcValue: T ): (value: any) => boolean; /** * @see _.matchesProperty */ matchesProperty( path: StringRepresentable|StringRepresentable[], srcValue: T ): (value: V) => boolean; } interface LoDashImplicitWrapperBase { /** * @see _.matchesProperty */ matchesProperty( srcValue: SrcValue ): LoDashImplicitObjectWrapper<(value: any) => boolean>; /** * @see _.matchesProperty */ matchesProperty( srcValue: SrcValue ): LoDashImplicitObjectWrapper<(value: Value) => boolean>; } interface LoDashExplicitWrapperBase { /** * @see _.matchesProperty */ matchesProperty( srcValue: SrcValue ): LoDashExplicitObjectWrapper<(value: any) => boolean>; /** * @see _.matchesProperty */ matchesProperty( 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( path: string|StringRepresentable[], ...args: any[] ): (object: TObject) => TResult; /** * @see _.method */ method( path: string|StringRepresentable[], ...args: any[] ): (object: any) => TResult; } interface LoDashImplicitWrapper { /** * @see _.method */ method(...args: any[]): LoDashImplicitObjectWrapper<(object: TObject) => TResult>; /** * @see _.method */ method(...args: any[]): LoDashImplicitObjectWrapper<(object: any) => TResult>; } interface LoDashImplicitArrayWrapper { /** * @see _.method */ method(...args: any[]): LoDashImplicitObjectWrapper<(object: TObject) => TResult>; /** * @see _.method */ method(...args: any[]): LoDashImplicitObjectWrapper<(object: any) => TResult>; } interface LoDashExplicitWrapper { /** * @see _.method */ method(...args: any[]): LoDashExplicitObjectWrapper<(object: TObject) => TResult>; /** * @see _.method */ method(...args: any[]): LoDashExplicitObjectWrapper<(object: any) => TResult>; } interface LoDashExplicitArrayWrapper { /** * @see _.method */ method(...args: any[]): LoDashExplicitObjectWrapper<(object: TObject) => TResult>; /** * @see _.method */ method(...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( object: TObject, ...args: any[] ): (path: StringRepresentable|StringRepresentable[]) => TResult; /** * @see _.methodOf */ methodOf( object: {}, ...args: any[] ): (path: StringRepresentable|StringRepresentable[]) => TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.methodOf */ methodOf( ...args: any[] ): LoDashImplicitObjectWrapper<(path: StringRepresentable|StringRepresentable[]) => TResult>; } interface LoDashExplicitObjectWrapper { /** * @see _.methodOf */ methodOf( ...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( object: TObject, source: Dictionary, options?: MixinOptions ): TResult; /** * @see _.mixin */ mixin( source: Dictionary, options?: MixinOptions ): TResult; } interface LoDashImplicitObjectWrapper { /** * @see _.mixin */ mixin( source: Dictionary, options?: MixinOptions ): LoDashImplicitObjectWrapper; /** * @see _.mixin */ mixin( options?: MixinOptions ): LoDashImplicitObjectWrapper; } interface LoDashExplicitObjectWrapper { /** * @see _.mixin */ mixin( source: Dictionary, options?: MixinOptions ): LoDashExplicitObjectWrapper; /** * @see _.mixin */ mixin( options?: MixinOptions ): LoDashExplicitObjectWrapper; } //_.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 { /** * @see _.noConflict */ noConflict(): 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 { /** * @see _.noop */ noop(...args: any[]): void; } interface LoDashExplicitWrapperBase { /** * @see _.noop */ noop(...args: any[]): _.LoDashExplicitWrapper; } //_.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(n?: number): TResult; } interface LoDashImplicitWrapper { /** * @see _.nthArg */ nthArg(): LoDashImplicitObjectWrapper; } interface LoDashExplicitWrapper { /** * @see _.nthArg */ nthArg(): LoDashExplicitObjectWrapper; } //_.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(...iteratees: (Function|Function[])[]): (...args: any[]) => TResult[]; } interface LoDashImplicitArrayWrapper { /** * @see _.over */ over(...iteratees: (Function|Function[])[]): LoDashImplicitObjectWrapper<(...args: any[]) => TResult[]>; } interface LoDashImplicitObjectWrapper { /** * @see _.over */ over(...iteratees: (Function|Function[])[]): LoDashImplicitObjectWrapper<(...args: any[]) => TResult[]>; } interface LoDashExplicitArrayWrapper { /** * @see _.over */ over(...iteratees: (Function|Function[])[]): LoDashExplicitObjectWrapper<(...args: any[]) => TResult[]>; } interface LoDashExplicitObjectWrapper { /** * @see _.over */ over(...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 { /** * @see _.overEvery */ overEvery(...predicates: (Function|Function[])[]): LoDashImplicitObjectWrapper<(...args: any[]) => boolean>; } interface LoDashImplicitObjectWrapper { /** * @see _.overEvery */ overEvery(...predicates: (Function|Function[])[]): LoDashImplicitObjectWrapper<(...args: any[]) => boolean>; } interface LoDashExplicitArrayWrapper { /** * @see _.overEvery */ overEvery(...predicates: (Function|Function[])[]): LoDashExplicitObjectWrapper<(...args: any[]) => boolean>; } interface LoDashExplicitObjectWrapper { /** * @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 { /** * @see _.overSome */ overSome(...predicates: (Function|Function[])[]): LoDashImplicitObjectWrapper<(...args: any[]) => boolean>; } interface LoDashImplicitObjectWrapper { /** * @see _.overSome */ overSome(...predicates: (Function|Function[])[]): LoDashImplicitObjectWrapper<(...args: any[]) => boolean>; } interface LoDashExplicitArrayWrapper { /** * @see _.overSome */ overSome(...predicates: (Function|Function[])[]): LoDashExplicitObjectWrapper<(...args: any[]) => boolean>; } interface LoDashExplicitObjectWrapper { /** * @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(path: StringRepresentable|StringRepresentable[]): (obj: TObj) => TResult; } interface LoDashImplicitWrapper { /** * @see _.property */ property(): LoDashImplicitObjectWrapper<(obj: TObj) => TResult>; } interface LoDashImplicitArrayWrapper { /** * @see _.property */ property(): LoDashImplicitObjectWrapper<(obj: TObj) => TResult>; } interface LoDashExplicitWrapper { /** * @see _.property */ property(): LoDashExplicitObjectWrapper<(obj: TObj) => TResult>; } interface LoDashExplicitArrayWrapper { /** * @see _.property */ property(): 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(object: T): (path: string|string[]) => any; } interface LoDashImplicitObjectWrapper { /** * @see _.propertyOf */ propertyOf(): LoDashImplicitObjectWrapper<(path: string|string[]) => any>; } interface LoDashExplicitObjectWrapper { /** * @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 { /** * @see _.range */ range( end?: number, step?: number ): LoDashImplicitArrayWrapper; } interface LoDashExplicitWrapper { /** * @see _.range */ range( end?: number, step?: number ): LoDashExplicitArrayWrapper; } //_.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 { /** * @see _.rangeRight */ rangeRight( end?: number, step?: number ): LoDashImplicitArrayWrapper; } interface LoDashExplicitWrapper { /** * @see _.rangeRight */ rangeRight( end?: number, step?: number ): LoDashExplicitArrayWrapper; } //_.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 { /** * @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( n: number, iteratee: (num: number) => TResult ): TResult[]; /** * @see _.times */ times(n: number): number[]; } interface LoDashImplicitWrapper { /** * @see _.times */ times( iteratee: (num: number) => TResult ): TResult[]; /** * @see _.times */ times(): number[]; } interface LoDashExplicitWrapper { /** * @see _.times */ times( iteratee: (num: number) => TResult ): LoDashExplicitArrayWrapper; /** * @see _.times */ times(): LoDashExplicitArrayWrapper; } //_.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 { /** * @see _.toPath */ toPath(): LoDashImplicitWrapper; } interface LoDashExplicitWrapperBase { /** * @see _.toPath */ toPath(): LoDashExplicitWrapper; } //_.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 { /** * @see _.uniqueId */ uniqueId(): string; } interface LoDashExplicitWrapper { /** * @see _.uniqueId */ uniqueId(): LoDashExplicitWrapper; } interface ListIterator { (value: T, index: number, collection: List): TResult; } interface DictionaryIterator { (value: T, key?: string, collection?: Dictionary): TResult; } interface NumericDictionaryIterator { (value: T, key?: number, collection?: Dictionary): TResult; } interface ObjectIterator { (element: T, key?: string, collection?: any): TResult; } interface StringIterator { (char: string, index?: number, string?: string): TResult; } interface MemoVoidIterator { (prev: TResult, curr: T, indexOrKey?: any, list?: T[]): void; } interface MemoIterator { (prev: TResult, curr: T, indexOrKey?: any, list?: T[]): TResult; } interface MemoVoidArrayIterator { (acc: TResult, curr: T, index?: number, arr?: T[]): void; } interface MemoVoidDictionaryIterator { (acc: TResult, curr: T, key?: string, dict?: Dictionary): void; } //interface Collection {} // Common interface between Arrays and jQuery objects interface List { [index: number]: T; length: number; } interface Dictionary { [index: string]: T; } interface NumericDictionary { [index: number]: T; } interface StringRepresentable { toString(): string; } interface Cancelable { cancel(): void; } } declare module "lodash" { export = _; }WebDevelopment-assignment-2/typings/main/ambient/minimatch/000077500000000000000000000000001266350324300243205ustar00rootroot00000000000000WebDevelopment-assignment-2/typings/main/ambient/minimatch/minimatch.d.ts000066400000000000000000000037111266350324300270650ustar00rootroot00000000000000// Compiled using typings@0.6.8 // Source: https://raw.githubusercontent.com/DefinitelyTyped/DefinitelyTyped/a3900b896f7b3361b79f9b503224777619907d53/minimatch/minimatch.d.ts // Type definitions for Minimatch 2.0.8 // Project: https://github.com/isaacs/minimatch // Definitions by: vvakame // Definitions: https://github.com/borisyankov/DefinitelyTyped declare module "minimatch" { function M(target: string, pattern: string, options?: M.IOptions): boolean; module M { function match(list: string[], pattern: string, options?: IOptions): string[]; function filter(pattern: string, options?: IOptions): (element: string, indexed: number, array: string[]) => boolean; function makeRe(pattern: string, options?: IOptions): RegExp; var Minimatch: IMinimatchStatic; interface IOptions { debug?: boolean; nobrace?: boolean; noglobstar?: boolean; dot?: boolean; noext?: boolean; nocase?: boolean; nonull?: boolean; matchBase?: boolean; nocomment?: boolean; nonegate?: boolean; flipNegate?: boolean; } interface IMinimatchStatic { new (pattern: string, options?: IOptions): IMinimatch; prototype: IMinimatch; } interface IMinimatch { pattern: string; options: IOptions; /** 2-dimensional array of regexp or string expressions. */ set: any[][]; // (RegExp | string)[][] regexp: RegExp; negate: boolean; comment: boolean; empty: boolean; makeRe(): RegExp; // regexp or boolean match(fname: string): boolean; matchOne(files: string[], pattern: string[], partial: boolean): boolean; /** Deprecated. For internal use. */ debug(): void; /** Deprecated. For internal use. */ make(): void; /** Deprecated. For internal use. */ parseNegate(): void; /** Deprecated. For internal use. */ braceExpand(pattern: string, options: IOptions): void; /** Deprecated. For internal use. */ parse(pattern: string, isSub?: boolean): void; } } export = M; }WebDevelopment-assignment-2/typings/main/ambient/node/000077500000000000000000000000001266350324300232745ustar00rootroot00000000000000WebDevelopment-assignment-2/typings/main/ambient/node/node.d.ts000066400000000000000000002636661266350324300250360ustar00rootroot00000000000000// Compiled using typings@0.6.8 // Source: https://raw.githubusercontent.com/DefinitelyTyped/DefinitelyTyped/20e1eb9616922d382d918cc5a21870a9dbe255f5/node/node.d.ts // Type definitions for Node.js v4.x // Project: http://nodejs.org/ // Definitions by: Microsoft TypeScript , DefinitelyTyped // Definitions: https://github.com/borisyankov/DefinitelyTyped /************************************************ * * * Node.js v4.x API * * * ************************************************/ interface Error { stack?: string; } // compat for TypeScript 1.5.3 // if you use with --target es3 or --target es5 and use below definitions, // use the lib.es6.d.ts that is bundled with TypeScript 1.5.3. interface MapConstructor {} interface WeakMapConstructor {} interface SetConstructor {} interface WeakSetConstructor {} /************************************************ * * * GLOBAL * * * ************************************************/ declare var process: NodeJS.Process; declare var global: NodeJS.Global; declare var __filename: string; declare var __dirname: string; declare function setTimeout(callback: (...args: any[]) => void, ms: number, ...args: any[]): NodeJS.Timer; declare function clearTimeout(timeoutId: NodeJS.Timer): void; declare function setInterval(callback: (...args: any[]) => void, ms: number, ...args: any[]): NodeJS.Timer; declare function clearInterval(intervalId: NodeJS.Timer): void; declare function setImmediate(callback: (...args: any[]) => void, ...args: any[]): any; declare function clearImmediate(immediateId: any): void; interface NodeRequireFunction { (id: string): any; } interface NodeRequire extends NodeRequireFunction { resolve(id:string): string; cache: any; extensions: any; main: any; } declare var require: NodeRequire; interface NodeModule { exports: any; require: NodeRequireFunction; id: string; filename: string; loaded: boolean; parent: any; children: any[]; } declare var module: NodeModule; // Same as module.exports declare var exports: any; declare var SlowBuffer: { new (str: string, encoding?: string): Buffer; new (size: number): Buffer; new (size: Uint8Array): Buffer; new (array: any[]): Buffer; prototype: Buffer; isBuffer(obj: any): boolean; byteLength(string: string, encoding?: string): number; concat(list: Buffer[], totalLength?: number): Buffer; }; // Buffer class interface Buffer extends NodeBuffer {} /** * Raw data is stored in instances of the Buffer class. * A Buffer is similar to an array of integers but corresponds to a raw memory allocation outside the V8 heap. A Buffer cannot be resized. * Valid string encodings: 'ascii'|'utf8'|'utf16le'|'ucs2'(alias of 'utf16le')|'base64'|'binary'(deprecated)|'hex' */ declare var Buffer: { /** * Allocates a new buffer containing the given {str}. * * @param str String to store in buffer. * @param encoding encoding to use, optional. Default is 'utf8' */ new (str: string, encoding?: string): Buffer; /** * Allocates a new buffer of {size} octets. * * @param size count of octets to allocate. */ new (size: number): Buffer; /** * Allocates a new buffer containing the given {array} of octets. * * @param array The octets to store. */ new (array: Uint8Array): Buffer; /** * Allocates a new buffer containing the given {array} of octets. * * @param array The octets to store. */ new (array: any[]): Buffer; /** * Copies the passed {buffer} data onto a new {Buffer} instance. * * @param buffer The buffer to copy. */ new (buffer: Buffer): Buffer; prototype: Buffer; /** * Returns true if {obj} is a Buffer * * @param obj object to test. */ isBuffer(obj: any): obj is Buffer; /** * Returns true if {encoding} is a valid encoding argument. * Valid string encodings in Node 0.12: 'ascii'|'utf8'|'utf16le'|'ucs2'(alias of 'utf16le')|'base64'|'binary'(deprecated)|'hex' * * @param encoding string to test. */ isEncoding(encoding: string): boolean; /** * Gives the actual byte length of a string. encoding defaults to 'utf8'. * This is not the same as String.prototype.length since that returns the number of characters in a string. * * @param string string to test. * @param encoding encoding used to evaluate (defaults to 'utf8') */ byteLength(string: string, encoding?: string): number; /** * Returns a buffer which is the result of concatenating all the buffers in the list together. * * If the list has no items, or if the totalLength is 0, then it returns a zero-length buffer. * If the list has exactly one item, then the first item of the list is returned. * If the list has more than one item, then a new Buffer is created. * * @param list An array of Buffer objects to concatenate * @param totalLength Total length of the buffers when concatenated. * If totalLength is not provided, it is read from the buffers in the list. However, this adds an additional loop to the function, so it is faster to provide the length explicitly. */ concat(list: Buffer[], totalLength?: number): Buffer; /** * The same as buf1.compare(buf2). */ compare(buf1: Buffer, buf2: Buffer): number; }; /************************************************ * * * GLOBAL INTERFACES * * * ************************************************/ declare module NodeJS { export interface ErrnoException extends Error { errno?: number; code?: string; path?: string; syscall?: string; stack?: string; } export interface EventEmitter { addListener(event: string, listener: Function): EventEmitter; on(event: string, listener: Function): EventEmitter; once(event: string, listener: Function): EventEmitter; removeListener(event: string, listener: Function): EventEmitter; removeAllListeners(event?: string): EventEmitter; setMaxListeners(n: number): EventEmitter; getMaxListeners(): number; listeners(event: string): Function[]; emit(event: string, ...args: any[]): boolean; listenerCount(type: string): number; } export interface ReadableStream extends EventEmitter { readable: boolean; read(size?: number): string|Buffer; setEncoding(encoding: string): void; pause(): void; resume(): void; pipe(destination: T, options?: { end?: boolean; }): T; unpipe(destination?: T): void; unshift(chunk: string): void; unshift(chunk: Buffer): void; wrap(oldStream: ReadableStream): ReadableStream; } export interface WritableStream extends EventEmitter { writable: boolean; write(buffer: Buffer|string, cb?: Function): boolean; write(str: string, encoding?: string, cb?: Function): boolean; end(): void; end(buffer: Buffer, cb?: Function): void; end(str: string, cb?: Function): void; end(str: string, encoding?: string, cb?: Function): void; } export interface ReadWriteStream extends ReadableStream, WritableStream {} export interface Process extends EventEmitter { stdout: WritableStream; stderr: WritableStream; stdin: ReadableStream; argv: string[]; execArgv: string[]; execPath: string; abort(): void; chdir(directory: string): void; cwd(): string; env: any; exit(code?: number): void; getgid(): number; setgid(id: number): void; setgid(id: string): void; getuid(): number; setuid(id: number): void; setuid(id: string): void; version: string; versions: { http_parser: string; node: string; v8: string; ares: string; uv: string; zlib: string; openssl: string; }; config: { target_defaults: { cflags: any[]; default_configuration: string; defines: string[]; include_dirs: string[]; libraries: string[]; }; variables: { clang: number; host_arch: string; node_install_npm: boolean; node_install_waf: boolean; node_prefix: string; node_shared_openssl: boolean; node_shared_v8: boolean; node_shared_zlib: boolean; node_use_dtrace: boolean; node_use_etw: boolean; node_use_openssl: boolean; target_arch: string; v8_no_strict_aliasing: number; v8_use_snapshot: boolean; visibility: string; }; }; kill(pid:number, signal?: string|number): void; pid: number; title: string; arch: string; platform: string; memoryUsage(): { rss: number; heapTotal: number; heapUsed: number; }; nextTick(callback: Function): void; umask(mask?: number): number; uptime(): number; hrtime(time?:number[]): number[]; // Worker send?(message: any, sendHandle?: any): void; } export interface Global { Array: typeof Array; ArrayBuffer: typeof ArrayBuffer; Boolean: typeof Boolean; Buffer: typeof Buffer; DataView: typeof DataView; Date: typeof Date; Error: typeof Error; EvalError: typeof EvalError; Float32Array: typeof Float32Array; Float64Array: typeof Float64Array; Function: typeof Function; GLOBAL: Global; Infinity: typeof Infinity; Int16Array: typeof Int16Array; Int32Array: typeof Int32Array; Int8Array: typeof Int8Array; Intl: typeof Intl; JSON: typeof JSON; Map: MapConstructor; Math: typeof Math; NaN: typeof NaN; Number: typeof Number; Object: typeof Object; Promise: Function; RangeError: typeof RangeError; ReferenceError: typeof ReferenceError; RegExp: typeof RegExp; Set: SetConstructor; String: typeof String; Symbol: Function; SyntaxError: typeof SyntaxError; TypeError: typeof TypeError; URIError: typeof URIError; Uint16Array: typeof Uint16Array; Uint32Array: typeof Uint32Array; Uint8Array: typeof Uint8Array; Uint8ClampedArray: Function; WeakMap: WeakMapConstructor; WeakSet: WeakSetConstructor; clearImmediate: (immediateId: any) => void; clearInterval: (intervalId: NodeJS.Timer) => void; clearTimeout: (timeoutId: NodeJS.Timer) => void; console: typeof console; decodeURI: typeof decodeURI; decodeURIComponent: typeof decodeURIComponent; encodeURI: typeof encodeURI; encodeURIComponent: typeof encodeURIComponent; escape: (str: string) => string; eval: typeof eval; global: Global; isFinite: typeof isFinite; isNaN: typeof isNaN; parseFloat: typeof parseFloat; parseInt: typeof parseInt; process: Process; root: Global; setImmediate: (callback: (...args: any[]) => void, ...args: any[]) => any; setInterval: (callback: (...args: any[]) => void, ms: number, ...args: any[]) => NodeJS.Timer; setTimeout: (callback: (...args: any[]) => void, ms: number, ...args: any[]) => NodeJS.Timer; undefined: typeof undefined; unescape: (str: string) => string; gc: () => void; v8debug?: any; } export interface Timer { ref() : void; unref() : void; } } /** * @deprecated */ interface NodeBuffer { [index: number]: number; write(string: string, offset?: number, length?: number, encoding?: string): number; toString(encoding?: string, start?: number, end?: number): string; toJSON(): any; length: number; equals(otherBuffer: Buffer): boolean; compare(otherBuffer: Buffer): number; copy(targetBuffer: Buffer, targetStart?: number, sourceStart?: number, sourceEnd?: number): number; slice(start?: number, end?: number): Buffer; writeUIntLE(value: number, offset: number, byteLength: number, noAssert?: boolean): number; writeUIntBE(value: number, offset: number, byteLength: number, noAssert?: boolean): number; writeIntLE(value: number, offset: number, byteLength: number, noAssert?: boolean): number; writeIntBE(value: number, offset: number, byteLength: number, noAssert?: boolean): number; readUIntLE(offset: number, byteLength: number, noAssert?: boolean): number; readUIntBE(offset: number, byteLength: number, noAssert?: boolean): number; readIntLE(offset: number, byteLength: number, noAssert?: boolean): number; readIntBE(offset: number, byteLength: number, noAssert?: boolean): number; readUInt8(offset: number, noAsset?: boolean): number; readUInt16LE(offset: number, noAssert?: boolean): number; readUInt16BE(offset: number, noAssert?: boolean): number; readUInt32LE(offset: number, noAssert?: boolean): number; readUInt32BE(offset: number, noAssert?: boolean): number; readInt8(offset: number, noAssert?: boolean): number; readInt16LE(offset: number, noAssert?: boolean): number; readInt16BE(offset: number, noAssert?: boolean): number; readInt32LE(offset: number, noAssert?: boolean): number; readInt32BE(offset: number, noAssert?: boolean): number; readFloatLE(offset: number, noAssert?: boolean): number; readFloatBE(offset: number, noAssert?: boolean): number; readDoubleLE(offset: number, noAssert?: boolean): number; readDoubleBE(offset: number, noAssert?: boolean): number; writeUInt8(value: number, offset: number, noAssert?: boolean): number; writeUInt16LE(value: number, offset: number, noAssert?: boolean): number; writeUInt16BE(value: number, offset: number, noAssert?: boolean): number; writeUInt32LE(value: number, offset: number, noAssert?: boolean): number; writeUInt32BE(value: number, offset: number, noAssert?: boolean): number; writeInt8(value: number, offset: number, noAssert?: boolean): number; writeInt16LE(value: number, offset: number, noAssert?: boolean): number; writeInt16BE(value: number, offset: number, noAssert?: boolean): number; writeInt32LE(value: number, offset: number, noAssert?: boolean): number; writeInt32BE(value: number, offset: number, noAssert?: boolean): number; writeFloatLE(value: number, offset: number, noAssert?: boolean): number; writeFloatBE(value: number, offset: number, noAssert?: boolean): number; writeDoubleLE(value: number, offset: number, noAssert?: boolean): number; writeDoubleBE(value: number, offset: number, noAssert?: boolean): number; fill(value: any, offset?: number, end?: number): Buffer; indexOf(value: string | number | Buffer, byteOffset?: number): number; } /************************************************ * * * MODULES * * * ************************************************/ declare module "buffer" { export var INSPECT_MAX_BYTES: number; var BuffType: typeof Buffer; var SlowBuffType: typeof SlowBuffer; export { BuffType as Buffer, SlowBuffType as SlowBuffer }; } declare module "querystring" { export interface StringifyOptions { encodeURIComponent?: Function; } export interface ParseOptions { maxKeys?: number; decodeURIComponent?: Function; } export function stringify(obj: T, sep?: string, eq?: string, options?: StringifyOptions): string; export function parse(str: string, sep?: string, eq?: string, options?: ParseOptions): any; export function parse(str: string, sep?: string, eq?: string, options?: ParseOptions): T; export function escape(str: string): string; export function unescape(str: string): string; } declare module "events" { export class EventEmitter implements NodeJS.EventEmitter { static EventEmitter: EventEmitter; static listenerCount(emitter: EventEmitter, event: string): number; // deprecated static defaultMaxListeners: number; addListener(event: string, listener: Function): EventEmitter; on(event: string, listener: Function): EventEmitter; once(event: string, listener: Function): EventEmitter; removeListener(event: string, listener: Function): EventEmitter; removeAllListeners(event?: string): EventEmitter; setMaxListeners(n: number): EventEmitter; getMaxListeners(): number; listeners(event: string): Function[]; emit(event: string, ...args: any[]): boolean; listenerCount(type: string): number; } } declare module "http" { import * as events from "events"; import * as net from "net"; import * as stream from "stream"; export interface RequestOptions { protocol?: string; host?: string; hostname?: string; family?: number; port?: number; localAddress?: string; socketPath?: string; method?: string; path?: string; headers?: { [key: string]: any }; auth?: string; agent?: Agent|boolean; } export interface Server extends events.EventEmitter { listen(port: number, hostname?: string, backlog?: number, callback?: Function): Server; listen(port: number, hostname?: string, callback?: Function): Server; listen(path: string, callback?: Function): Server; listen(handle: any, listeningListener?: Function): Server; close(cb?: any): Server; address(): { port: number; family: string; address: string; }; maxHeadersCount: number; } /** * @deprecated Use IncomingMessage */ export interface ServerRequest extends IncomingMessage { connection: net.Socket; } export interface ServerResponse extends events.EventEmitter, stream.Writable { // Extended base methods write(buffer: Buffer): boolean; write(buffer: Buffer, cb?: Function): boolean; write(str: string, cb?: Function): boolean; write(str: string, encoding?: string, cb?: Function): boolean; write(str: string, encoding?: string, fd?: string): boolean; writeContinue(): void; writeHead(statusCode: number, reasonPhrase?: string, headers?: any): void; writeHead(statusCode: number, headers?: any): void; statusCode: number; statusMessage: string; headersSent: boolean; setHeader(name: string, value: string | string[]): void; sendDate: boolean; getHeader(name: string): string; removeHeader(name: string): void; write(chunk: any, encoding?: string): any; addTrailers(headers: any): void; // Extended base methods end(): void; end(buffer: Buffer, cb?: Function): void; end(str: string, cb?: Function): void; end(str: string, encoding?: string, cb?: Function): void; end(data?: any, encoding?: string): void; } export interface ClientRequest extends events.EventEmitter, stream.Writable { // Extended base methods write(buffer: Buffer): boolean; write(buffer: Buffer, cb?: Function): boolean; write(str: string, cb?: Function): boolean; write(str: string, encoding?: string, cb?: Function): boolean; write(str: string, encoding?: string, fd?: string): boolean; write(chunk: any, encoding?: string): void; abort(): void; setTimeout(timeout: number, callback?: Function): void; setNoDelay(noDelay?: boolean): void; setSocketKeepAlive(enable?: boolean, initialDelay?: number): void; // Extended base methods end(): void; end(buffer: Buffer, cb?: Function): void; end(str: string, cb?: Function): void; end(str: string, encoding?: string, cb?: Function): void; end(data?: any, encoding?: string): void; } export interface IncomingMessage extends events.EventEmitter, stream.Readable { httpVersion: string; headers: any; rawHeaders: string[]; trailers: any; rawTrailers: any; setTimeout(msecs: number, callback: Function): NodeJS.Timer; /** * Only valid for request obtained from http.Server. */ method?: string; /** * Only valid for request obtained from http.Server. */ url?: string; /** * Only valid for response obtained from http.ClientRequest. */ statusCode?: number; /** * Only valid for response obtained from http.ClientRequest. */ statusMessage?: string; socket: net.Socket; } /** * @deprecated Use IncomingMessage */ export interface ClientResponse extends IncomingMessage { } export interface AgentOptions { /** * Keep sockets around in a pool to be used by other requests in the future. Default = false */ keepAlive?: boolean; /** * When using HTTP KeepAlive, how often to send TCP KeepAlive packets over sockets being kept alive. Default = 1000. * Only relevant if keepAlive is set to true. */ keepAliveMsecs?: number; /** * Maximum number of sockets to allow per host. Default for Node 0.10 is 5, default for Node 0.12 is Infinity */ maxSockets?: number; /** * Maximum number of sockets to leave open in a free state. Only relevant if keepAlive is set to true. Default = 256. */ maxFreeSockets?: number; } export class Agent { maxSockets: number; sockets: any; requests: any; constructor(opts?: AgentOptions); /** * Destroy any sockets that are currently in use by the agent. * It is usually not necessary to do this. However, if you are using an agent with KeepAlive enabled, * then it is best to explicitly shut down the agent when you know that it will no longer be used. Otherwise, * sockets may hang open for quite a long time before the server terminates them. */ destroy(): void; } export var METHODS: string[]; export var STATUS_CODES: { [errorCode: number]: string; [errorCode: string]: string; }; export function createServer(requestListener?: (request: IncomingMessage, response: ServerResponse) =>void ): Server; export function createClient(port?: number, host?: string): any; export function request(options: RequestOptions, callback?: (res: IncomingMessage) => void): ClientRequest; export function get(options: any, callback?: (res: IncomingMessage) => void): ClientRequest; export var globalAgent: Agent; } declare module "cluster" { import * as child from "child_process"; import * as events from "events"; export interface ClusterSettings { exec?: string; args?: string[]; silent?: boolean; } export class Worker extends events.EventEmitter { id: string; process: child.ChildProcess; suicide: boolean; send(message: any, sendHandle?: any): void; kill(signal?: string): void; destroy(signal?: string): void; disconnect(): void; } export var settings: ClusterSettings; export var isMaster: boolean; export var isWorker: boolean; export function setupMaster(settings?: ClusterSettings): void; export function fork(env?: any): Worker; export function disconnect(callback?: Function): void; export var worker: Worker; export var workers: Worker[]; // Event emitter export function addListener(event: string, listener: Function): void; export function on(event: "disconnect", listener: (worker: Worker) => void): void; export function on(event: "exit", listener: (worker: Worker, code: number, signal: string) => void): void; export function on(event: "fork", listener: (worker: Worker) => void): void; export function on(event: "listening", listener: (worker: Worker, address: any) => void): void; export function on(event: "message", listener: (worker: Worker, message: any) => void): void; export function on(event: "online", listener: (worker: Worker) => void): void; export function on(event: "setup", listener: (settings: any) => void): void; export function on(event: string, listener: Function): any; export function once(event: string, listener: Function): void; export function removeListener(event: string, listener: Function): void; export function removeAllListeners(event?: string): void; export function setMaxListeners(n: number): void; export function listeners(event: string): Function[]; export function emit(event: string, ...args: any[]): boolean; } declare module "zlib" { import * as stream from "stream"; export interface ZlibOptions { chunkSize?: number; windowBits?: number; level?: number; memLevel?: number; strategy?: number; dictionary?: any; } export interface Gzip extends stream.Transform { } export interface Gunzip extends stream.Transform { } export interface Deflate extends stream.Transform { } export interface Inflate extends stream.Transform { } export interface DeflateRaw extends stream.Transform { } export interface InflateRaw extends stream.Transform { } export interface Unzip extends stream.Transform { } export function createGzip(options?: ZlibOptions): Gzip; export function createGunzip(options?: ZlibOptions): Gunzip; export function createDeflate(options?: ZlibOptions): Deflate; export function createInflate(options?: ZlibOptions): Inflate; export function createDeflateRaw(options?: ZlibOptions): DeflateRaw; export function createInflateRaw(options?: ZlibOptions): InflateRaw; export function createUnzip(options?: ZlibOptions): Unzip; export function deflate(buf: Buffer, callback: (error: Error, result: any) =>void ): void; export function deflateSync(buf: Buffer, options?: ZlibOptions): any; export function deflateRaw(buf: Buffer, callback: (error: Error, result: any) =>void ): void; export function deflateRawSync(buf: Buffer, options?: ZlibOptions): any; export function gzip(buf: Buffer, callback: (error: Error, result: any) =>void ): void; export function gzipSync(buf: Buffer, options?: ZlibOptions): any; export function gunzip(buf: Buffer, callback: (error: Error, result: any) =>void ): void; export function gunzipSync(buf: Buffer, options?: ZlibOptions): any; export function inflate(buf: Buffer, callback: (error: Error, result: any) =>void ): void; export function inflateSync(buf: Buffer, options?: ZlibOptions): any; export function inflateRaw(buf: Buffer, callback: (error: Error, result: any) =>void ): void; export function inflateRawSync(buf: Buffer, options?: ZlibOptions): any; export function unzip(buf: Buffer, callback: (error: Error, result: any) =>void ): void; export function unzipSync(buf: Buffer, options?: ZlibOptions): any; // Constants export var Z_NO_FLUSH: number; export var Z_PARTIAL_FLUSH: number; export var Z_SYNC_FLUSH: number; export var Z_FULL_FLUSH: number; export var Z_FINISH: number; export var Z_BLOCK: number; export var Z_TREES: number; export var Z_OK: number; export var Z_STREAM_END: number; export var Z_NEED_DICT: number; export var Z_ERRNO: number; export var Z_STREAM_ERROR: number; export var Z_DATA_ERROR: number; export var Z_MEM_ERROR: number; export var Z_BUF_ERROR: number; export var Z_VERSION_ERROR: number; export var Z_NO_COMPRESSION: number; export var Z_BEST_SPEED: number; export var Z_BEST_COMPRESSION: number; export var Z_DEFAULT_COMPRESSION: number; export var Z_FILTERED: number; export var Z_HUFFMAN_ONLY: number; export var Z_RLE: number; export var Z_FIXED: number; export var Z_DEFAULT_STRATEGY: number; export var Z_BINARY: number; export var Z_TEXT: number; export var Z_ASCII: number; export var Z_UNKNOWN: number; export var Z_DEFLATED: number; export var Z_NULL: number; } declare module "os" { export interface CpuInfo { model: string; speed: number; times: { user: number; nice: number; sys: number; idle: number; irq: number; }; } export interface NetworkInterfaceInfo { address: string; netmask: string; family: string; mac: string; internal: boolean; } export function tmpdir(): string; export function homedir(): string; export function endianness(): string; export function hostname(): string; export function type(): string; export function platform(): string; export function arch(): string; export function release(): string; export function uptime(): number; export function loadavg(): number[]; export function totalmem(): number; export function freemem(): number; export function cpus(): CpuInfo[]; export function networkInterfaces(): {[index: string]: NetworkInterfaceInfo[]}; export var EOL: string; } declare module "https" { import * as tls from "tls"; import * as events from "events"; import * as http from "http"; export interface ServerOptions { pfx?: any; key?: any; passphrase?: string; cert?: any; ca?: any; crl?: any; ciphers?: string; honorCipherOrder?: boolean; requestCert?: boolean; rejectUnauthorized?: boolean; NPNProtocols?: any; SNICallback?: (servername: string) => any; } export interface RequestOptions extends http.RequestOptions{ pfx?: any; key?: any; passphrase?: string; cert?: any; ca?: any; ciphers?: string; rejectUnauthorized?: boolean; secureProtocol?: string; } export interface Agent { maxSockets: number; sockets: any; requests: any; } export var Agent: { new (options?: RequestOptions): Agent; }; export interface Server extends tls.Server { } export function createServer(options: ServerOptions, requestListener?: Function): Server; export function request(options: RequestOptions, callback?: (res: http.IncomingMessage) =>void ): http.ClientRequest; export function get(options: RequestOptions, callback?: (res: http.IncomingMessage) =>void ): http.ClientRequest; export var globalAgent: Agent; } declare module "punycode" { export function decode(string: string): string; export function encode(string: string): string; export function toUnicode(domain: string): string; export function toASCII(domain: string): string; export var ucs2: ucs2; interface ucs2 { decode(string: string): number[]; encode(codePoints: number[]): string; } export var version: any; } declare module "repl" { import * as stream from "stream"; import * as events from "events"; export interface ReplOptions { prompt?: string; input?: NodeJS.ReadableStream; output?: NodeJS.WritableStream; terminal?: boolean; eval?: Function; useColors?: boolean; useGlobal?: boolean; ignoreUndefined?: boolean; writer?: Function; } export function start(options: ReplOptions): events.EventEmitter; } declare module "readline" { import * as events from "events"; import * as stream from "stream"; export interface Key { sequence?: string; name?: string; ctrl?: boolean; meta?: boolean; shift?: boolean; } export interface ReadLine extends events.EventEmitter { setPrompt(prompt: string): void; prompt(preserveCursor?: boolean): void; question(query: string, callback: (answer: string) => void): void; pause(): ReadLine; resume(): ReadLine; close(): void; write(data: string|Buffer, key?: Key): void; } export interface Completer { (line: string): CompleterResult; (line: string, callback: (err: any, result: CompleterResult) => void): any; } export interface CompleterResult { completions: string[]; line: string; } export interface ReadLineOptions { input: NodeJS.ReadableStream; output?: NodeJS.WritableStream; completer?: Completer; terminal?: boolean; historySize?: number; } export function createInterface(input: NodeJS.ReadableStream, output?: NodeJS.WritableStream, completer?: Completer, terminal?: boolean): ReadLine; export function createInterface(options: ReadLineOptions): ReadLine; export function cursorTo(stream: NodeJS.WritableStream, x: number, y: number): void; export function moveCursor(stream: NodeJS.WritableStream, dx: number|string, dy: number|string): void; export function clearLine(stream: NodeJS.WritableStream, dir: number): void; export function clearScreenDown(stream: NodeJS.WritableStream): void; } declare module "vm" { export interface Context { } export interface Script { runInThisContext(): void; runInNewContext(sandbox?: Context): void; } export function runInThisContext(code: string, filename?: string): void; export function runInNewContext(code: string, sandbox?: Context, filename?: string): void; export function runInContext(code: string, context: Context, filename?: string): void; export function createContext(initSandbox?: Context): Context; export function createScript(code: string, filename?: string): Script; } declare module "child_process" { import * as events from "events"; import * as stream from "stream"; export interface ChildProcess extends events.EventEmitter { stdin: stream.Writable; stdout: stream.Readable; stderr: stream.Readable; stdio: (stream.Readable|stream.Writable)[]; pid: number; kill(signal?: string): void; send(message: any, sendHandle?: any): void; disconnect(): void; unref(): void; } export function spawn(command: string, args?: string[], options?: { cwd?: string; stdio?: any; custom?: any; env?: any; detached?: boolean; }): ChildProcess; export function exec(command: string, options: { cwd?: string; stdio?: any; customFds?: any; env?: any; encoding?: string; timeout?: number; maxBuffer?: number; killSignal?: string; }, callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess; export function exec(command: string, callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess; export function execFile(file: string, callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess; export function execFile(file: string, args?: string[], callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess; export function execFile(file: string, args?: string[], options?: { cwd?: string; stdio?: any; customFds?: any; env?: any; encoding?: string; timeout?: number; maxBuffer?: number; killSignal?: string; }, callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess; export function fork(modulePath: string, args?: string[], options?: { cwd?: string; env?: any; execPath?: string; execArgv?: string[]; silent?: boolean; uid?: number; gid?: number; }): ChildProcess; export function spawnSync(command: string, args?: string[], options?: { cwd?: string; input?: string | Buffer; stdio?: any; env?: any; uid?: number; gid?: number; timeout?: number; maxBuffer?: number; killSignal?: string; encoding?: string; }): { pid: number; output: string[]; stdout: string | Buffer; stderr: string | Buffer; status: number; signal: string; error: Error; }; export function execSync(command: string, options?: { cwd?: string; input?: string|Buffer; stdio?: any; env?: any; uid?: number; gid?: number; timeout?: number; maxBuffer?: number; killSignal?: string; encoding?: string; }): string | Buffer; export function execFileSync(command: string, args?: string[], options?: { cwd?: string; input?: string|Buffer; stdio?: any; env?: any; uid?: number; gid?: number; timeout?: number; maxBuffer?: number; killSignal?: string; encoding?: string; }): string | Buffer; } declare module "url" { export interface Url { href?: string; protocol?: string; auth?: string; hostname?: string; port?: string; host?: string; pathname?: string; search?: string; query?: any; // string | Object slashes?: boolean; hash?: string; path?: string; } export function parse(urlStr: string, parseQueryString?: boolean , slashesDenoteHost?: boolean ): Url; export function format(url: Url): string; export function resolve(from: string, to: string): string; } declare module "dns" { export function lookup(domain: string, family: number, callback: (err: Error, address: string, family: number) =>void ): string; export function lookup(domain: string, callback: (err: Error, address: string, family: number) =>void ): string; export function resolve(domain: string, rrtype: string, callback: (err: Error, addresses: string[]) =>void ): string[]; export function resolve(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[]; export function resolve4(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[]; export function resolve6(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[]; export function resolveMx(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[]; export function resolveTxt(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[]; export function resolveSrv(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[]; export function resolveNs(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[]; export function resolveCname(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[]; export function reverse(ip: string, callback: (err: Error, domains: string[]) =>void ): string[]; } declare module "net" { import * as stream from "stream"; export interface Socket extends stream.Duplex { // Extended base methods write(buffer: Buffer): boolean; write(buffer: Buffer, cb?: Function): boolean; write(str: string, cb?: Function): boolean; write(str: string, encoding?: string, cb?: Function): boolean; write(str: string, encoding?: string, fd?: string): boolean; connect(port: number, host?: string, connectionListener?: Function): void; connect(path: string, connectionListener?: Function): void; bufferSize: number; setEncoding(encoding?: string): void; write(data: any, encoding?: string, callback?: Function): void; destroy(): void; pause(): void; resume(): void; setTimeout(timeout: number, callback?: Function): void; setNoDelay(noDelay?: boolean): void; setKeepAlive(enable?: boolean, initialDelay?: number): void; address(): { port: number; family: string; address: string; }; unref(): void; ref(): void; remoteAddress: string; remoteFamily: string; remotePort: number; localAddress: string; localPort: number; bytesRead: number; bytesWritten: number; // Extended base methods end(): void; end(buffer: Buffer, cb?: Function): void; end(str: string, cb?: Function): void; end(str: string, encoding?: string, cb?: Function): void; end(data?: any, encoding?: string): void; } export var Socket: { new (options?: { fd?: string; type?: string; allowHalfOpen?: boolean; }): Socket; }; export interface Server extends Socket { listen(port: number, host?: string, backlog?: number, listeningListener?: Function): Server; listen(path: string, listeningListener?: Function): Server; listen(handle: any, listeningListener?: Function): Server; close(callback?: Function): Server; address(): { port: number; family: string; address: string; }; maxConnections: number; connections: number; } export function createServer(connectionListener?: (socket: Socket) =>void ): Server; export function createServer(options?: { allowHalfOpen?: boolean; }, connectionListener?: (socket: Socket) =>void ): Server; export function connect(options: { port: number, host?: string, localAddress? : string, localPort? : string, family? : number, allowHalfOpen?: boolean; }, connectionListener?: Function): Socket; export function connect(port: number, host?: string, connectionListener?: Function): Socket; export function connect(path: string, connectionListener?: Function): Socket; export function createConnection(options: { port: number, host?: string, localAddress? : string, localPort? : string, family? : number, allowHalfOpen?: boolean; }, connectionListener?: Function): Socket; export function createConnection(port: number, host?: string, connectionListener?: Function): Socket; export function createConnection(path: string, connectionListener?: Function): Socket; export function isIP(input: string): number; export function isIPv4(input: string): boolean; export function isIPv6(input: string): boolean; } declare module "dgram" { import * as events from "events"; interface RemoteInfo { address: string; port: number; size: number; } interface AddressInfo { address: string; family: string; port: number; } export function createSocket(type: string, callback?: (msg: Buffer, rinfo: RemoteInfo) => void): Socket; interface Socket extends events.EventEmitter { send(buf: Buffer, offset: number, length: number, port: number, address: string, callback?: (error: Error, bytes: number) => void): void; bind(port: number, address?: string, callback?: () => void): void; close(): void; address(): AddressInfo; setBroadcast(flag: boolean): void; setMulticastTTL(ttl: number): void; setMulticastLoopback(flag: boolean): void; addMembership(multicastAddress: string, multicastInterface?: string): void; dropMembership(multicastAddress: string, multicastInterface?: string): void; } } declare module "fs" { import * as stream from "stream"; import * as events from "events"; interface Stats { isFile(): boolean; isDirectory(): boolean; isBlockDevice(): boolean; isCharacterDevice(): boolean; isSymbolicLink(): boolean; isFIFO(): boolean; isSocket(): boolean; dev: number; ino: number; mode: number; nlink: number; uid: number; gid: number; rdev: number; size: number; blksize: number; blocks: number; atime: Date; mtime: Date; ctime: Date; birthtime: Date; } interface FSWatcher extends events.EventEmitter { close(): void; } export interface ReadStream extends stream.Readable { close(): void; } export interface WriteStream extends stream.Writable { close(): void; bytesWritten: number; } /** * Asynchronous rename. * @param oldPath * @param newPath * @param callback No arguments other than a possible exception are given to the completion callback. */ export function rename(oldPath: string, newPath: string, callback?: (err?: NodeJS.ErrnoException) => void): void; /** * Synchronous rename * @param oldPath * @param newPath */ export function renameSync(oldPath: string, newPath: string): void; export function truncate(path: string, callback?: (err?: NodeJS.ErrnoException) => void): void; export function truncate(path: string, len: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function truncateSync(path: string, len?: number): void; export function ftruncate(fd: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function ftruncate(fd: number, len: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function ftruncateSync(fd: number, len?: number): void; export function chown(path: string, uid: number, gid: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function chownSync(path: string, uid: number, gid: number): void; export function fchown(fd: number, uid: number, gid: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function fchownSync(fd: number, uid: number, gid: number): void; export function lchown(path: string, uid: number, gid: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function lchownSync(path: string, uid: number, gid: number): void; export function chmod(path: string, mode: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function chmod(path: string, mode: string, callback?: (err?: NodeJS.ErrnoException) => void): void; export function chmodSync(path: string, mode: number): void; export function chmodSync(path: string, mode: string): void; export function fchmod(fd: number, mode: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function fchmod(fd: number, mode: string, callback?: (err?: NodeJS.ErrnoException) => void): void; export function fchmodSync(fd: number, mode: number): void; export function fchmodSync(fd: number, mode: string): void; export function lchmod(path: string, mode: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function lchmod(path: string, mode: string, callback?: (err?: NodeJS.ErrnoException) => void): void; export function lchmodSync(path: string, mode: number): void; export function lchmodSync(path: string, mode: string): void; export function stat(path: string, callback?: (err: NodeJS.ErrnoException, stats: Stats) => any): void; export function lstat(path: string, callback?: (err: NodeJS.ErrnoException, stats: Stats) => any): void; export function fstat(fd: number, callback?: (err: NodeJS.ErrnoException, stats: Stats) => any): void; export function statSync(path: string): Stats; export function lstatSync(path: string): Stats; export function fstatSync(fd: number): Stats; export function link(srcpath: string, dstpath: string, callback?: (err?: NodeJS.ErrnoException) => void): void; export function linkSync(srcpath: string, dstpath: string): void; export function symlink(srcpath: string, dstpath: string, type?: string, callback?: (err?: NodeJS.ErrnoException) => void): void; export function symlinkSync(srcpath: string, dstpath: string, type?: string): void; export function readlink(path: string, callback?: (err: NodeJS.ErrnoException, linkString: string) => any): void; export function readlinkSync(path: string): string; export function realpath(path: string, callback?: (err: NodeJS.ErrnoException, resolvedPath: string) => any): void; export function realpath(path: string, cache: {[path: string]: string}, callback: (err: NodeJS.ErrnoException, resolvedPath: string) =>any): void; export function realpathSync(path: string, cache?: { [path: string]: string }): string; /* * Asynchronous unlink - deletes the file specified in {path} * * @param path * @param callback No arguments other than a possible exception are given to the completion callback. */ export function unlink(path: string, callback?: (err?: NodeJS.ErrnoException) => void): void; /* * Synchronous unlink - deletes the file specified in {path} * * @param path */ export function unlinkSync(path: string): void; /* * Asynchronous rmdir - removes the directory specified in {path} * * @param path * @param callback No arguments other than a possible exception are given to the completion callback. */ export function rmdir(path: string, callback?: (err?: NodeJS.ErrnoException) => void): void; /* * Synchronous rmdir - removes the directory specified in {path} * * @param path */ export function rmdirSync(path: string): void; /* * Asynchronous mkdir - creates the directory specified in {path}. Parameter {mode} defaults to 0777. * * @param path * @param callback No arguments other than a possible exception are given to the completion callback. */ export function mkdir(path: string, callback?: (err?: NodeJS.ErrnoException) => void): void; /* * Asynchronous mkdir - creates the directory specified in {path}. Parameter {mode} defaults to 0777. * * @param path * @param mode * @param callback No arguments other than a possible exception are given to the completion callback. */ export function mkdir(path: string, mode: number, callback?: (err?: NodeJS.ErrnoException) => void): void; /* * Asynchronous mkdir - creates the directory specified in {path}. Parameter {mode} defaults to 0777. * * @param path * @param mode * @param callback No arguments other than a possible exception are given to the completion callback. */ export function mkdir(path: string, mode: string, callback?: (err?: NodeJS.ErrnoException) => void): void; /* * Synchronous mkdir - creates the directory specified in {path}. Parameter {mode} defaults to 0777. * * @param path * @param mode * @param callback No arguments other than a possible exception are given to the completion callback. */ export function mkdirSync(path: string, mode?: number): void; /* * Synchronous mkdir - creates the directory specified in {path}. Parameter {mode} defaults to 0777. * * @param path * @param mode * @param callback No arguments other than a possible exception are given to the completion callback. */ export function mkdirSync(path: string, mode?: string): void; export function readdir(path: string, callback?: (err: NodeJS.ErrnoException, files: string[]) => void): void; export function readdirSync(path: string): string[]; export function close(fd: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function closeSync(fd: number): void; export function open(path: string, flags: string, callback?: (err: NodeJS.ErrnoException, fd: number) => any): void; export function open(path: string, flags: string, mode: number, callback?: (err: NodeJS.ErrnoException, fd: number) => any): void; export function open(path: string, flags: string, mode: string, callback?: (err: NodeJS.ErrnoException, fd: number) => any): void; export function openSync(path: string, flags: string, mode?: number): number; export function openSync(path: string, flags: string, mode?: string): number; export function utimes(path: string, atime: number, mtime: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function utimes(path: string, atime: Date, mtime: Date, callback?: (err?: NodeJS.ErrnoException) => void): void; export function utimesSync(path: string, atime: number, mtime: number): void; export function utimesSync(path: string, atime: Date, mtime: Date): void; export function futimes(fd: number, atime: number, mtime: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function futimes(fd: number, atime: Date, mtime: Date, callback?: (err?: NodeJS.ErrnoException) => void): void; export function futimesSync(fd: number, atime: number, mtime: number): void; export function futimesSync(fd: number, atime: Date, mtime: Date): void; export function fsync(fd: number, callback?: (err?: NodeJS.ErrnoException) => void): void; export function fsyncSync(fd: number): void; export function write(fd: number, buffer: Buffer, offset: number, length: number, position: number, callback?: (err: NodeJS.ErrnoException, written: number, buffer: Buffer) => void): void; export function write(fd: number, buffer: Buffer, offset: number, length: number, callback?: (err: NodeJS.ErrnoException, written: number, buffer: Buffer) => void): void; export function write(fd: number, data: any, callback?: (err: NodeJS.ErrnoException, written: number, str: string) => void): void; export function write(fd: number, data: any, offset: number, callback?: (err: NodeJS.ErrnoException, written: number, str: string) => void): void; export function write(fd: number, data: any, offset: number, encoding: string, callback?: (err: NodeJS.ErrnoException, written: number, str: string) => void): void; export function writeSync(fd: number, buffer: Buffer, offset: number, length: number, position: number): number; export function read(fd: number, buffer: Buffer, offset: number, length: number, position: number, callback?: (err: NodeJS.ErrnoException, bytesRead: number, buffer: Buffer) => void): void; export function readSync(fd: number, buffer: Buffer, offset: number, length: number, position: number): number; /* * Asynchronous readFile - Asynchronously reads the entire contents of a file. * * @param fileName * @param encoding * @param callback - The callback is passed two arguments (err, data), where data is the contents of the file. */ export function readFile(filename: string, encoding: string, callback: (err: NodeJS.ErrnoException, data: string) => void): void; /* * Asynchronous readFile - Asynchronously reads the entire contents of a file. * * @param fileName * @param options An object with optional {encoding} and {flag} properties. If {encoding} is specified, readFile returns a string; otherwise it returns a Buffer. * @param callback - The callback is passed two arguments (err, data), where data is the contents of the file. */ export function readFile(filename: string, options: { encoding: string; flag?: string; }, callback: (err: NodeJS.ErrnoException, data: string) => void): void; /* * Asynchronous readFile - Asynchronously reads the entire contents of a file. * * @param fileName * @param options An object with optional {encoding} and {flag} properties. If {encoding} is specified, readFile returns a string; otherwise it returns a Buffer. * @param callback - The callback is passed two arguments (err, data), where data is the contents of the file. */ export function readFile(filename: string, options: { flag?: string; }, callback: (err: NodeJS.ErrnoException, data: Buffer) => void): void; /* * Asynchronous readFile - Asynchronously reads the entire contents of a file. * * @param fileName * @param callback - The callback is passed two arguments (err, data), where data is the contents of the file. */ export function readFile(filename: string, callback: (err: NodeJS.ErrnoException, data: Buffer) => void): void; /* * Synchronous readFile - Synchronously reads the entire contents of a file. * * @param fileName * @param encoding */ export function readFileSync(filename: string, encoding: string): string; /* * Synchronous readFile - Synchronously reads the entire contents of a file. * * @param fileName * @param options An object with optional {encoding} and {flag} properties. If {encoding} is specified, readFileSync returns a string; otherwise it returns a Buffer. */ export function readFileSync(filename: string, options: { encoding: string; flag?: string; }): string; /* * Synchronous readFile - Synchronously reads the entire contents of a file. * * @param fileName * @param options An object with optional {encoding} and {flag} properties. If {encoding} is specified, readFileSync returns a string; otherwise it returns a Buffer. */ export function readFileSync(filename: string, options?: { flag?: string; }): Buffer; export function writeFile(filename: string, data: any, callback?: (err: NodeJS.ErrnoException) => void): void; export function writeFile(filename: string, data: any, options: { encoding?: string; mode?: number; flag?: string; }, callback?: (err: NodeJS.ErrnoException) => void): void; export function writeFile(filename: string, data: any, options: { encoding?: string; mode?: string; flag?: string; }, callback?: (err: NodeJS.ErrnoException) => void): void; export function writeFileSync(filename: string, data: any, options?: { encoding?: string; mode?: number; flag?: string; }): void; export function writeFileSync(filename: string, data: any, options?: { encoding?: string; mode?: string; flag?: string; }): void; export function appendFile(filename: string, data: any, options: { encoding?: string; mode?: number; flag?: string; }, callback?: (err: NodeJS.ErrnoException) => void): void; export function appendFile(filename: string, data: any, options: { encoding?: string; mode?: string; flag?: string; }, callback?: (err: NodeJS.ErrnoException) => void): void; export function appendFile(filename: string, data: any, callback?: (err: NodeJS.ErrnoException) => void): void; export function appendFileSync(filename: string, data: any, options?: { encoding?: string; mode?: number; flag?: string; }): void; export function appendFileSync(filename: string, data: any, options?: { encoding?: string; mode?: string; flag?: string; }): void; export function watchFile(filename: string, listener: (curr: Stats, prev: Stats) => void): void; export function watchFile(filename: string, options: { persistent?: boolean; interval?: number; }, listener: (curr: Stats, prev: Stats) => void): void; export function unwatchFile(filename: string, listener?: (curr: Stats, prev: Stats) => void): void; export function watch(filename: string, listener?: (event: string, filename: string) => any): FSWatcher; export function watch(filename: string, options: { persistent?: boolean; }, listener?: (event: string, filename: string) => any): FSWatcher; export function exists(path: string, callback?: (exists: boolean) => void): void; export function existsSync(path: string): boolean; /** Constant for fs.access(). File is visible to the calling process. */ export var F_OK: number; /** Constant for fs.access(). File can be read by the calling process. */ export var R_OK: number; /** Constant for fs.access(). File can be written by the calling process. */ export var W_OK: number; /** Constant for fs.access(). File can be executed by the calling process. */ export var X_OK: number; /** Tests a user's permissions for the file specified by path. */ export function access(path: string, callback: (err: NodeJS.ErrnoException) => void): void; export function access(path: string, mode: number, callback: (err: NodeJS.ErrnoException) => void): void; /** Synchronous version of fs.access. This throws if any accessibility checks fail, and does nothing otherwise. */ export function accessSync(path: string, mode ?: number): void; export function createReadStream(path: string, options?: { flags?: string; encoding?: string; fd?: number; mode?: number; autoClose?: boolean; }): ReadStream; export function createWriteStream(path: string, options?: { flags?: string; encoding?: string; fd?: number; mode?: number; }): WriteStream; } declare module "path" { /** * A parsed path object generated by path.parse() or consumed by path.format(). */ export interface ParsedPath { /** * The root of the path such as '/' or 'c:\' */ root: string; /** * The full directory path such as '/home/user/dir' or 'c:\path\dir' */ dir: string; /** * The file name including extension (if any) such as 'index.html' */ base: string; /** * The file extension (if any) such as '.html' */ ext: string; /** * The file name without extension (if any) such as 'index' */ name: string; } /** * Normalize a string path, reducing '..' and '.' parts. * When multiple slashes are found, they're replaced by a single one; when the path contains a trailing slash, it is preserved. On Windows backslashes are used. * * @param p string path to normalize. */ export function normalize(p: string): string; /** * Join all arguments together and normalize the resulting path. * Arguments must be strings. In v0.8, non-string arguments were silently ignored. In v0.10 and up, an exception is thrown. * * @param paths string paths to join. */ export function join(...paths: any[]): string; /** * Join all arguments together and normalize the resulting path. * Arguments must be strings. In v0.8, non-string arguments were silently ignored. In v0.10 and up, an exception is thrown. * * @param paths string paths to join. */ export function join(...paths: string[]): string; /** * The right-most parameter is considered {to}. Other parameters are considered an array of {from}. * * Starting from leftmost {from} paramter, resolves {to} to an absolute path. * * If {to} isn't already absolute, {from} arguments are prepended in right to left order, until an absolute path is found. If after using all {from} paths still no absolute path is found, the current working directory is used as well. The resulting path is normalized, and trailing slashes are removed unless the path gets resolved to the root directory. * * @param pathSegments string paths to join. Non-string arguments are ignored. */ export function resolve(...pathSegments: any[]): string; /** * Determines whether {path} is an absolute path. An absolute path will always resolve to the same location, regardless of the working directory. * * @param path path to test. */ export function isAbsolute(path: string): boolean; /** * Solve the relative path from {from} to {to}. * At times we have two absolute paths, and we need to derive the relative path from one to the other. This is actually the reverse transform of path.resolve. * * @param from * @param to */ export function relative(from: string, to: string): string; /** * Return the directory name of a path. Similar to the Unix dirname command. * * @param p the path to evaluate. */ export function dirname(p: string): string; /** * Return the last portion of a path. Similar to the Unix basename command. * Often used to extract the file name from a fully qualified path. * * @param p the path to evaluate. * @param ext optionally, an extension to remove from the result. */ export function basename(p: string, ext?: string): string; /** * Return the extension of the path, from the last '.' to end of string in the last portion of the path. * If there is no '.' in the last portion of the path or the first character of it is '.', then it returns an empty string * * @param p the path to evaluate. */ export function extname(p: string): string; /** * The platform-specific file separator. '\\' or '/'. */ export var sep: string; /** * The platform-specific file delimiter. ';' or ':'. */ export var delimiter: string; /** * Returns an object from a path string - the opposite of format(). * * @param pathString path to evaluate. */ export function parse(pathString: string): ParsedPath; /** * Returns a path string from an object - the opposite of parse(). * * @param pathString path to evaluate. */ export function format(pathObject: ParsedPath): string; export module posix { export function normalize(p: string): string; export function join(...paths: any[]): string; export function resolve(...pathSegments: any[]): string; export function isAbsolute(p: string): boolean; export function relative(from: string, to: string): string; export function dirname(p: string): string; export function basename(p: string, ext?: string): string; export function extname(p: string): string; export var sep: string; export var delimiter: string; export function parse(p: string): ParsedPath; export function format(pP: ParsedPath): string; } export module win32 { export function normalize(p: string): string; export function join(...paths: any[]): string; export function resolve(...pathSegments: any[]): string; export function isAbsolute(p: string): boolean; export function relative(from: string, to: string): string; export function dirname(p: string): string; export function basename(p: string, ext?: string): string; export function extname(p: string): string; export var sep: string; export var delimiter: string; export function parse(p: string): ParsedPath; export function format(pP: ParsedPath): string; } } declare module "string_decoder" { export interface NodeStringDecoder { write(buffer: Buffer): string; detectIncompleteChar(buffer: Buffer): number; } export var StringDecoder: { new (encoding: string): NodeStringDecoder; }; } declare module "tls" { import * as crypto from "crypto"; import * as net from "net"; import * as stream from "stream"; var CLIENT_RENEG_LIMIT: number; var CLIENT_RENEG_WINDOW: number; export interface TlsOptions { host?: string; port?: number; pfx?: any; //string or buffer key?: any; //string or buffer passphrase?: string; cert?: any; ca?: any; //string or buffer crl?: any; //string or string array ciphers?: string; honorCipherOrder?: any; requestCert?: boolean; rejectUnauthorized?: boolean; NPNProtocols?: any; //array or Buffer; SNICallback?: (servername: string) => any; } export interface ConnectionOptions { host?: string; port?: number; socket?: net.Socket; pfx?: any; //string | Buffer key?: any; //string | Buffer passphrase?: string; cert?: any; //string | Buffer ca?: any; //Array of string | Buffer rejectUnauthorized?: boolean; NPNProtocols?: any; //Array of string | Buffer servername?: string; } export interface Server extends net.Server { // Extended base methods listen(port: number, host?: string, backlog?: number, listeningListener?: Function): Server; listen(path: string, listeningListener?: Function): Server; listen(handle: any, listeningListener?: Function): Server; listen(port: number, host?: string, callback?: Function): Server; close(): Server; address(): { port: number; family: string; address: string; }; addContext(hostName: string, credentials: { key: string; cert: string; ca: string; }): void; maxConnections: number; connections: number; } export interface ClearTextStream extends stream.Duplex { authorized: boolean; authorizationError: Error; getPeerCertificate(): any; getCipher: { name: string; version: string; }; address: { port: number; family: string; address: string; }; remoteAddress: string; remotePort: number; } export interface SecurePair { encrypted: any; cleartext: any; } export interface SecureContextOptions { pfx?: any; //string | buffer key?: any; //string | buffer passphrase?: string; cert?: any; // string | buffer ca?: any; // string | buffer crl?: any; // string | string[] ciphers?: string; honorCipherOrder?: boolean; } export interface SecureContext { context: any; } export function createServer(options: TlsOptions, secureConnectionListener?: (cleartextStream: ClearTextStream) =>void ): Server; export function connect(options: TlsOptions, secureConnectionListener?: () =>void ): ClearTextStream; export function connect(port: number, host?: string, options?: ConnectionOptions, secureConnectListener?: () =>void ): ClearTextStream; export function connect(port: number, options?: ConnectionOptions, secureConnectListener?: () =>void ): ClearTextStream; export function createSecurePair(credentials?: crypto.Credentials, isServer?: boolean, requestCert?: boolean, rejectUnauthorized?: boolean): SecurePair; export function createSecureContext(details: SecureContextOptions): SecureContext; } declare module "crypto" { export interface CredentialDetails { pfx: string; key: string; passphrase: string; cert: string; ca: any; //string | string array crl: any; //string | string array ciphers: string; } export interface Credentials { context?: any; } export function createCredentials(details: CredentialDetails): Credentials; export function createHash(algorithm: string): Hash; export function createHmac(algorithm: string, key: string): Hmac; export function createHmac(algorithm: string, key: Buffer): Hmac; export interface Hash { update(data: any, input_encoding?: string): Hash; digest(encoding: 'buffer'): Buffer; digest(encoding: string): any; digest(): Buffer; } export interface Hmac extends NodeJS.ReadWriteStream { update(data: any, input_encoding?: string): Hmac; digest(encoding: 'buffer'): Buffer; digest(encoding: string): any; digest(): Buffer; } export function createCipher(algorithm: string, password: any): Cipher; export function createCipheriv(algorithm: string, key: any, iv: any): Cipher; export interface Cipher { update(data: Buffer): Buffer; update(data: string, input_encoding?: string, output_encoding?: string): string; final(): Buffer; final(output_encoding: string): string; setAutoPadding(auto_padding: boolean): void; } export function createDecipher(algorithm: string, password: any): Decipher; export function createDecipheriv(algorithm: string, key: any, iv: any): Decipher; export interface Decipher { update(data: Buffer): Buffer; update(data: string, input_encoding?: string, output_encoding?: string): string; final(): Buffer; final(output_encoding: string): string; setAutoPadding(auto_padding: boolean): void; } export function createSign(algorithm: string): Signer; export interface Signer extends NodeJS.WritableStream { update(data: any): void; sign(private_key: string, output_format: string): string; } export function createVerify(algorith: string): Verify; export interface Verify extends NodeJS.WritableStream { update(data: any): void; verify(object: string, signature: string, signature_format?: string): boolean; } export function createDiffieHellman(prime_length: number): DiffieHellman; export function createDiffieHellman(prime: number, encoding?: string): DiffieHellman; export interface DiffieHellman { generateKeys(encoding?: string): string; computeSecret(other_public_key: string, input_encoding?: string, output_encoding?: string): string; getPrime(encoding?: string): string; getGenerator(encoding: string): string; getPublicKey(encoding?: string): string; getPrivateKey(encoding?: string): string; setPublicKey(public_key: string, encoding?: string): void; setPrivateKey(public_key: string, encoding?: string): void; } export function getDiffieHellman(group_name: string): DiffieHellman; export function pbkdf2(password: string|Buffer, salt: string|Buffer, iterations: number, keylen: number, callback: (err: Error, derivedKey: Buffer) => any): void; export function pbkdf2(password: string|Buffer, salt: string|Buffer, iterations: number, keylen: number, digest: string, callback: (err: Error, derivedKey: Buffer) => any): void; export function pbkdf2Sync(password: string|Buffer, salt: string|Buffer, iterations: number, keylen: number) : Buffer; export function pbkdf2Sync(password: string|Buffer, salt: string|Buffer, iterations: number, keylen: number, digest: string) : Buffer; export function randomBytes(size: number): Buffer; export function randomBytes(size: number, callback: (err: Error, buf: Buffer) =>void ): void; export function pseudoRandomBytes(size: number): Buffer; export function pseudoRandomBytes(size: number, callback: (err: Error, buf: Buffer) =>void ): void; export interface RsaPublicKey { key: string; padding?: any; } export interface RsaPrivateKey { key: string; passphrase?: string, padding?: any; } export function publicEncrypt(public_key: string|RsaPublicKey, buffer: Buffer): Buffer export function privateDecrypt(private_key: string|RsaPrivateKey, buffer: Buffer): Buffer } declare module "stream" { import * as events from "events"; export class Stream extends events.EventEmitter { pipe(destination: T, options?: { end?: boolean; }): T; } export interface ReadableOptions { highWaterMark?: number; encoding?: string; objectMode?: boolean; } export class Readable extends events.EventEmitter implements NodeJS.ReadableStream { readable: boolean; constructor(opts?: ReadableOptions); _read(size: number): void; read(size?: number): any; setEncoding(encoding: string): void; pause(): void; resume(): void; pipe(destination: T, options?: { end?: boolean; }): T; unpipe(destination?: T): void; unshift(chunk: any): void; wrap(oldStream: NodeJS.ReadableStream): NodeJS.ReadableStream; push(chunk: any, encoding?: string): boolean; } export interface WritableOptions { highWaterMark?: number; decodeStrings?: boolean; objectMode?: boolean; } export class Writable extends events.EventEmitter implements NodeJS.WritableStream { writable: boolean; constructor(opts?: WritableOptions); _write(chunk: any, encoding: string, callback: Function): void; write(chunk: any, cb?: Function): boolean; write(chunk: any, encoding?: string, cb?: Function): boolean; end(): void; end(chunk: any, cb?: Function): void; end(chunk: any, encoding?: string, cb?: Function): void; } export interface DuplexOptions extends ReadableOptions, WritableOptions { allowHalfOpen?: boolean; } // Note: Duplex extends both Readable and Writable. export class Duplex extends Readable implements NodeJS.ReadWriteStream { writable: boolean; constructor(opts?: DuplexOptions); _write(chunk: any, encoding: string, callback: Function): void; write(chunk: any, cb?: Function): boolean; write(chunk: any, encoding?: string, cb?: Function): boolean; end(): void; end(chunk: any, cb?: Function): void; end(chunk: any, encoding?: string, cb?: Function): void; } export interface TransformOptions extends ReadableOptions, WritableOptions {} // Note: Transform lacks the _read and _write methods of Readable/Writable. export class Transform extends events.EventEmitter implements NodeJS.ReadWriteStream { readable: boolean; writable: boolean; constructor(opts?: TransformOptions); _transform(chunk: any, encoding: string, callback: Function): void; _flush(callback: Function): void; read(size?: number): any; setEncoding(encoding: string): void; pause(): void; resume(): void; pipe(destination: T, options?: { end?: boolean; }): T; unpipe(destination?: T): void; unshift(chunk: any): void; wrap(oldStream: NodeJS.ReadableStream): NodeJS.ReadableStream; push(chunk: any, encoding?: string): boolean; write(chunk: any, cb?: Function): boolean; write(chunk: any, encoding?: string, cb?: Function): boolean; end(): void; end(chunk: any, cb?: Function): void; end(chunk: any, encoding?: string, cb?: Function): void; } export class PassThrough extends Transform {} } declare module "util" { export interface InspectOptions { showHidden?: boolean; depth?: number; colors?: boolean; customInspect?: boolean; } export function format(format: any, ...param: any[]): string; export function debug(string: string): void; export function error(...param: any[]): void; export function puts(...param: any[]): void; export function print(...param: any[]): void; export function log(string: string): void; export function inspect(object: any, showHidden?: boolean, depth?: number, color?: boolean): string; export function inspect(object: any, options: InspectOptions): string; export function isArray(object: any): boolean; export function isRegExp(object: any): boolean; export function isDate(object: any): boolean; export function isError(object: any): boolean; export function inherits(constructor: any, superConstructor: any): void; export function debuglog(key:string): (msg:string,...param: any[])=>void; } declare module "assert" { function internal (value: any, message?: string): void; module internal { export class AssertionError implements Error { name: string; message: string; actual: any; expected: any; operator: string; generatedMessage: boolean; constructor(options?: {message?: string; actual?: any; expected?: any; operator?: string; stackStartFunction?: Function}); } export function fail(actual?: any, expected?: any, message?: string, operator?: string): void; export function ok(value: any, message?: string): void; export function equal(actual: any, expected: any, message?: string): void; export function notEqual(actual: any, expected: any, message?: string): void; export function deepEqual(actual: any, expected: any, message?: string): void; export function notDeepEqual(acutal: any, expected: any, message?: string): void; export function strictEqual(actual: any, expected: any, message?: string): void; export function notStrictEqual(actual: any, expected: any, message?: string): void; export function deepStrictEqual(actual: any, expected: any, message?: string): void; export function notDeepStrictEqual(actual: any, expected: any, message?: string): void; export var throws: { (block: Function, message?: string): void; (block: Function, error: Function, message?: string): void; (block: Function, error: RegExp, message?: string): void; (block: Function, error: (err: any) => boolean, message?: string): void; }; export var doesNotThrow: { (block: Function, message?: string): void; (block: Function, error: Function, message?: string): void; (block: Function, error: RegExp, message?: string): void; (block: Function, error: (err: any) => boolean, message?: string): void; }; export function ifError(value: any): void; } export = internal; } declare module "tty" { import * as net from "net"; export function isatty(fd: number): boolean; export interface ReadStream extends net.Socket { isRaw: boolean; setRawMode(mode: boolean): void; isTTY: boolean; } export interface WriteStream extends net.Socket { columns: number; rows: number; isTTY: boolean; } } declare module "domain" { import * as events from "events"; export class Domain extends events.EventEmitter { run(fn: Function): void; add(emitter: events.EventEmitter): void; remove(emitter: events.EventEmitter): void; bind(cb: (err: Error, data: any) => any): any; intercept(cb: (data: any) => any): any; dispose(): void; addListener(event: string, listener: Function): Domain; on(event: string, listener: Function): Domain; once(event: string, listener: Function): Domain; removeListener(event: string, listener: Function): Domain; removeAllListeners(event?: string): Domain; } export function create(): Domain; } declare module "constants" { export var E2BIG: number; export var EACCES: number; export var EADDRINUSE: number; export var EADDRNOTAVAIL: number; export var EAFNOSUPPORT: number; export var EAGAIN: number; export var EALREADY: number; export var EBADF: number; export var EBADMSG: number; export var EBUSY: number; export var ECANCELED: number; export var ECHILD: number; export var ECONNABORTED: number; export var ECONNREFUSED: number; export var ECONNRESET: number; export var EDEADLK: number; export var EDESTADDRREQ: number; export var EDOM: number; export var EEXIST: number; export var EFAULT: number; export var EFBIG: number; export var EHOSTUNREACH: number; export var EIDRM: number; export var EILSEQ: number; export var EINPROGRESS: number; export var EINTR: number; export var EINVAL: number; export var EIO: number; export var EISCONN: number; export var EISDIR: number; export var ELOOP: number; export var EMFILE: number; export var EMLINK: number; export var EMSGSIZE: number; export var ENAMETOOLONG: number; export var ENETDOWN: number; export var ENETRESET: number; export var ENETUNREACH: number; export var ENFILE: number; export var ENOBUFS: number; export var ENODATA: number; export var ENODEV: number; export var ENOENT: number; export var ENOEXEC: number; export var ENOLCK: number; export var ENOLINK: number; export var ENOMEM: number; export var ENOMSG: number; export var ENOPROTOOPT: number; export var ENOSPC: number; export var ENOSR: number; export var ENOSTR: number; export var ENOSYS: number; export var ENOTCONN: number; export var ENOTDIR: number; export var ENOTEMPTY: number; export var ENOTSOCK: number; export var ENOTSUP: number; export var ENOTTY: number; export var ENXIO: number; export var EOPNOTSUPP: number; export var EOVERFLOW: number; export var EPERM: number; export var EPIPE: number; export var EPROTO: number; export var EPROTONOSUPPORT: number; export var EPROTOTYPE: number; export var ERANGE: number; export var EROFS: number; export var ESPIPE: number; export var ESRCH: number; export var ETIME: number; export var ETIMEDOUT: number; export var ETXTBSY: number; export var EWOULDBLOCK: number; export var EXDEV: number; export var WSAEINTR: number; export var WSAEBADF: number; export var WSAEACCES: number; export var WSAEFAULT: number; export var WSAEINVAL: number; export var WSAEMFILE: number; export var WSAEWOULDBLOCK: number; export var WSAEINPROGRESS: number; export var WSAEALREADY: number; export var WSAENOTSOCK: number; export var WSAEDESTADDRREQ: number; export var WSAEMSGSIZE: number; export var WSAEPROTOTYPE: number; export var WSAENOPROTOOPT: number; export var WSAEPROTONOSUPPORT: number; export var WSAESOCKTNOSUPPORT: number; export var WSAEOPNOTSUPP: number; export var WSAEPFNOSUPPORT: number; export var WSAEAFNOSUPPORT: number; export var WSAEADDRINUSE: number; export var WSAEADDRNOTAVAIL: number; export var WSAENETDOWN: number; export var WSAENETUNREACH: number; export var WSAENETRESET: number; export var WSAECONNABORTED: number; export var WSAECONNRESET: number; export var WSAENOBUFS: number; export var WSAEISCONN: number; export var WSAENOTCONN: number; export var WSAESHUTDOWN: number; export var WSAETOOMANYREFS: number; export var WSAETIMEDOUT: number; export var WSAECONNREFUSED: number; export var WSAELOOP: number; export var WSAENAMETOOLONG: number; export var WSAEHOSTDOWN: number; export var WSAEHOSTUNREACH: number; export var WSAENOTEMPTY: number; export var WSAEPROCLIM: number; export var WSAEUSERS: number; export var WSAEDQUOT: number; export var WSAESTALE: number; export var WSAEREMOTE: number; export var WSASYSNOTREADY: number; export var WSAVERNOTSUPPORTED: number; export var WSANOTINITIALISED: number; export var WSAEDISCON: number; export var WSAENOMORE: number; export var WSAECANCELLED: number; export var WSAEINVALIDPROCTABLE: number; export var WSAEINVALIDPROVIDER: number; export var WSAEPROVIDERFAILEDINIT: number; export var WSASYSCALLFAILURE: number; export var WSASERVICE_NOT_FOUND: number; export var WSATYPE_NOT_FOUND: number; export var WSA_E_NO_MORE: number; export var WSA_E_CANCELLED: number; export var WSAEREFUSED: number; export var SIGHUP: number; export var SIGINT: number; export var SIGILL: number; export var SIGABRT: number; export var SIGFPE: number; export var SIGKILL: number; export var SIGSEGV: number; export var SIGTERM: number; export var SIGBREAK: number; export var SIGWINCH: number; export var SSL_OP_ALL: number; export var SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION: number; export var SSL_OP_CIPHER_SERVER_PREFERENCE: number; export var SSL_OP_CISCO_ANYCONNECT: number; export var SSL_OP_COOKIE_EXCHANGE: number; export var SSL_OP_CRYPTOPRO_TLSEXT_BUG: number; export var SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS: number; export var SSL_OP_EPHEMERAL_RSA: number; export var SSL_OP_LEGACY_SERVER_CONNECT: number; export var SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER: number; export var SSL_OP_MICROSOFT_SESS_ID_BUG: number; export var SSL_OP_MSIE_SSLV2_RSA_PADDING: number; export var SSL_OP_NETSCAPE_CA_DN_BUG: number; export var SSL_OP_NETSCAPE_CHALLENGE_BUG: number; export var SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG: number; export var SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG: number; export var SSL_OP_NO_COMPRESSION: number; export var SSL_OP_NO_QUERY_MTU: number; export var SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION: number; export var SSL_OP_NO_SSLv2: number; export var SSL_OP_NO_SSLv3: number; export var SSL_OP_NO_TICKET: number; export var SSL_OP_NO_TLSv1: number; export var SSL_OP_NO_TLSv1_1: number; export var SSL_OP_NO_TLSv1_2: number; export var SSL_OP_PKCS1_CHECK_1: number; export var SSL_OP_PKCS1_CHECK_2: number; export var SSL_OP_SINGLE_DH_USE: number; export var SSL_OP_SINGLE_ECDH_USE: number; export var SSL_OP_SSLEAY_080_CLIENT_DH_BUG: number; export var SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG: number; export var SSL_OP_TLS_BLOCK_PADDING_BUG: number; export var SSL_OP_TLS_D5_BUG: number; export var SSL_OP_TLS_ROLLBACK_BUG: number; export var ENGINE_METHOD_DSA: number; export var ENGINE_METHOD_DH: number; export var ENGINE_METHOD_RAND: number; export var ENGINE_METHOD_ECDH: number; export var ENGINE_METHOD_ECDSA: number; export var ENGINE_METHOD_CIPHERS: number; export var ENGINE_METHOD_DIGESTS: number; export var ENGINE_METHOD_STORE: number; export var ENGINE_METHOD_PKEY_METHS: number; export var ENGINE_METHOD_PKEY_ASN1_METHS: number; export var ENGINE_METHOD_ALL: number; export var ENGINE_METHOD_NONE: number; export var DH_CHECK_P_NOT_SAFE_PRIME: number; export var DH_CHECK_P_NOT_PRIME: number; export var DH_UNABLE_TO_CHECK_GENERATOR: number; export var DH_NOT_SUITABLE_GENERATOR: number; export var NPN_ENABLED: number; export var RSA_PKCS1_PADDING: number; export var RSA_SSLV23_PADDING: number; export var RSA_NO_PADDING: number; export var RSA_PKCS1_OAEP_PADDING: number; export var RSA_X931_PADDING: number; export var RSA_PKCS1_PSS_PADDING: number; export var POINT_CONVERSION_COMPRESSED: number; export var POINT_CONVERSION_UNCOMPRESSED: number; export var POINT_CONVERSION_HYBRID: number; export var O_RDONLY: number; export var O_WRONLY: number; export var O_RDWR: number; export var S_IFMT: number; export var S_IFREG: number; export var S_IFDIR: number; export var S_IFCHR: number; export var S_IFLNK: number; export var O_CREAT: number; export var O_EXCL: number; export var O_TRUNC: number; export var O_APPEND: number; export var F_OK: number; export var R_OK: number; export var W_OK: number; export var X_OK: number; export var UV_UDP_REUSEADDR: number; }WebDevelopment-assignment-2/typings/main/definitions/000077500000000000000000000000001266350324300232435ustar00rootroot00000000000000WebDevelopment-assignment-2/typings/main/definitions/gulp/000077500000000000000000000000001266350324300242125ustar00rootroot00000000000000WebDevelopment-assignment-2/typings/main/definitions/gulp/gulp.d.ts000066400000000000000000000504661266350324300257660ustar00rootroot00000000000000// Compiled using typings@0.6.8 // Source: https://raw.githubusercontent.com/typed-typings/npm-es6-promise/fb04188767acfec1defd054fc8024fafa5cd4de7/dist/es6-promise.d.ts declare module 'gulp~orchestrator~es6-promise/dist/es6-promise' { export interface Thenable { then (onFulfilled?: (value: R) => U | Thenable, onRejected?: (error: any) => U | Thenable): Thenable; then (onFulfilled?: (value: R) => U | Thenable, onRejected?: (error: any) => void): Thenable; } export class Promise implements Thenable { /** * If you call resolve in the body of the callback passed to the constructor, * your promise is fulfilled with result object passed to resolve. * If you call reject your promise is rejected with the object passed to resolve. * For consistency and debugging (eg stack traces), obj should be an instanceof Error. * Any errors thrown in the constructor callback will be implicitly passed to reject(). */ constructor (callback: (resolve : (value?: R | Thenable) => void, reject: (error?: any) => void) => void); /** * onFulfilled is called when/if "promise" resolves. onRejected is called when/if "promise" rejects. * Both are optional, if either/both are omitted the next onFulfilled/onRejected in the chain is called. * Both callbacks have a single parameter , the fulfillment value or rejection reason. * "then" returns a new promise equivalent to the value you return from onFulfilled/onRejected after being passed through Promise.resolve. * If an error is thrown in the callback, the returned promise rejects with that error. * * @param onFulfilled called when/if "promise" resolves * @param onRejected called when/if "promise" rejects */ then (onFulfilled?: (value: R) => U | Thenable, onRejected?: (error: any) => U | Thenable): Promise; then (onFulfilled?: (value: R) => U | Thenable, onRejected?: (error: any) => void): Promise; /** * Sugar for promise.then(undefined, onRejected) * * @param onRejected called when/if "promise" rejects */ catch (onRejected?: (error: any) => U | Thenable): Promise; /** * Make a new promise from the thenable. * A thenable is promise-like in as far as it has a "then" method. */ static resolve (): Promise; static resolve (value: R | Thenable): Promise; /** * Make a promise that rejects to obj. For consistency and debugging (eg stack traces), obj should be an instanceof Error */ static reject (error: any): Promise; /** * Make a promise that fulfills when every item in the array fulfills, and rejects if (and when) any item rejects. * the array passed to all can be a mixture of promise-like objects and other objects. * The fulfillment value is an array (in order) of fulfillment values. The rejection value is the first rejection value. */ static all(values: [T1 | Thenable, T2 | Thenable, T3 | Thenable, T4 | Thenable , T5 | Thenable, T6 | Thenable, T7 | Thenable, T8 | Thenable, T9 | Thenable, T10 | Thenable]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>; static all(values: [T1 | Thenable, T2 | Thenable, T3 | Thenable, T4 | Thenable , T5 | Thenable, T6 | Thenable, T7 | Thenable, T8 | Thenable, T9 | Thenable]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>; static all(values: [T1 | Thenable, T2 | Thenable, T3 | Thenable, T4 | Thenable , T5 | Thenable, T6 | Thenable, T7 | Thenable, T8 | Thenable]): Promise<[T1, T2, T3, T4, T5, T6, T7, T8]>; static all(values: [T1 | Thenable, T2 | Thenable, T3 | Thenable, T4 | Thenable , T5 | Thenable, T6 | Thenable, T7 | Thenable]): Promise<[T1, T2, T3, T4, T5, T6, T7]>; static all(values: [T1 | Thenable, T2 | Thenable, T3 | Thenable, T4 | Thenable , T5 | Thenable, T6 | Thenable]): Promise<[T1, T2, T3, T4, T5, T6]>; static all(values: [T1 | Thenable, T2 | Thenable, T3 | Thenable, T4 | Thenable , T5 | Thenable]): Promise<[T1, T2, T3, T4, T5]>; static all(values: [T1 | Thenable, T2 | Thenable, T3 | Thenable, T4 | Thenable ]): Promise<[T1, T2, T3, T4]>; static all(values: [T1 | Thenable, T2 | Thenable, T3 | Thenable]): Promise<[T1, T2, T3]>; static all(values: [T1 | Thenable, T2 | Thenable]): Promise<[T1, T2]>; static all(values: [T1 | Thenable]): Promise<[T1]>; static all(values: Array>): Promise; /** * Make a Promise that fulfills when any item fulfills, and rejects if any item rejects. */ static race (promises: (R | Thenable)[]): Promise; } /** * The polyfill method will patch the global environment (in this case to the Promise name) when called. */ export function polyfill (): void; } declare module 'gulp~orchestrator~es6-promise' { export * from 'gulp~orchestrator~es6-promise/dist/es6-promise'; } // Compiled using typings@0.6.8 // Source: https://raw.githubusercontent.com/typed-typings/npm-orchestrator/bd916c96d6d8e946bc73772fc3854accd5860aa4/orchestrator.d.ts declare module 'gulp~orchestrator/orchestrator' { // Type definitions for Orchestrator // Project: https://github.com/orchestrator/orchestrator // Definitions by: Qubo // Definitions: https://github.com/borisyankov/DefinitelyTyped import { Promise } from 'gulp~orchestrator~es6-promise'; type Strings = string | string[]; class Orchestrator { add: Orchestrator.AddMethod; /** * Have you defined a task with this name? * @param name The task name to query */ hasTask(name: string): boolean; start: Orchestrator.StartMethod; stop(): void; /** * Listen to orchestrator internals * @param event Event name to listen to: *
    *
  • start: from start() method, shows you the task sequence *
  • stop: from stop() method, the queue finished successfully *
  • err: from stop() method, the queue was aborted due to a task error *
  • task_start: from _runTask() method, task was started *
  • task_stop: from _runTask() method, task completed successfully *
  • task_err: from _runTask() method, task errored *
  • task_not_found: from start() method, you're trying to start a task that doesn't exist *
  • task_recursion: from start() method, there are recursive dependencies in your task list *
* @param cb Passes single argument: e: event details */ on(event: string, cb: (e: Orchestrator.OnCallbackEvent) => any): Orchestrator; /** * Listen to all orchestrator events from one callback * @param cb Passes single argument: e: event details */ onAll(cb: (e: Orchestrator.OnAllCallbackEvent) => any): void; } namespace Orchestrator { interface AddMethodCallback { /** * Accept a callback * @param callback */ (callback?: Function): any; /** * Return a promise */ (): Promise; /** * Return a stream: (task is marked complete when stream ends) */ (): any; //TODO: stream type should be here e.g. map-stream } /** * Define a task */ interface AddMethod { /** * Define a task * @param name The name of the task. * @param deps An array of task names to be executed and completed before your task will run. * @param fn The function that performs the task's operations. For asynchronous tasks, you need to provide a hint when the task is complete: *
    *
  • Take in a callback
    • *
  • Return a stream or a promise
    • *
*/ (name: string, deps?: string[], fn?: AddMethodCallback | Function): Orchestrator; /** * Define a task * @param name The name of the task. * @param fn The function that performs the task's operations. For asynchronous tasks, you need to provide a hint when the task is complete: *
    *
  • Take in a callback
    • *
  • Return a stream or a promise
    • *
*/ (name: string, fn?: AddMethodCallback | Function): Orchestrator; } /** * Start running the tasks */ interface StartMethod { /** * Start running the tasks * @param tasks Tasks to be executed. You may pass any number of tasks as individual arguments. * @param cb Callback to call after run completed. */ (tasks: Strings, cb?: (error?: any) => any): Orchestrator; /** * Start running the tasks * @param tasks Tasks to be executed. You may pass any number of tasks as individual arguments. * @param cb Callback to call after run completed. */ (...tasks: Strings[]/*, cb?: (error: any) => any */): Orchestrator; //TODO: TypeScript 1.5.3 cannot express varargs followed by callback as a last argument... (task1: Strings, task2: Strings, cb?: (error?: any) => any): Orchestrator; (task1: Strings, task2: Strings, task3: Strings, cb?: (error?: any) => any): Orchestrator; (task1: Strings, task2: Strings, task3: Strings, task4: Strings, cb?: (error?: any) => any): Orchestrator; (task1: Strings, task2: Strings, task3: Strings, task4: Strings, task5: Strings, cb?: (error?: any) => any): Orchestrator; (task1: Strings, task2: Strings, task3: Strings, task4: Strings, task5: Strings, task6: Strings, cb?: (error?: any) => any): Orchestrator; } interface OnCallbackEvent { message: string; task: string; err: any; duration?: number; } interface OnAllCallbackEvent extends OnCallbackEvent { src: string; } } export = Orchestrator; } declare module 'gulp~orchestrator' { import main = require('gulp~orchestrator/orchestrator'); export = main; } // Compiled using typings@0.6.8 // Source: https://raw.githubusercontent.com/typed-typings/npm-gulp/504da08753acdfe9dd2c415ab8fe36151e9645c1/gulp.d.ts declare module 'gulp/gulp' { // Type definitions for Gulp v3.8.x // Project: http://gulpjs.com // Original Definitions by: Drew Noakes import Orchestrator = require('gulp~orchestrator'); import { EventEmitter } from 'events'; import { Duplex } from 'stream'; module gulp { interface Gulp extends Orchestrator { /** * Define a task * @param name The name of the task. * @param deps An array of task names to be executed and completed before your task will run. * @param fn The function that performs the task's operations. For asynchronous tasks, you need to provide a hint when the task is complete: *
    *
  • Take in a callback
    • *
  • Return a stream or a promise
    • *
*/ task: Orchestrator.AddMethod; /** * Emits files matching provided glob or an array of globs. Returns a stream of Vinyl files that can be piped to plugins. * @param glob Glob or array of globs to read. * @param opt Options to pass to node-glob through glob-stream. */ src: SrcMethod; /** * Can be piped to and it will write files. Re-emits all data passed to it so you can pipe to multiple folders. * Folders that don't exist will be created. * * @param outFolder The path (output folder) to write files to. Or a function that returns it, the function will be provided a vinyl File instance. * @param opt */ dest: DestMethod; /** * Watch files and do something when a file changes. This always returns an EventEmitter that emits change events. * * @param glob a single glob or array of globs that indicate which files to watch for changes. * @param opt options, that are passed to the gaze library. * @param fn a callback or array of callbacks to be called on each change, or names of task(s) to run when a file changes, added with task(). */ watch: WatchMethod; } interface GulpPlugin { (...args: any[]): Duplex; } interface WatchMethod { /** * Watch files and do something when a file changes. This always returns an EventEmitter that emits change events. * * @param glob a single glob or array of globs that indicate which files to watch for changes. * @param fn a callback or array of callbacks to be called on each change, or names of task(s) to run when a file changes, added with task(). */ (glob: string | string[], fn: (WatchCallback | string)): EventEmitter; /** * Watch files and do something when a file changes. This always returns an EventEmitter that emits change events. * * @param glob a single glob or array of globs that indicate which files to watch for changes. * @param fn a callback or array of callbacks to be called on each change, or names of task(s) to run when a file changes, added with task(). */ (glob: string | string[], fn: (WatchCallback | string)[]): EventEmitter; /** * Watch files and do something when a file changes. This always returns an EventEmitter that emits change events. * * @param glob a single glob or array of globs that indicate which files to watch for changes. * @param opt options, that are passed to the gaze library. * @param fn a callback or array of callbacks to be called on each change, or names of task(s) to run when a file changes, added with task(). */ (glob: string | string[], opt: WatchOptions, fn: (WatchCallback | string)): EventEmitter; /** * Watch files and do something when a file changes. This always returns an EventEmitter that emits change events. * * @param glob a single glob or array of globs that indicate which files to watch for changes. * @param opt options, that are passed to the gaze library. * @param fn a callback or array of callbacks to be called on each change, or names of task(s) to run when a file changes, added with task(). */ (glob: string | string[], opt: WatchOptions, fn: (WatchCallback | string)[]): EventEmitter; } interface DestMethod { /** * Can be piped to and it will write files. Re-emits all data passed to it so you can pipe to multiple folders. * Folders that don't exist will be created. * * @param outFolder The path (output folder) to write files to. Or a function that returns it, the function will be provided a vinyl File instance. * @param opt */ (outFolder: string | ((file: string) => string), opt?: DestOptions): Duplex; } interface SrcMethod { /** * Emits files matching provided glob or an array of globs. Returns a stream of Vinyl files that can be piped to plugins. * @param glob Glob or array of globs to read. * @param opt Options to pass to node-glob through glob-stream. */ (glob: string | string[], opt?: SrcOptions): Duplex; } /** * Options to pass to node-glob through glob-stream. * Specifies two options in addition to those used by node-glob: * https://github.com/isaacs/node-glob#options */ interface SrcOptions { /** * Setting this to false will return file.contents as null * and not read the file at all. * Default: true. */ read?: boolean; /** * Setting this to false will return file.contents as a stream and not buffer files. * This is useful when working with large files. * Note: Plugins might not implement support for streams. * Default: true. */ buffer?: boolean; /** * The base path of a glob. * * Default is everything before a glob starts. */ base?: string; /** * The current working directory in which to search. * Defaults to process.cwd(). */ cwd?: string; /** * The place where patterns starting with / will be mounted onto. * Defaults to path.resolve(options.cwd, "/") (/ on Unix systems, and C:\ or some such on Windows.) */ root?: string; /** * Include .dot files in normal matches and globstar matches. * Note that an explicit dot in a portion of the pattern will always match dot files. */ dot?: boolean; /** * By default, a pattern starting with a forward-slash will be "mounted" onto the root setting, so that a valid * filesystem path is returned. Set this flag to disable that behavior. */ nomount?: boolean; /** * Add a / character to directory matches. Note that this requires additional stat calls. */ mark?: boolean; /** * Don't sort the results. */ nosort?: boolean; /** * Set to true to stat all results. This reduces performance somewhat, and is completely unnecessary, unless * readdir is presumed to be an untrustworthy indicator of file existence. It will cause ELOOP to be triggered one * level sooner in the case of cyclical symbolic links. */ stat?: boolean; /** * When an unusual error is encountered when attempting to read a directory, a warning will be printed to stderr. * Set the silent option to true to suppress these warnings. */ silent?: boolean; /** * When an unusual error is encountered when attempting to read a directory, the process will just continue on in * search of other matches. Set the strict option to raise an error in these cases. */ strict?: boolean; /** * See cache property above. Pass in a previously generated cache object to save some fs calls. */ cache?: boolean; /** * A cache of results of filesystem information, to prevent unnecessary stat calls. * While it should not normally be necessary to set this, you may pass the statCache from one glob() call to the * options object of another, if you know that the filesystem will not change between calls. */ statCache?: boolean; /** * Perform a synchronous glob search. */ sync?: boolean; /** * In some cases, brace-expanded patterns can result in the same file showing up multiple times in the result set. * By default, this implementation prevents duplicates in the result set. Set this flag to disable that behavior. */ nounique?: boolean; /** * Set to never return an empty set, instead returning a set containing the pattern itself. * This is the default in glob(3). */ nonull?: boolean; /** * Perform a case-insensitive match. Note that case-insensitive filesystems will sometimes result in glob returning * results that are case-insensitively matched anyway, since readdir and stat will not raise an error. */ nocase?: boolean; /** * Set to enable debug logging in minimatch and glob. */ debug?: boolean; /** * Set to enable debug logging in glob, but not minimatch. */ globDebug?: boolean; } interface DestOptions { /** * The output folder. Only has an effect if provided output folder is relative. * Default: process.cwd() */ cwd?: string; /** * Octal permission string specifying mode for any folders that need to be created for output folder. * Default: 0777. */ mode?: string; } /** * Options that are passed to gaze. * https://github.com/shama/gaze */ interface WatchOptions { /** Interval to pass to fs.watchFile. */ interval?: number; /** Delay for events called in succession for the same file/event. */ debounceDelay?: number; /** Force the watch mode. Either 'auto' (default), 'watch' (force native events), or 'poll' (force stat polling). */ mode?: string; /** The current working directory to base file patterns from. Default is process.cwd().. */ cwd?: string; } interface WatchEvent { /** The type of change that occurred, either added, changed or deleted. */ type: string; /** The path to the file that triggered the event. */ path: string; } /** * Callback to be called on each watched file change. */ interface WatchCallback { (event: WatchEvent): void; } interface TaskCallback { /** * Defines a task. * Tasks may be made asynchronous if they are passing a callback or return a promise or a stream. * @param cb callback used to signal asynchronous completion. Caller includes err in case of error. */ (cb?: (err?: any) => void): any; } } var gulp: gulp.Gulp; export = gulp; } declare module 'gulp' { import main = require('gulp/gulp'); export = main; }