vhad/DefinitelyTyped
1
0
Fork 0
mirror of https://github.com/gosticks/DefinitelyTyped.git synced 2026-10-03 22:37:03 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #1 from DefinitelyTyped/master

Browse Source 
Master to patch-2
This commit is contained in:
Dovydas Navickas
2017-07-27 23:15:05 +03:00
committed by GitHub
parent d10fdbcc3e 351950a008
commit 63c461f72e
397 changed files with 5196 additions and 746 deletions
Download Patch File Download Diff File Expand all files Collapse all files
types/angular-clipboard/angular-clipboard-tests.ts
+1 -1
View File
@@ -1,5 +1,5 @@
import * as angular from "angular";
import {ClipboardService} from "angular-clipboard";
import { ClipboardService } from "angular-clipboard";
interface TestScope extends ng.IScope {
[index: string]: any;
types/angular/angular-component-router.d.ts
Vendored
+1 -1
View File
@@ -15,7 +15,7 @@ declare namespace angular {
* ### Example
*
* ```
* import {Component} from 'angular2/core';
* import { Component } from 'angular2/core';
* import {bootstrap} from 'angular2/platform/browser';
* import {Router, ROUTER_DIRECTIVES, ROUTER_PROVIDERS, RouteConfig} from 'angular2/router';
*
types/argparse/argparse-tests.ts
+1 -1
View File
@@ -1,7 +1,7 @@
// near copy of each of the tests from https://github.com/nodeca/argparse/tree/master/examples
import {ArgumentParser, RawDescriptionHelpFormatter} from 'argparse';
import { ArgumentParser, RawDescriptionHelpFormatter } from 'argparse';
var args: any;
var simpleExample = new ArgumentParser({
types/arrify/index.d.ts
Vendored
+1 -1
View File
@@ -1,4 +1,4 @@
// Type definitions for arrify 1.0.1
// Type definitions for arrify 1.0
// Project: https://github.com/sindresorhus/arrify
// Definitions by: AnJun Wang <https://github.com/wanganjun>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
types/arrify/tsconfig.json
+1 -1
View File
@@ -19,4 +19,4 @@
"index.d.ts",
"arrify-tests.ts"
]
}
}
types/arrify/tslint.json
+1
View File
@@ -0,0 +1 @@
{ "extends": "dtslint/dt.json" }
types/askmethat-rating/askmethat-rating-tests.ts
+3
View File
@@ -13,3 +13,6 @@ let options = {
let div = document.createElement("div");
let amcRating = new AskmethatRating(div, 2 , options);
options.readonly = true;
amcRating.defaultOptions = options;
types/askmethat-rating/index.d.ts
Vendored
+12 -1
View File
@@ -75,7 +75,12 @@ export class AskmethatRating {
*
* @return options based on @type AskmethatRatingOptions
*/
readonly defaultOptions: any;
/**
* @function set the default option for the rating
*
* @return options based on @type AskmethatRatingOptions
*/
defaultOptions: AskmethatRatingOptions;
/**
* constructor with div element, default rating value & default options
*
@@ -122,6 +127,12 @@ export class AskmethatRating {
* Update readonly status if needed for the rating
*/
private mutationEvent();
/**
* This is fired by mutation observer when an attribute changed in the hidden input
* Is protected to have some unit tests
* @param {MutationRecord[]} mutations list of mutations record
*/
protected mutationDisableEvent(mutations: MutationRecord[]): void;
/**
* @function static method to retrieve with identifier the value
* @param {string} identifier: string container identifier
types/assert-plus/index.d.ts
Vendored
+1 -1
View File
@@ -5,7 +5,7 @@
/// <reference types="node" />
import {Stream} from 'stream';
import { Stream } from 'stream';
export function array(arr: any[], message ?: string): void;
types/async.nexttick/async.nexttick-tests.ts
+1 -1
View File
@@ -1,4 +1,4 @@
import {nextTick} from 'async.nexttick';
import { nextTick } from 'async.nexttick';
function calledOnNextTick(a: string): number {
return parseInt(a, 10);
types/auto-sni/index.d.ts
Vendored
+1 -1
View File
@@ -5,7 +5,7 @@
/// <reference types="node" />
import {Server} from "https";
import { Server } from "https";
declare namespace createServer {
interface Options {
types/babel-core/babel-core-tests.ts
+1 -4
View File
@@ -1,7 +1,5 @@
import * as babel from "babel-core";
// Example from https://github.com/babel/babel/tree/master/packages/babel-core
const code = `class Example {}`;
const result = babel.transform(code, { /* options */ });
@@ -9,7 +7,6 @@ result.code; // Generated code
result.map; // Sourcemap
result.ast; // AST
// Examples from http://babeljs.io/docs/usage/api/
let options: babel.TransformOptions = {
plugins: [
@@ -23,7 +20,7 @@ let options: babel.TransformOptions = {
sourceMaps: true
};
babel.transformFile("filename.js", options, function (err, result) {
babel.transformFile("filename.js", options, (err, result) => {
result.code;
result.map;
result.ast;
types/babel-core/index.d.ts
Vendored
+10 -17
View File
@@ -1,22 +1,17 @@
// Type definitions for babel-core v6.7
// Type definitions for babel-core 6.25
// Project: https://github.com/babel/babel/tree/master/packages/babel-core
// Definitions by: Troy Gerwien <https://github.com/yortus>
// Marvin Hagemeister <https://github.com/marvinhagemeister>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.3
/// <reference types="babel-template" />
/// <reference types="babel-traverse" />
/// <reference types="babel-types" />
import * as t from 'babel-types';
export {t as types};
type Node = t.Node;
export type Node = t.Node;
export import template = require('babel-template');
export var version: string;
import traverse, {Visitor} from "babel-traverse";
export {traverse, Visitor};
export const version: string;
import traverse, { Visitor } from "babel-traverse";
export { traverse, Visitor };
/** Transforms the passed in `code`. Returning an object with the generated code, source map, and AST. */
export function transform(code: string, opts?: TransformOptions): BabelFileResult;
@@ -30,7 +25,6 @@ export function transformFileSync(filename: string, opts?: TransformOptions): Ba
export function transformFromAst(ast: Node, code?: string, opts?: TransformOptions): BabelFileResult;
export interface TransformOptions {
/** Filename to use when reading from stdin - this will be used in source-maps, errors etc. Default: "unknown". */
filename?: string;
@@ -38,7 +32,7 @@ export interface TransformOptions {
filenameRelative?: string;
/** A source map object that the output source map will be based on. */
inputSourceMap?: Object;
inputSourceMap?: object;
/**
* This is an object of keys that represent different environments. For example, you may have:
@@ -46,7 +40,7 @@ export interface TransformOptions {
* which will use those options when the enviroment variable `BABEL_ENV` is set to `"production"`.
* If `BABEL_ENV` isn't set then `NODE_ENV` will be used, if it's not set then it defaults to `"development"`.
*/
env?: Object;
env?: object;
/** Retain line numbers - will result in really ugly code. Default: `false` */
retainLines?: boolean;
@@ -85,7 +79,7 @@ export interface TransformOptions {
* An optional callback that controls whether a comment should be output or not. Called as
* `shouldPrintComment(commentContents)`. **NOTE**: This overrides the `comments` option when used.
*/
shouldPrintComment?: (comment: string) => boolean;
shouldPrintComment?(comment: string): boolean;
/**
* Do not include superfluous whitespace characters and line terminators. When set to `"auto"`, `compact` is set to
@@ -122,7 +116,7 @@ export interface TransformOptions {
* Specify a custom callback to generate a module id with. Called as `getModuleId(moduleName)`.
* If falsy value is returned then the generated module id is used.
*/
getModuleId?: (moduleName: string) => string;
getModuleId?(moduleName: string): string;
/** Optional prefix for the AMD module formatter that will be prepend to the filename on module definitions. */
moduleRoot?: string;
@@ -140,7 +134,6 @@ export interface TransformOptions {
export interface BabelFileResult {
ast?: Node;
code?: string;
map?: Object;
map?: object;
}
export as namespace babel;
types/babel-core/tslint.json
+1
View File
@@ -0,0 +1 @@
{ "extends": "dtslint/dt.json" }
types/babel-generator/babel-generator-tests.ts
+1 -1
View File
@@ -1,5 +1,5 @@
// Example from https://github.com/babel/babel/tree/master/packages/babel-generator
import {parse} from 'babylon';
import { parse } from 'babylon';
import generate from 'babel-generator';
const code = 'class Example {}';
types/babel-template/babel-template-tests.ts
-2
View File
@@ -1,5 +1,3 @@
/// <reference types="babel-generator" />
// Example from https://github.com/babel/babel/tree/master/packages/babel-template
import template = require('babel-template');
import generate from 'babel-generator';
types/babel-template/index.d.ts
Vendored
+2 -7
View File
@@ -1,15 +1,11 @@
// Type definitions for babel-template v6.7
// Type definitions for babel-template 6.25
// Project: https://github.com/babel/babel/tree/master/packages/babel-template
// Definitions by: Troy Gerwien <https://github.com/yortus>
// Marvin Hagemeister <https://github.com/marvinhagemeister>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.3
/// <reference types="babylon" />
/// <reference types="babel-types" />
import {BabylonOptions} from 'babylon';
import { BabylonOptions } from 'babylon';
import * as t from 'babel-types';
type Node = t.Node;
@@ -20,4 +16,3 @@ export = template;
declare function template(code: string, opts?: BabylonOptions): UseTemplate;
type UseTemplate = (nodes?: {[placeholder: string]: Node}) => Node;
types/babel-template/tslint.json
+1
View File
@@ -0,0 +1 @@
{ "extends": "dtslint/dt.json" }
types/babel-traverse/babel-traverse-tests.ts
+1 -8
View File
@@ -1,11 +1,7 @@
/// <reference types="babylon" />
import * as babylon from "babylon";
import traverse, {Visitor} from 'babel-traverse';
import traverse, { Visitor } from 'babel-traverse';
import * as t from 'babel-types';
// Examples from: https://github.com/thejameskyle/babel-handbook/blob/master/translations/en/plugin-handbook.md
const MyVisitor: Visitor = {
Identifier: {
@@ -24,7 +20,6 @@ const MyVisitor2: Visitor = {
}
};
// Example from https://github.com/thejameskyle/babel-handbook/blob/master/translations/en/plugin-handbook.md#babel-traverse
const code = `function square(n) {
return n * n;
@@ -41,11 +36,9 @@ traverse(ast, {
}
});
// Examples from https://github.com/thejameskyle/babel-handbook/blob/master/translations/en/plugin-handbook.md#writing-your-first-babel-plugin
const v1: Visitor = {
BinaryExpression(path) {
if (t.isIdentifier(path.node.left)) {
// ...
types/babel-traverse/index.d.ts
Vendored
+376 -377
View File
@@ -1,15 +1,12 @@
// Type definitions for babel-traverse v6.7
// Type definitions for babel-traverse 6.25
// Project: https://github.com/babel/babel/tree/master/packages/babel-traverse
// Definitions by: Troy Gerwien <https://github.com/yortus>
// Marvin Hagemeister <https://github.com/marvinhagemeister>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.3
/// <reference types="babel-types" />
import * as t from 'babel-types';
type Node = t.Node;
export type Node = t.Node;
export default function traverse(parent: Node | Node[], opts?: TraverseOptions, scope?: Scope, state?: any, parentPath?: NodePath<Node>): void;
@@ -56,7 +53,7 @@ export class Scope {
/** Possibly generate a memoised identifier if it is not static and has consequences. */
maybeGenerateMemoised(node: Node, dontPush?: boolean): t.Identifier;
checkBlockScopedCollisions(local: Node, kind: string, name: string, id: Object): void;
checkBlockScopedCollisions(local: Node, kind: string, name: string, id: object): void;
rename(oldName: string, newName?: string, block?: Node): void;
@@ -97,7 +94,7 @@ export class Scope {
getBlockParent(): Scope;
/** Walks the scope tree and gathers **all** bindings. */
getAllBindings(...kinds: string[]): Object;
getAllBindings(...kinds: string[]): object;
bindingIdentifierEquals(name: string, node: Node): boolean;
@@ -131,9 +128,9 @@ export class Binding {
kind: 'var' | 'let' | 'const' | 'module';
referenced: boolean;
references: number;
referencePaths: NodePath<Node>[];
referencePaths: Array<NodePath<Node>>;
constant: boolean;
constantViolations: NodePath<Node>[];
constantViolations: Array<NodePath<Node>>;
}
export interface Visitor extends VisitNodeObject<Node> {
@@ -319,21 +316,21 @@ export interface VisitNodeObject<T> {
exit?(path: NodePath<T>, state: any): void;
}
export class NodePath<T> {
export class NodePath<T = Node> {
constructor(hub: Hub, parent: Node);
parent: Node;
hub: Hub;
contexts: TraversalContext[];
data: Object;
data: object;
shouldSkip: boolean;
shouldStop: boolean;
removed: boolean;
state: any;
opts: Object;
skipKeys: Object;
opts: object;
skipKeys: object;
parentPath: NodePath<Node>;
context: TraversalContext;
container: Object | Object[];
container: object | object[];
listKey: string;
inList: boolean;
parentKey: string;
@@ -341,7 +338,7 @@ export class NodePath<T> {
node: T;
scope: Scope;
type: string;
typeAnnotation: Object;
typeAnnotation: object;
getScope(scope: Scope): Scope;
@@ -357,7 +354,8 @@ export class NodePath<T> {
getPathLocation(): string;
debug(buildMessage: Function): void;
// Example: https://github.com/babel/babel/blob/63204ae51e020d84a5b246312f5eeb4d981ab952/packages/babel-traverse/src/path/modification.js#L83
debug(buildMessage: () => string): void;
// ------------------------- ancestry -------------------------
/**
@@ -381,17 +379,20 @@ export class NodePath<T> {
* Earliest is defined as being "before" all the other nodes in terms of list container
* position and visiting key.
*/
getEarliestCommonAncestorFrom(paths: NodePath<Node>[]): NodePath<Node>;
getEarliestCommonAncestorFrom(paths: Array<NodePath<Node>>): Array<NodePath<Node>>;
/** Get the earliest path in the tree where the provided `paths` intersect. */
getDeepestCommonAncestorFrom(paths: NodePath<Node>[], filter?: Function): NodePath<Node>;
getDeepestCommonAncestorFrom(
paths: Array<NodePath<Node>>,
filter?: (deepest: Node, i: number, ancestries: Array<NodePath<Node>>) => NodePath<Node>
): NodePath<Node>;
/**
* Build an array of node paths containing the entire ancestry of the current node path.
*
* NOTE: The current node path is included in this.
*/
getAncestry(): NodePath<Node>[];
getAncestry(): Array<NodePath<Node>>;
inType(...candidateTypes: string[]): boolean;
@@ -572,11 +573,9 @@ export class NodePath<T> {
hoist(scope: Scope): void;
// ------------------------- family -------------------------
getStatementParent(): NodePath<Node>;
getOpposite(): NodePath<Node>;
getCompletionRecords(): NodePath<Node>[];
getCompletionRecords(): Array<NodePath<Node>>;
getSibling(key: string): NodePath<Node>;
@@ -596,362 +595,362 @@ export class NodePath<T> {
addComments(type: string, comments: any[]): void;
// ------------------------- isXXX -------------------------
isArrayExpression(opts?: Object): boolean;
isAssignmentExpression(opts?: Object): boolean;
isBinaryExpression(opts?: Object): boolean;
isDirective(opts?: Object): boolean;
isDirectiveLiteral(opts?: Object): boolean;
isBlockStatement(opts?: Object): boolean;
isBreakStatement(opts?: Object): boolean;
isCallExpression(opts?: Object): boolean;
isCatchClause(opts?: Object): boolean;
isConditionalExpression(opts?: Object): boolean;
isContinueStatement(opts?: Object): boolean;
isDebuggerStatement(opts?: Object): boolean;
isDoWhileStatement(opts?: Object): boolean;
isEmptyStatement(opts?: Object): boolean;
isExpressionStatement(opts?: Object): boolean;
isFile(opts?: Object): boolean;
isForInStatement(opts?: Object): boolean;
isForStatement(opts?: Object): boolean;
isFunctionDeclaration(opts?: Object): boolean;
isFunctionExpression(opts?: Object): boolean;
isIdentifier(opts?: Object): boolean;
isIfStatement(opts?: Object): boolean;
isLabeledStatement(opts?: Object): boolean;
isStringLiteral(opts?: Object): boolean;
isNumericLiteral(opts?: Object): boolean;
isNullLiteral(opts?: Object): boolean;
isBooleanLiteral(opts?: Object): boolean;
isRegExpLiteral(opts?: Object): boolean;
isLogicalExpression(opts?: Object): boolean;
isMemberExpression(opts?: Object): boolean;
isNewExpression(opts?: Object): boolean;
isProgram(opts?: Object): boolean;
isObjectExpression(opts?: Object): boolean;
isObjectMethod(opts?: Object): boolean;
isObjectProperty(opts?: Object): boolean;
isRestElement(opts?: Object): boolean;
isReturnStatement(opts?: Object): boolean;
isSequenceExpression(opts?: Object): boolean;
isSwitchCase(opts?: Object): boolean;
isSwitchStatement(opts?: Object): boolean;
isThisExpression(opts?: Object): boolean;
isThrowStatement(opts?: Object): boolean;
isTryStatement(opts?: Object): boolean;
isUnaryExpression(opts?: Object): boolean;
isUpdateExpression(opts?: Object): boolean;
isVariableDeclaration(opts?: Object): boolean;
isVariableDeclarator(opts?: Object): boolean;
isWhileStatement(opts?: Object): boolean;
isWithStatement(opts?: Object): boolean;
isAssignmentPattern(opts?: Object): boolean;
isArrayPattern(opts?: Object): boolean;
isArrowFunctionExpression(opts?: Object): boolean;
isClassBody(opts?: Object): boolean;
isClassDeclaration(opts?: Object): boolean;
isClassExpression(opts?: Object): boolean;
isExportAllDeclaration(opts?: Object): boolean;
isExportDefaultDeclaration(opts?: Object): boolean;
isExportNamedDeclaration(opts?: Object): boolean;
isExportSpecifier(opts?: Object): boolean;
isForOfStatement(opts?: Object): boolean;
isImportDeclaration(opts?: Object): boolean;
isImportDefaultSpecifier(opts?: Object): boolean;
isImportNamespaceSpecifier(opts?: Object): boolean;
isImportSpecifier(opts?: Object): boolean;
isMetaProperty(opts?: Object): boolean;
isClassMethod(opts?: Object): boolean;
isObjectPattern(opts?: Object): boolean;
isSpreadElement(opts?: Object): boolean;
isSuper(opts?: Object): boolean;
isTaggedTemplateExpression(opts?: Object): boolean;
isTemplateElement(opts?: Object): boolean;
isTemplateLiteral(opts?: Object): boolean;
isYieldExpression(opts?: Object): boolean;
isAnyTypeAnnotation(opts?: Object): boolean;
isArrayTypeAnnotation(opts?: Object): boolean;
isBooleanTypeAnnotation(opts?: Object): boolean;
isBooleanLiteralTypeAnnotation(opts?: Object): boolean;
isNullLiteralTypeAnnotation(opts?: Object): boolean;
isClassImplements(opts?: Object): boolean;
isClassProperty(opts?: Object): boolean;
isDeclareClass(opts?: Object): boolean;
isDeclareFunction(opts?: Object): boolean;
isDeclareInterface(opts?: Object): boolean;
isDeclareModule(opts?: Object): boolean;
isDeclareTypeAlias(opts?: Object): boolean;
isDeclareVariable(opts?: Object): boolean;
isExistentialTypeParam(opts?: Object): boolean;
isFunctionTypeAnnotation(opts?: Object): boolean;
isFunctionTypeParam(opts?: Object): boolean;
isGenericTypeAnnotation(opts?: Object): boolean;
isInterfaceExtends(opts?: Object): boolean;
isInterfaceDeclaration(opts?: Object): boolean;
isIntersectionTypeAnnotation(opts?: Object): boolean;
isMixedTypeAnnotation(opts?: Object): boolean;
isNullableTypeAnnotation(opts?: Object): boolean;
isNumericLiteralTypeAnnotation(opts?: Object): boolean;
isNumberTypeAnnotation(opts?: Object): boolean;
isStringLiteralTypeAnnotation(opts?: Object): boolean;
isStringTypeAnnotation(opts?: Object): boolean;
isThisTypeAnnotation(opts?: Object): boolean;
isTupleTypeAnnotation(opts?: Object): boolean;
isTypeofTypeAnnotation(opts?: Object): boolean;
isTypeAlias(opts?: Object): boolean;
isTypeAnnotation(opts?: Object): boolean;
isTypeCastExpression(opts?: Object): boolean;
isTypeParameterDeclaration(opts?: Object): boolean;
isTypeParameterInstantiation(opts?: Object): boolean;
isObjectTypeAnnotation(opts?: Object): boolean;
isObjectTypeCallProperty(opts?: Object): boolean;
isObjectTypeIndexer(opts?: Object): boolean;
isObjectTypeProperty(opts?: Object): boolean;
isQualifiedTypeIdentifier(opts?: Object): boolean;
isUnionTypeAnnotation(opts?: Object): boolean;
isVoidTypeAnnotation(opts?: Object): boolean;
isJSXAttribute(opts?: Object): boolean;
isJSXClosingElement(opts?: Object): boolean;
isJSXElement(opts?: Object): boolean;
isJSXEmptyExpression(opts?: Object): boolean;
isJSXExpressionContainer(opts?: Object): boolean;
isJSXIdentifier(opts?: Object): boolean;
isJSXMemberExpression(opts?: Object): boolean;
isJSXNamespacedName(opts?: Object): boolean;
isJSXOpeningElement(opts?: Object): boolean;
isJSXSpreadAttribute(opts?: Object): boolean;
isJSXText(opts?: Object): boolean;
isNoop(opts?: Object): boolean;
isParenthesizedExpression(opts?: Object): boolean;
isAwaitExpression(opts?: Object): boolean;
isBindExpression(opts?: Object): boolean;
isDecorator(opts?: Object): boolean;
isDoExpression(opts?: Object): boolean;
isExportDefaultSpecifier(opts?: Object): boolean;
isExportNamespaceSpecifier(opts?: Object): boolean;
isRestProperty(opts?: Object): boolean;
isSpreadProperty(opts?: Object): boolean;
isExpression(opts?: Object): boolean;
isBinary(opts?: Object): boolean;
isScopable(opts?: Object): boolean;
isBlockParent(opts?: Object): boolean;
isBlock(opts?: Object): boolean;
isStatement(opts?: Object): boolean;
isTerminatorless(opts?: Object): boolean;
isCompletionStatement(opts?: Object): boolean;
isConditional(opts?: Object): boolean;
isLoop(opts?: Object): boolean;
isWhile(opts?: Object): boolean;
isExpressionWrapper(opts?: Object): boolean;
isFor(opts?: Object): boolean;
isForXStatement(opts?: Object): boolean;
isFunction(opts?: Object): boolean;
isFunctionParent(opts?: Object): boolean;
isPureish(opts?: Object): boolean;
isDeclaration(opts?: Object): boolean;
isLVal(opts?: Object): boolean;
isLiteral(opts?: Object): boolean;
isImmutable(opts?: Object): boolean;
isUserWhitespacable(opts?: Object): boolean;
isMethod(opts?: Object): boolean;
isObjectMember(opts?: Object): boolean;
isProperty(opts?: Object): boolean;
isUnaryLike(opts?: Object): boolean;
isPattern(opts?: Object): boolean;
isClass(opts?: Object): boolean;
isModuleDeclaration(opts?: Object): boolean;
isExportDeclaration(opts?: Object): boolean;
isModuleSpecifier(opts?: Object): boolean;
isFlow(opts?: Object): boolean;
isFlowBaseAnnotation(opts?: Object): boolean;
isFlowDeclaration(opts?: Object): boolean;
isJSX(opts?: Object): boolean;
isNumberLiteral(opts?: Object): boolean;
isRegexLiteral(opts?: Object): boolean;
isReferencedIdentifier(opts?: Object): boolean;
isReferencedMemberExpression(opts?: Object): boolean;
isBindingIdentifier(opts?: Object): boolean;
isScope(opts?: Object): boolean;
isReferenced(opts?: Object): boolean;
isBlockScoped(opts?: Object): boolean;
isVar(opts?: Object): boolean;
isUser(opts?: Object): boolean;
isGenerated(opts?: Object): boolean;
isPure(opts?: Object): boolean;
isArrayExpression(opts?: object): boolean;
isAssignmentExpression(opts?: object): boolean;
isBinaryExpression(opts?: object): boolean;
isDirective(opts?: object): boolean;
isDirectiveLiteral(opts?: object): boolean;
isBlockStatement(opts?: object): boolean;
isBreakStatement(opts?: object): boolean;
isCallExpression(opts?: object): boolean;
isCatchClause(opts?: object): boolean;
isConditionalExpression(opts?: object): boolean;
isContinueStatement(opts?: object): boolean;
isDebuggerStatement(opts?: object): boolean;
isDoWhileStatement(opts?: object): boolean;
isEmptyStatement(opts?: object): boolean;
isExpressionStatement(opts?: object): boolean;
isFile(opts?: object): boolean;
isForInStatement(opts?: object): boolean;
isForStatement(opts?: object): boolean;
isFunctionDeclaration(opts?: object): boolean;
isFunctionExpression(opts?: object): boolean;
isIdentifier(opts?: object): boolean;
isIfStatement(opts?: object): boolean;
isLabeledStatement(opts?: object): boolean;
isStringLiteral(opts?: object): boolean;
isNumericLiteral(opts?: object): boolean;
isNullLiteral(opts?: object): boolean;
isBooleanLiteral(opts?: object): boolean;
isRegExpLiteral(opts?: object): boolean;
isLogicalExpression(opts?: object): boolean;
isMemberExpression(opts?: object): boolean;
isNewExpression(opts?: object): boolean;
isProgram(opts?: object): boolean;
isObjectExpression(opts?: object): boolean;
isObjectMethod(opts?: object): boolean;
isObjectProperty(opts?: object): boolean;
isRestElement(opts?: object): boolean;
isReturnStatement(opts?: object): boolean;
isSequenceExpression(opts?: object): boolean;
isSwitchCase(opts?: object): boolean;
isSwitchStatement(opts?: object): boolean;
isThisExpression(opts?: object): boolean;
isThrowStatement(opts?: object): boolean;
isTryStatement(opts?: object): boolean;
isUnaryExpression(opts?: object): boolean;
isUpdateExpression(opts?: object): boolean;
isVariableDeclaration(opts?: object): boolean;
isVariableDeclarator(opts?: object): boolean;
isWhileStatement(opts?: object): boolean;
isWithStatement(opts?: object): boolean;
isAssignmentPattern(opts?: object): boolean;
isArrayPattern(opts?: object): boolean;
isArrowFunctionExpression(opts?: object): boolean;
isClassBody(opts?: object): boolean;
isClassDeclaration(opts?: object): boolean;
isClassExpression(opts?: object): boolean;
isExportAllDeclaration(opts?: object): boolean;
isExportDefaultDeclaration(opts?: object): boolean;
isExportNamedDeclaration(opts?: object): boolean;
isExportSpecifier(opts?: object): boolean;
isForOfStatement(opts?: object): boolean;
isImportDeclaration(opts?: object): boolean;
isImportDefaultSpecifier(opts?: object): boolean;
isImportNamespaceSpecifier(opts?: object): boolean;
isImportSpecifier(opts?: object): boolean;
isMetaProperty(opts?: object): boolean;
isClassMethod(opts?: object): boolean;
isObjectPattern(opts?: object): boolean;
isSpreadElement(opts?: object): boolean;
isSuper(opts?: object): boolean;
isTaggedTemplateExpression(opts?: object): boolean;
isTemplateElement(opts?: object): boolean;
isTemplateLiteral(opts?: object): boolean;
isYieldExpression(opts?: object): boolean;
isAnyTypeAnnotation(opts?: object): boolean;
isArrayTypeAnnotation(opts?: object): boolean;
isBooleanTypeAnnotation(opts?: object): boolean;
isBooleanLiteralTypeAnnotation(opts?: object): boolean;
isNullLiteralTypeAnnotation(opts?: object): boolean;
isClassImplements(opts?: object): boolean;
isClassProperty(opts?: object): boolean;
isDeclareClass(opts?: object): boolean;
isDeclareFunction(opts?: object): boolean;
isDeclareInterface(opts?: object): boolean;
isDeclareModule(opts?: object): boolean;
isDeclareTypeAlias(opts?: object): boolean;
isDeclareVariable(opts?: object): boolean;
isExistentialTypeParam(opts?: object): boolean;
isFunctionTypeAnnotation(opts?: object): boolean;
isFunctionTypeParam(opts?: object): boolean;
isGenericTypeAnnotation(opts?: object): boolean;
isInterfaceExtends(opts?: object): boolean;
isInterfaceDeclaration(opts?: object): boolean;
isIntersectionTypeAnnotation(opts?: object): boolean;
isMixedTypeAnnotation(opts?: object): boolean;
isNullableTypeAnnotation(opts?: object): boolean;
isNumericLiteralTypeAnnotation(opts?: object): boolean;
isNumberTypeAnnotation(opts?: object): boolean;
isStringLiteralTypeAnnotation(opts?: object): boolean;
isStringTypeAnnotation(opts?: object): boolean;
isThisTypeAnnotation(opts?: object): boolean;
isTupleTypeAnnotation(opts?: object): boolean;
isTypeofTypeAnnotation(opts?: object): boolean;
isTypeAlias(opts?: object): boolean;
isTypeAnnotation(opts?: object): boolean;
isTypeCastExpression(opts?: object): boolean;
isTypeParameterDeclaration(opts?: object): boolean;
isTypeParameterInstantiation(opts?: object): boolean;
isObjectTypeAnnotation(opts?: object): boolean;
isObjectTypeCallProperty(opts?: object): boolean;
isObjectTypeIndexer(opts?: object): boolean;
isObjectTypeProperty(opts?: object): boolean;
isQualifiedTypeIdentifier(opts?: object): boolean;
isUnionTypeAnnotation(opts?: object): boolean;
isVoidTypeAnnotation(opts?: object): boolean;
isJSXAttribute(opts?: object): boolean;
isJSXClosingElement(opts?: object): boolean;
isJSXElement(opts?: object): boolean;
isJSXEmptyExpression(opts?: object): boolean;
isJSXExpressionContainer(opts?: object): boolean;
isJSXIdentifier(opts?: object): boolean;
isJSXMemberExpression(opts?: object): boolean;
isJSXNamespacedName(opts?: object): boolean;
isJSXOpeningElement(opts?: object): boolean;
isJSXSpreadAttribute(opts?: object): boolean;
isJSXText(opts?: object): boolean;
isNoop(opts?: object): boolean;
isParenthesizedExpression(opts?: object): boolean;
isAwaitExpression(opts?: object): boolean;
isBindExpression(opts?: object): boolean;
isDecorator(opts?: object): boolean;
isDoExpression(opts?: object): boolean;
isExportDefaultSpecifier(opts?: object): boolean;
isExportNamespaceSpecifier(opts?: object): boolean;
isRestProperty(opts?: object): boolean;
isSpreadProperty(opts?: object): boolean;
isExpression(opts?: object): boolean;
isBinary(opts?: object): boolean;
isScopable(opts?: object): boolean;
isBlockParent(opts?: object): boolean;
isBlock(opts?: object): boolean;
isStatement(opts?: object): boolean;
isTerminatorless(opts?: object): boolean;
isCompletionStatement(opts?: object): boolean;
isConditional(opts?: object): boolean;
isLoop(opts?: object): boolean;
isWhile(opts?: object): boolean;
isExpressionWrapper(opts?: object): boolean;
isFor(opts?: object): boolean;
isForXStatement(opts?: object): boolean;
isFunction(opts?: object): boolean;
isFunctionParent(opts?: object): boolean;
isPureish(opts?: object): boolean;
isDeclaration(opts?: object): boolean;
isLVal(opts?: object): boolean;
isLiteral(opts?: object): boolean;
isImmutable(opts?: object): boolean;
isUserWhitespacable(opts?: object): boolean;
isMethod(opts?: object): boolean;
isObjectMember(opts?: object): boolean;
isProperty(opts?: object): boolean;
isUnaryLike(opts?: object): boolean;
isPattern(opts?: object): boolean;
isClass(opts?: object): boolean;
isModuleDeclaration(opts?: object): boolean;
isExportDeclaration(opts?: object): boolean;
isModuleSpecifier(opts?: object): boolean;
isFlow(opts?: object): boolean;
isFlowBaseAnnotation(opts?: object): boolean;
isFlowDeclaration(opts?: object): boolean;
isJSX(opts?: object): boolean;
isNumberLiteral(opts?: object): boolean;
isRegexLiteral(opts?: object): boolean;
isReferencedIdentifier(opts?: object): boolean;
isReferencedMemberExpression(opts?: object): boolean;
isBindingIdentifier(opts?: object): boolean;
isScope(opts?: object): boolean;
isReferenced(opts?: object): boolean;
isBlockScoped(opts?: object): boolean;
isVar(opts?: object): boolean;
isUser(opts?: object): boolean;
isGenerated(opts?: object): boolean;
isPure(opts?: object): boolean;
// ------------------------- assertXXX -------------------------
assertArrayExpression(opts?: Object): void;
assertAssignmentExpression(opts?: Object): void;
assertBinaryExpression(opts?: Object): void;
assertDirective(opts?: Object): void;
assertDirectiveLiteral(opts?: Object): void;
assertBlockStatement(opts?: Object): void;
assertBreakStatement(opts?: Object): void;
assertCallExpression(opts?: Object): void;
assertCatchClause(opts?: Object): void;
assertConditionalExpression(opts?: Object): void;
assertContinueStatement(opts?: Object): void;
assertDebuggerStatement(opts?: Object): void;
assertDoWhileStatement(opts?: Object): void;
assertEmptyStatement(opts?: Object): void;
assertExpressionStatement(opts?: Object): void;
assertFile(opts?: Object): void;
assertForInStatement(opts?: Object): void;
assertForStatement(opts?: Object): void;
assertFunctionDeclaration(opts?: Object): void;
assertFunctionExpression(opts?: Object): void;
assertIdentifier(opts?: Object): void;
assertIfStatement(opts?: Object): void;
assertLabeledStatement(opts?: Object): void;
assertStringLiteral(opts?: Object): void;
assertNumericLiteral(opts?: Object): void;
assertNullLiteral(opts?: Object): void;
assertBooleanLiteral(opts?: Object): void;
assertRegExpLiteral(opts?: Object): void;
assertLogicalExpression(opts?: Object): void;
assertMemberExpression(opts?: Object): void;
assertNewExpression(opts?: Object): void;
assertProgram(opts?: Object): void;
assertObjectExpression(opts?: Object): void;
assertObjectMethod(opts?: Object): void;
assertObjectProperty(opts?: Object): void;
assertRestElement(opts?: Object): void;
assertReturnStatement(opts?: Object): void;
assertSequenceExpression(opts?: Object): void;
assertSwitchCase(opts?: Object): void;
assertSwitchStatement(opts?: Object): void;
assertThisExpression(opts?: Object): void;
assertThrowStatement(opts?: Object): void;
assertTryStatement(opts?: Object): void;
assertUnaryExpression(opts?: Object): void;
assertUpdateExpression(opts?: Object): void;
assertVariableDeclaration(opts?: Object): void;
assertVariableDeclarator(opts?: Object): void;
assertWhileStatement(opts?: Object): void;
assertWithStatement(opts?: Object): void;
assertAssignmentPattern(opts?: Object): void;
assertArrayPattern(opts?: Object): void;
assertArrowFunctionExpression(opts?: Object): void;
assertClassBody(opts?: Object): void;
assertClassDeclaration(opts?: Object): void;
assertClassExpression(opts?: Object): void;
assertExportAllDeclaration(opts?: Object): void;
assertExportDefaultDeclaration(opts?: Object): void;
assertExportNamedDeclaration(opts?: Object): void;
assertExportSpecifier(opts?: Object): void;
assertForOfStatement(opts?: Object): void;
assertImportDeclaration(opts?: Object): void;
assertImportDefaultSpecifier(opts?: Object): void;
assertImportNamespaceSpecifier(opts?: Object): void;
assertImportSpecifier(opts?: Object): void;
assertMetaProperty(opts?: Object): void;
assertClassMethod(opts?: Object): void;
assertObjectPattern(opts?: Object): void;
assertSpreadElement(opts?: Object): void;
assertSuper(opts?: Object): void;
assertTaggedTemplateExpression(opts?: Object): void;
assertTemplateElement(opts?: Object): void;
assertTemplateLiteral(opts?: Object): void;
assertYieldExpression(opts?: Object): void;
assertAnyTypeAnnotation(opts?: Object): void;
assertArrayTypeAnnotation(opts?: Object): void;
assertBooleanTypeAnnotation(opts?: Object): void;
assertBooleanLiteralTypeAnnotation(opts?: Object): void;
assertNullLiteralTypeAnnotation(opts?: Object): void;
assertClassImplements(opts?: Object): void;
assertClassProperty(opts?: Object): void;
assertDeclareClass(opts?: Object): void;
assertDeclareFunction(opts?: Object): void;
assertDeclareInterface(opts?: Object): void;
assertDeclareModule(opts?: Object): void;
assertDeclareTypeAlias(opts?: Object): void;
assertDeclareVariable(opts?: Object): void;
assertExistentialTypeParam(opts?: Object): void;
assertFunctionTypeAnnotation(opts?: Object): void;
assertFunctionTypeParam(opts?: Object): void;
assertGenericTypeAnnotation(opts?: Object): void;
assertInterfaceExtends(opts?: Object): void;
assertInterfaceDeclaration(opts?: Object): void;
assertIntersectionTypeAnnotation(opts?: Object): void;
assertMixedTypeAnnotation(opts?: Object): void;
assertNullableTypeAnnotation(opts?: Object): void;
assertNumericLiteralTypeAnnotation(opts?: Object): void;
assertNumberTypeAnnotation(opts?: Object): void;
assertStringLiteralTypeAnnotation(opts?: Object): void;
assertStringTypeAnnotation(opts?: Object): void;
assertThisTypeAnnotation(opts?: Object): void;
assertTupleTypeAnnotation(opts?: Object): void;
assertTypeofTypeAnnotation(opts?: Object): void;
assertTypeAlias(opts?: Object): void;
assertTypeAnnotation(opts?: Object): void;
assertTypeCastExpression(opts?: Object): void;
assertTypeParameterDeclaration(opts?: Object): void;
assertTypeParameterInstantiation(opts?: Object): void;
assertObjectTypeAnnotation(opts?: Object): void;
assertObjectTypeCallProperty(opts?: Object): void;
assertObjectTypeIndexer(opts?: Object): void;
assertObjectTypeProperty(opts?: Object): void;
assertQualifiedTypeIdentifier(opts?: Object): void;
assertUnionTypeAnnotation(opts?: Object): void;
assertVoidTypeAnnotation(opts?: Object): void;
assertJSXAttribute(opts?: Object): void;
assertJSXClosingElement(opts?: Object): void;
assertJSXElement(opts?: Object): void;
assertJSXEmptyExpression(opts?: Object): void;
assertJSXExpressionContainer(opts?: Object): void;
assertJSXIdentifier(opts?: Object): void;
assertJSXMemberExpression(opts?: Object): void;
assertJSXNamespacedName(opts?: Object): void;
assertJSXOpeningElement(opts?: Object): void;
assertJSXSpreadAttribute(opts?: Object): void;
assertJSXText(opts?: Object): void;
assertNoop(opts?: Object): void;
assertParenthesizedExpression(opts?: Object): void;
assertAwaitExpression(opts?: Object): void;
assertBindExpression(opts?: Object): void;
assertDecorator(opts?: Object): void;
assertDoExpression(opts?: Object): void;
assertExportDefaultSpecifier(opts?: Object): void;
assertExportNamespaceSpecifier(opts?: Object): void;
assertRestProperty(opts?: Object): void;
assertSpreadProperty(opts?: Object): void;
assertExpression(opts?: Object): void;
assertBinary(opts?: Object): void;
assertScopable(opts?: Object): void;
assertBlockParent(opts?: Object): void;
assertBlock(opts?: Object): void;
assertStatement(opts?: Object): void;
assertTerminatorless(opts?: Object): void;
assertCompletionStatement(opts?: Object): void;
assertConditional(opts?: Object): void;
assertLoop(opts?: Object): void;
assertWhile(opts?: Object): void;
assertExpressionWrapper(opts?: Object): void;
assertFor(opts?: Object): void;
assertForXStatement(opts?: Object): void;
assertFunction(opts?: Object): void;
assertFunctionParent(opts?: Object): void;
assertPureish(opts?: Object): void;
assertDeclaration(opts?: Object): void;
assertLVal(opts?: Object): void;
assertLiteral(opts?: Object): void;
assertImmutable(opts?: Object): void;
assertUserWhitespacable(opts?: Object): void;
assertMethod(opts?: Object): void;
assertObjectMember(opts?: Object): void;
assertProperty(opts?: Object): void;
assertUnaryLike(opts?: Object): void;
assertPattern(opts?: Object): void;
assertClass(opts?: Object): void;
assertModuleDeclaration(opts?: Object): void;
assertExportDeclaration(opts?: Object): void;
assertModuleSpecifier(opts?: Object): void;
assertFlow(opts?: Object): void;
assertFlowBaseAnnotation(opts?: Object): void;
assertFlowDeclaration(opts?: Object): void;
assertJSX(opts?: Object): void;
assertNumberLiteral(opts?: Object): void;
assertRegexLiteral(opts?: Object): void;
assertArrayExpression(opts?: object): void;
assertAssignmentExpression(opts?: object): void;
assertBinaryExpression(opts?: object): void;
assertDirective(opts?: object): void;
assertDirectiveLiteral(opts?: object): void;
assertBlockStatement(opts?: object): void;
assertBreakStatement(opts?: object): void;
assertCallExpression(opts?: object): void;
assertCatchClause(opts?: object): void;
assertConditionalExpression(opts?: object): void;
assertContinueStatement(opts?: object): void;
assertDebuggerStatement(opts?: object): void;
assertDoWhileStatement(opts?: object): void;
assertEmptyStatement(opts?: object): void;
assertExpressionStatement(opts?: object): void;
assertFile(opts?: object): void;
assertForInStatement(opts?: object): void;
assertForStatement(opts?: object): void;
assertFunctionDeclaration(opts?: object): void;
assertFunctionExpression(opts?: object): void;
assertIdentifier(opts?: object): void;
assertIfStatement(opts?: object): void;
assertLabeledStatement(opts?: object): void;
assertStringLiteral(opts?: object): void;
assertNumericLiteral(opts?: object): void;
assertNullLiteral(opts?: object): void;
assertBooleanLiteral(opts?: object): void;
assertRegExpLiteral(opts?: object): void;
assertLogicalExpression(opts?: object): void;
assertMemberExpression(opts?: object): void;
assertNewExpression(opts?: object): void;
assertProgram(opts?: object): void;
assertObjectExpression(opts?: object): void;
assertObjectMethod(opts?: object): void;
assertObjectProperty(opts?: object): void;
assertRestElement(opts?: object): void;
assertReturnStatement(opts?: object): void;
assertSequenceExpression(opts?: object): void;
assertSwitchCase(opts?: object): void;
assertSwitchStatement(opts?: object): void;
assertThisExpression(opts?: object): void;
assertThrowStatement(opts?: object): void;
assertTryStatement(opts?: object): void;
assertUnaryExpression(opts?: object): void;
assertUpdateExpression(opts?: object): void;
assertVariableDeclaration(opts?: object): void;
assertVariableDeclarator(opts?: object): void;
assertWhileStatement(opts?: object): void;
assertWithStatement(opts?: object): void;
assertAssignmentPattern(opts?: object): void;
assertArrayPattern(opts?: object): void;
assertArrowFunctionExpression(opts?: object): void;
assertClassBody(opts?: object): void;
assertClassDeclaration(opts?: object): void;
assertClassExpression(opts?: object): void;
assertExportAllDeclaration(opts?: object): void;
assertExportDefaultDeclaration(opts?: object): void;
assertExportNamedDeclaration(opts?: object): void;
assertExportSpecifier(opts?: object): void;
assertForOfStatement(opts?: object): void;
assertImportDeclaration(opts?: object): void;
assertImportDefaultSpecifier(opts?: object): void;
assertImportNamespaceSpecifier(opts?: object): void;
assertImportSpecifier(opts?: object): void;
assertMetaProperty(opts?: object): void;
assertClassMethod(opts?: object): void;
assertObjectPattern(opts?: object): void;
assertSpreadElement(opts?: object): void;
assertSuper(opts?: object): void;
assertTaggedTemplateExpression(opts?: object): void;
assertTemplateElement(opts?: object): void;
assertTemplateLiteral(opts?: object): void;
assertYieldExpression(opts?: object): void;
assertAnyTypeAnnotation(opts?: object): void;
assertArrayTypeAnnotation(opts?: object): void;
assertBooleanTypeAnnotation(opts?: object): void;
assertBooleanLiteralTypeAnnotation(opts?: object): void;
assertNullLiteralTypeAnnotation(opts?: object): void;
assertClassImplements(opts?: object): void;
assertClassProperty(opts?: object): void;
assertDeclareClass(opts?: object): void;
assertDeclareFunction(opts?: object): void;
assertDeclareInterface(opts?: object): void;
assertDeclareModule(opts?: object): void;
assertDeclareTypeAlias(opts?: object): void;
assertDeclareVariable(opts?: object): void;
assertExistentialTypeParam(opts?: object): void;
assertFunctionTypeAnnotation(opts?: object): void;
assertFunctionTypeParam(opts?: object): void;
assertGenericTypeAnnotation(opts?: object): void;
assertInterfaceExtends(opts?: object): void;
assertInterfaceDeclaration(opts?: object): void;
assertIntersectionTypeAnnotation(opts?: object): void;
assertMixedTypeAnnotation(opts?: object): void;
assertNullableTypeAnnotation(opts?: object): void;
assertNumericLiteralTypeAnnotation(opts?: object): void;
assertNumberTypeAnnotation(opts?: object): void;
assertStringLiteralTypeAnnotation(opts?: object): void;
assertStringTypeAnnotation(opts?: object): void;
assertThisTypeAnnotation(opts?: object): void;
assertTupleTypeAnnotation(opts?: object): void;
assertTypeofTypeAnnotation(opts?: object): void;
assertTypeAlias(opts?: object): void;
assertTypeAnnotation(opts?: object): void;
assertTypeCastExpression(opts?: object): void;
assertTypeParameterDeclaration(opts?: object): void;
assertTypeParameterInstantiation(opts?: object): void;
assertObjectTypeAnnotation(opts?: object): void;
assertObjectTypeCallProperty(opts?: object): void;
assertObjectTypeIndexer(opts?: object): void;
assertObjectTypeProperty(opts?: object): void;
assertQualifiedTypeIdentifier(opts?: object): void;
assertUnionTypeAnnotation(opts?: object): void;
assertVoidTypeAnnotation(opts?: object): void;
assertJSXAttribute(opts?: object): void;
assertJSXClosingElement(opts?: object): void;
assertJSXElement(opts?: object): void;
assertJSXEmptyExpression(opts?: object): void;
assertJSXExpressionContainer(opts?: object): void;
assertJSXIdentifier(opts?: object): void;
assertJSXMemberExpression(opts?: object): void;
assertJSXNamespacedName(opts?: object): void;
assertJSXOpeningElement(opts?: object): void;
assertJSXSpreadAttribute(opts?: object): void;
assertJSXText(opts?: object): void;
assertNoop(opts?: object): void;
assertParenthesizedExpression(opts?: object): void;
assertAwaitExpression(opts?: object): void;
assertBindExpression(opts?: object): void;
assertDecorator(opts?: object): void;
assertDoExpression(opts?: object): void;
assertExportDefaultSpecifier(opts?: object): void;
assertExportNamespaceSpecifier(opts?: object): void;
assertRestProperty(opts?: object): void;
assertSpreadProperty(opts?: object): void;
assertExpression(opts?: object): void;
assertBinary(opts?: object): void;
assertScopable(opts?: object): void;
assertBlockParent(opts?: object): void;
assertBlock(opts?: object): void;
assertStatement(opts?: object): void;
assertTerminatorless(opts?: object): void;
assertCompletionStatement(opts?: object): void;
assertConditional(opts?: object): void;
assertLoop(opts?: object): void;
assertWhile(opts?: object): void;
assertExpressionWrapper(opts?: object): void;
assertFor(opts?: object): void;
assertForXStatement(opts?: object): void;
assertFunction(opts?: object): void;
assertFunctionParent(opts?: object): void;
assertPureish(opts?: object): void;
assertDeclaration(opts?: object): void;
assertLVal(opts?: object): void;
assertLiteral(opts?: object): void;
assertImmutable(opts?: object): void;
assertUserWhitespacable(opts?: object): void;
assertMethod(opts?: object): void;
assertObjectMember(opts?: object): void;
assertProperty(opts?: object): void;
assertUnaryLike(opts?: object): void;
assertPattern(opts?: object): void;
assertClass(opts?: object): void;
assertModuleDeclaration(opts?: object): void;
assertExportDeclaration(opts?: object): void;
assertModuleSpecifier(opts?: object): void;
assertFlow(opts?: object): void;
assertFlowBaseAnnotation(opts?: object): void;
assertFlowDeclaration(opts?: object): void;
assertJSX(opts?: object): void;
assertNumberLiteral(opts?: object): void;
assertRegexLiteral(opts?: object): void;
}
export class Hub {
@@ -960,7 +959,7 @@ export class Hub {
options: any;
}
interface TraversalContext {
export interface TraversalContext {
parentPath: NodePath<Node>;
scope: Scope;
state: any;
types/babel-traverse/tslint.json
+1
View File
@@ -0,0 +1 @@
{ "extends": "dtslint/dt.json" }
types/basic-auth/basic-auth-tests.ts
+1 -1
View File
@@ -1,4 +1,4 @@
import {IncomingMessage} from 'http';
import { IncomingMessage } from 'http';
import auth = require('basic-auth');
const loginData = auth(undefined! as IncomingMessage);
types/bleno/tslint.json
+1 -1
View File
@@ -1 +1 @@
{ "extends": "../tslint.json" }
{ "extends": "dtslint/dt.json" }
types/blessed/index.d.ts
Vendored
+1 -1
View File
@@ -5,7 +5,7 @@
///<reference types="node"/>
import {EventEmitter} from 'events';
import { EventEmitter } from 'events';
import * as stream from "stream";
import * as child_process from "child_process";
types/bwip-js/index.d.ts
Vendored
+1 -1
View File
@@ -5,7 +5,7 @@
/// <reference types="node" />
import {IncomingMessage as Request, ServerResponse as Response} from 'http';
import { IncomingMessage as Request, ServerResponse as Response } from 'http';
declare namespace BwipJs {
export function loadFont(fontName:string, sizeMulti: number, fontFile: string): void;
types/chokidar/index.d.ts
Vendored
+1 -1
View File
@@ -6,7 +6,7 @@
/// <reference types="node" />
import * as fs from 'fs';
import {EventEmitter} from 'events';
import { EventEmitter } from 'events';
/**
* The object's keys are all the directories (using absolute paths unless the `cwd` option was
types/closure-compiler/closure-compiler-tests.ts
+1 -1
View File
@@ -1,4 +1,4 @@
import {compile} from 'closure-compiler';
import { compile } from 'closure-compiler';
compile('some.source()', {'check-only': null},
(err: Error, stdout: string, stderr: string): void => {
types/color-convert/color-convert-tests.ts
+6
View File
@@ -0,0 +1,6 @@
import * as color from 'color-convert';
import * as conv from 'color-convert/conversions';
let hsv: [number, number, number] = color.rgb.hsv([1, 2, 3]);
let hsv_raw: [number, number, number] = color.rgb.hsv.raw([1, 2, 3]);
let aaa: [number, number, number] = color.rgb.hsv([1, 2, 3]);
types/color-convert/conversions.d.ts
Vendored
+136
View File
@@ -0,0 +1,136 @@
import * as cssKeywords from 'color-name';
export type RGB = [number, number, number];
export type HSL = [number, number, number];
export type HSV = [number, number, number];
export type HWB = [number, number, number];
export type CMYK = [number, number, number, number];
export type XYZ = [number, number, number];
export type LAB = [number, number, number];
export type LCH = [number, number, number];
export type HEX = string;
export type KEYWORD = keyof typeof cssKeywords;
export type ANSI16 = number;
export type ANSI256 = number;
export type HCG = [number, number, number];
export type APPLE = [number, number, number];
export type GRAY = [number];
export namespace rgb {
const channels: 3;
const labels: 'rgb';
function hsl(rgb: RGB): HSL;
function hsv(rgb: RGB): HSV;
function hwb(rgb: RGB): HWB;
function cmyk(rgb: RGB): CMYK;
function keyword(rgb: RGB): KEYWORD;
function xyz(rgb: RGB): XYZ;
function lab(rgb: RGB): LAB;
function ansi16(rgb: RGB): ANSI16;
function ansi256(rgb: RGB): ANSI256;
function hex(rgb: RGB): HEX;
function hcg(rgb: RGB): HCG;
function apple(rgb: RGB): APPLE;
function gray(rgb: RGB): GRAY;
}
export namespace hsl {
const channels: 3;
const labels: 'hsl';
function rgb(hsl: HSL): RGB;
function hsv(hsl: HSL): HSV;
function hcg(hsl: HSL): HCG;
}
export namespace hsv {
const channels: 3;
const labels: 'hsv';
function rgb(hsv: HSV): RGB;
function hsl(hsv: HSV): HSL;
function ansi16(hsv: HSV): ANSI16;
function hcg(hsv: HSV): HCG;
}
export namespace hwb {
const channels: 3;
const labels: 'hwb';
function rgb(hwb: HWB): RGB;
function hcg(hwb: HWB): HCG;
}
export namespace cmyk {
const channels: 4;
const labels: 'cmyk';
function rgb(cmyk: CMYK): RGB;
}
export namespace xyz {
const channels: 3;
const labels: 'xyz';
function rgb(xyz: XYZ): RGB;
function lab(xyz: XYZ): LAB;
}
export namespace lab {
const channels: 3;
const labels: 'lab';
function xyz(lab: LAB): XYZ;
function lch(lab: LAB): LCH;
}
export namespace lch {
const channels: 3;
const labels: 'lch';
function lab(lch: LCH): LAB;
}
export namespace hex {
const channels: 1;
const labels: ['hex'];
function rgb(hex: HEX): RGB;
}
export namespace keyword {
const channels: 1;
const labels: ['keyword'];
function rgb(keyword: KEYWORD): RGB;
}
export namespace ansi16 {
const channels: 1;
const labels: ['ansi16'];
function rgb(ansi16: ANSI16): RGB;
}
export namespace ansi256 {
const channels: 1;
const labels: ['ansi256'];
function rgb(ansi256: ANSI256): RGB;
}
export namespace hcg {
const channels: 3;
const labels: ['h', 'c', 'g'];
function rgb(hcg: HCG): RGB;
function hsv(hcg: HCG): HSV;
function hsl(hcg: HCG): HSL;
function hwb(hcg: HCG): HWB;
}
export namespace apple {
const channels: 3;
const labels: ['r16', 'g16', 'b16'];
function rgb(apple: APPLE): RGB;
}
export namespace gray {
const channels: 1;
const labels: ['gray'];
function rgb(gray: GRAY): RGB;
function hsl(gray: GRAY): HSL;
function hsv(gray: GRAY): HSV;
function hwb(gray: GRAY): HWB;
function cmyk(gray: GRAY): CMYK;
function lab(gray: GRAY): LAB;
function hex(gray: GRAY): HEX;
}
types/color-convert/index.d.ts
Vendored
+98
View File
@@ -0,0 +1,98 @@
// Type definitions for color-convert 1.9
// Project: https://github.com/qix-/color-convert#readme
// Definitions by: Junyoung Clare Jang <https://github.com/Airlun>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.3
import conversions = require('./conversions');
import route = require('./route');
export const rgb: typeof conversions.rgb & route.rgb & {
[F in keyof route.rgb]: {
raw: route.rgb[F]
}
};
export const hsl: typeof conversions.hsl & route.hsl & {
[F in keyof route.hsl]: {
raw: route.hsl[F]
}
};
export const hsv: typeof conversions.hsv & route.hsv & {
[F in keyof route.hsv]: {
raw: route.hsv[F]
}
};
export const hwb: typeof conversions.hwb & route.hwb & {
[F in keyof route.hwb]: {
raw: route.hwb[F]
}
};
export const cmyk: typeof conversions.cmyk & route.cmyk & {
[F in keyof route.cmyk]: {
raw: route.cmyk[F]
}
};
export const xyz: typeof conversions.xyz & route.xyz & {
[F in keyof route.xyz]: {
raw: route.xyz[F]
}
};
export const lab: typeof conversions.lab & route.lab & {
[F in keyof route.lab]: {
raw: route.lab[F]
}
};
export const lch: typeof conversions.lch & route.lch & {
[F in keyof route.lch]: {
raw: route.lch[F]
}
};
export const hex: typeof conversions.hex & route.hex & {
[F in keyof route.hex]: {
raw: route.hex[F]
}
};
export const keyword: typeof conversions.keyword & route.keyword & {
[F in keyof route.keyword]: {
raw: route.keyword[F]
}
};
export const ansi16: typeof conversions.ansi16 & route.ansi16 & {
[F in keyof route.ansi16]: {
raw: route.ansi16[F]
}
};
export const ansi256: typeof conversions.ansi256 & route.ansi256 & {
[F in keyof route.ansi256]: {
raw: route.ansi256[F]
}
};
export const hcg: typeof conversions.hcg & route.hcg & {
[F in keyof route.hcg]: {
raw: route.hcg[F]
}
};
export const apple: typeof conversions.apple & route.apple & {
[F in keyof route.apple]: {
raw: route.apple[F]
}
};
export const gray: typeof conversions.gray & route.gray & {
[F in keyof route.gray]: {
raw: route.gray[F]
}
};
types/color-convert/route.d.ts
Vendored
+262
View File
@@ -0,0 +1,262 @@
import conversions = require('./conversions');
declare namespace route {
interface rgb {
hsl(from: conversions.RGB): conversions.HSL;
hsv(from: conversions.RGB): conversions.HSV;
hwb(from: conversions.RGB): conversions.HWB;
cmyk(from: conversions.RGB): conversions.CMYK;
xyz(from: conversions.RGB): conversions.XYZ;
lab(from: conversions.RGB): conversions.LAB;
lch(from: conversions.RGB): conversions.LCH;
hex(from: conversions.RGB): conversions.HEX;
keyword(from: conversions.RGB): conversions.KEYWORD;
ansi16(from: conversions.RGB): conversions.ANSI16;
ansi256(from: conversions.RGB): conversions.ANSI256;
hcg(from: conversions.RGB): conversions.HCG;
apple(from: conversions.RGB): conversions.APPLE;
gray(from: conversions.RGB): conversions.GRAY;
}
interface hsl {
rgb(from: conversions.HSL): conversions.RGB;
hsv(from: conversions.HSL): conversions.HSV;
hwb(from: conversions.HSL): conversions.HWB;
cmyk(from: conversions.HSL): conversions.CMYK;
xyz(from: conversions.HSL): conversions.XYZ;
lab(from: conversions.HSL): conversions.LAB;
lch(from: conversions.HSL): conversions.LCH;
hex(from: conversions.HSL): conversions.HEX;
keyword(from: conversions.HSL): conversions.KEYWORD;
ansi16(from: conversions.HSL): conversions.ANSI16;
ansi256(from: conversions.HSL): conversions.ANSI256;
hcg(from: conversions.HSL): conversions.HCG;
apple(from: conversions.HSL): conversions.APPLE;
gray(from: conversions.HSL): conversions.GRAY;
}
interface hsv {
rgb(from: conversions.HSV): conversions.RGB;
hsl(from: conversions.HSV): conversions.HSL;
hwb(from: conversions.HSV): conversions.HWB;
cmyk(from: conversions.HSV): conversions.CMYK;
xyz(from: conversions.HSV): conversions.XYZ;
lab(from: conversions.HSV): conversions.LAB;
lch(from: conversions.HSV): conversions.LCH;
hex(from: conversions.HSV): conversions.HEX;
keyword(from: conversions.HSV): conversions.KEYWORD;
ansi16(from: conversions.HSV): conversions.ANSI16;
ansi256(from: conversions.HSV): conversions.ANSI256;
hcg(from: conversions.HSV): conversions.HCG;
apple(from: conversions.HSV): conversions.APPLE;
gray(from: conversions.HSV): conversions.GRAY;
}
interface hwb {
rgb(from: conversions.HWB): conversions.RGB;
hsl(from: conversions.HWB): conversions.HSL;
hsv(from: conversions.HWB): conversions.HSV;
cmyk(from: conversions.HWB): conversions.CMYK;
xyz(from: conversions.HWB): conversions.XYZ;
lab(from: conversions.HWB): conversions.LAB;
lch(from: conversions.HWB): conversions.LCH;
hex(from: conversions.HWB): conversions.HEX;
keyword(from: conversions.HWB): conversions.KEYWORD;
ansi16(from: conversions.HWB): conversions.ANSI16;
ansi256(from: conversions.HWB): conversions.ANSI256;
hcg(from: conversions.HWB): conversions.HCG;
apple(from: conversions.HWB): conversions.APPLE;
gray(from: conversions.HWB): conversions.GRAY;
}
interface cmyk {
rgb(from: conversions.CMYK): conversions.RGB;
hsl(from: conversions.CMYK): conversions.HSL;
hsv(from: conversions.CMYK): conversions.HSV;
hwb(from: conversions.CMYK): conversions.HWB;
xyz(from: conversions.CMYK): conversions.XYZ;
lab(from: conversions.CMYK): conversions.LAB;
lch(from: conversions.CMYK): conversions.LCH;
hex(from: conversions.CMYK): conversions.HEX;
keyword(from: conversions.CMYK): conversions.KEYWORD;
ansi16(from: conversions.CMYK): conversions.ANSI16;
ansi256(from: conversions.CMYK): conversions.ANSI256;
hcg(from: conversions.CMYK): conversions.HCG;
apple(from: conversions.CMYK): conversions.APPLE;
gray(from: conversions.CMYK): conversions.GRAY;
}
interface xyz {
rgb(from: conversions.XYZ): conversions.RGB;
hsl(from: conversions.XYZ): conversions.HSL;
hsv(from: conversions.XYZ): conversions.HSV;
hwb(from: conversions.XYZ): conversions.HWB;
cmyk(from: conversions.XYZ): conversions.CMYK;
lab(from: conversions.XYZ): conversions.LAB;
lch(from: conversions.XYZ): conversions.LCH;
hex(from: conversions.XYZ): conversions.HEX;
keyword(from: conversions.XYZ): conversions.KEYWORD;
ansi16(from: conversions.XYZ): conversions.ANSI16;
ansi256(from: conversions.XYZ): conversions.ANSI256;
hcg(from: conversions.XYZ): conversions.HCG;
apple(from: conversions.XYZ): conversions.APPLE;
gray(from: conversions.XYZ): conversions.GRAY;
}
interface lab {
rgb(from: conversions.LAB): conversions.RGB;
hsl(from: conversions.LAB): conversions.HSL;
hsv(from: conversions.LAB): conversions.HSV;
hwb(from: conversions.LAB): conversions.HWB;
cmyk(from: conversions.LAB): conversions.CMYK;
xyz(from: conversions.LAB): conversions.XYZ;
lch(from: conversions.LAB): conversions.LCH;
hex(from: conversions.LAB): conversions.HEX;
keyword(from: conversions.LAB): conversions.KEYWORD;
ansi16(from: conversions.LAB): conversions.ANSI16;
ansi256(from: conversions.LAB): conversions.ANSI256;
hcg(from: conversions.LAB): conversions.HCG;
apple(from: conversions.LAB): conversions.APPLE;
gray(from: conversions.LAB): conversions.GRAY;
}
interface lch {
rgb(from: conversions.LCH): conversions.RGB;
hsl(from: conversions.LCH): conversions.HSL;
hsv(from: conversions.LCH): conversions.HSV;
hwb(from: conversions.LCH): conversions.HWB;
cmyk(from: conversions.LCH): conversions.CMYK;
xyz(from: conversions.LCH): conversions.XYZ;
lab(from: conversions.LCH): conversions.LAB;
hex(from: conversions.LCH): conversions.HEX;
keyword(from: conversions.LCH): conversions.KEYWORD;
ansi16(from: conversions.LCH): conversions.ANSI16;
ansi256(from: conversions.LCH): conversions.ANSI256;
hcg(from: conversions.LCH): conversions.HCG;
apple(from: conversions.LCH): conversions.APPLE;
gray(from: conversions.LCH): conversions.GRAY;
}
interface hex {
rgb(from: conversions.HEX): conversions.RGB;
hsl(from: conversions.HEX): conversions.HSL;
hsv(from: conversions.HEX): conversions.HSV;
hwb(from: conversions.HEX): conversions.HWB;
cmyk(from: conversions.HEX): conversions.CMYK;
xyz(from: conversions.HEX): conversions.XYZ;
lab(from: conversions.HEX): conversions.LAB;
lch(from: conversions.HEX): conversions.LCH;
keyword(from: conversions.HEX): conversions.KEYWORD;
ansi16(from: conversions.HEX): conversions.ANSI16;
ansi256(from: conversions.HEX): conversions.ANSI256;
hcg(from: conversions.HEX): conversions.HCG;
apple(from: conversions.HEX): conversions.APPLE;
gray(from: conversions.HEX): conversions.GRAY;
}
interface keyword {
rgb(from: conversions.KEYWORD): conversions.RGB;
hsl(from: conversions.KEYWORD): conversions.HSL;
hsv(from: conversions.KEYWORD): conversions.HSV;
hwb(from: conversions.KEYWORD): conversions.HWB;
cmyk(from: conversions.KEYWORD): conversions.CMYK;
xyz(from: conversions.KEYWORD): conversions.XYZ;
lab(from: conversions.KEYWORD): conversions.LAB;
lch(from: conversions.KEYWORD): conversions.LCH;
hex(from: conversions.KEYWORD): conversions.HEX;
ansi16(from: conversions.KEYWORD): conversions.ANSI16;
ansi256(from: conversions.KEYWORD): conversions.ANSI256;
hcg(from: conversions.KEYWORD): conversions.HCG;
apple(from: conversions.KEYWORD): conversions.APPLE;
gray(from: conversions.KEYWORD): conversions.GRAY;
}
interface ansi16 {
rgb(from: conversions.ANSI16): conversions.RGB;
hsl(from: conversions.ANSI16): conversions.HSL;
hsv(from: conversions.ANSI16): conversions.HSV;
hwb(from: conversions.ANSI16): conversions.HWB;
cmyk(from: conversions.ANSI16): conversions.CMYK;
xyz(from: conversions.ANSI16): conversions.XYZ;
lab(from: conversions.ANSI16): conversions.LAB;
lch(from: conversions.ANSI16): conversions.LCH;
hex(from: conversions.ANSI16): conversions.HEX;
keyword(from: conversions.ANSI16): conversions.KEYWORD;
ansi256(from: conversions.ANSI16): conversions.ANSI256;
hcg(from: conversions.ANSI16): conversions.HCG;
apple(from: conversions.ANSI16): conversions.APPLE;
gray(from: conversions.ANSI16): conversions.GRAY;
}
interface ansi256 {
rgb(from: conversions.ANSI256): conversions.RGB;
hsl(from: conversions.ANSI256): conversions.HSL;
hsv(from: conversions.ANSI256): conversions.HSV;
hwb(from: conversions.ANSI256): conversions.HWB;
cmyk(from: conversions.ANSI256): conversions.CMYK;
xyz(from: conversions.ANSI256): conversions.XYZ;
lab(from: conversions.ANSI256): conversions.LAB;
lch(from: conversions.ANSI256): conversions.LCH;
hex(from: conversions.ANSI256): conversions.HEX;
keyword(from: conversions.ANSI256): conversions.KEYWORD;
ansi16(from: conversions.ANSI256): conversions.ANSI16;
hcg(from: conversions.ANSI256): conversions.HCG;
apple(from: conversions.ANSI256): conversions.APPLE;
gray(from: conversions.ANSI256): conversions.GRAY;
}
interface hcg {
rgb(from: conversions.HCG): conversions.RGB;
hsl(from: conversions.HCG): conversions.HSL;
hsv(from: conversions.HCG): conversions.HSV;
hwb(from: conversions.HCG): conversions.HWB;
cmyk(from: conversions.HCG): conversions.CMYK;
xyz(from: conversions.HCG): conversions.XYZ;
lab(from: conversions.HCG): conversions.LAB;
lch(from: conversions.HCG): conversions.LCH;
hex(from: conversions.HCG): conversions.HEX;
keyword(from: conversions.HCG): conversions.KEYWORD;
ansi16(from: conversions.HCG): conversions.ANSI16;
ansi256(from: conversions.HCG): conversions.ANSI256;
apple(from: conversions.HCG): conversions.APPLE;
gray(from: conversions.HCG): conversions.GRAY;
}
interface apple {
rgb(from: conversions.APPLE): conversions.RGB;
hsl(from: conversions.APPLE): conversions.HSL;
hsv(from: conversions.APPLE): conversions.HSV;
hwb(from: conversions.APPLE): conversions.HWB;
cmyk(from: conversions.APPLE): conversions.CMYK;
xyz(from: conversions.APPLE): conversions.XYZ;
lab(from: conversions.APPLE): conversions.LAB;
lch(from: conversions.APPLE): conversions.LCH;
hex(from: conversions.APPLE): conversions.HEX;
keyword(from: conversions.APPLE): conversions.KEYWORD;
ansi16(from: conversions.APPLE): conversions.ANSI16;
ansi256(from: conversions.APPLE): conversions.ANSI256;
hcg(from: conversions.APPLE): conversions.HCG;
gray(from: conversions.APPLE): conversions.GRAY;
}
interface gray {
rgb(from: conversions.GRAY): conversions.RGB;
hsl(from: conversions.GRAY): conversions.HSL;
hsv(from: conversions.GRAY): conversions.HSV;
hwb(from: conversions.GRAY): conversions.HWB;
cmyk(from: conversions.GRAY): conversions.CMYK;
xyz(from: conversions.GRAY): conversions.XYZ;
lab(from: conversions.GRAY): conversions.LAB;
lch(from: conversions.GRAY): conversions.LCH;
hex(from: conversions.GRAY): conversions.HEX;
keyword(from: conversions.GRAY): conversions.KEYWORD;
ansi16(from: conversions.GRAY): conversions.ANSI16;
ansi256(from: conversions.GRAY): conversions.ANSI256;
hcg(from: conversions.GRAY): conversions.HCG;
apple(from: conversions.GRAY): conversions.APPLE;
}
}
declare function route(fromModel: 'rgb'): route.rgb;
declare function route(fromModel: 'hsl'): route.hsl;
declare function route(fromModel: 'hsv'): route.hsv;
declare function route(fromModel: 'hwb'): route.hwb;
declare function route(fromModel: 'cmyk'): route.cmyk;
declare function route(fromModel: 'xyz'): route.xyz;
declare function route(fromModel: 'lab'): route.lab;
declare function route(fromModel: 'lch'): route.lch;
declare function route(fromModel: 'hex'): route.hex;
declare function route(fromModel: 'keyword'): route.keyword;
declare function route(fromModel: 'ansi16'): route.ansi16;
declare function route(fromModel: 'ansi256'): route.ansi256;
declare function route(fromModel: 'hcg'): route.hcg;
declare function route(fromModel: 'apple'): route.apple;
declare function route(fromModel: 'gray'): route.gray;
export = route;
types/color-convert/tsconfig.json
+24
View File
@@ -0,0 +1,24 @@
{
"compilerOptions": {
"module": "commonjs",
"lib": [
"es6"
],
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": true,
"baseUrl": "../",
"typeRoots": [
"../"
],
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true
},
"files": [
"index.d.ts",
"conversions.d.ts",
"route.d.ts",
"color-convert-tests.ts"
]
}
types/color-convert/tslint.json
+1
View File
@@ -0,0 +1 @@
{ "extends": "dtslint/dt.json" }
types/consul/index.d.ts
Vendored
+1 -1
View File
@@ -7,7 +7,7 @@
import {IncomingMessage as HttpIncomingMessage} from "http";
import { IncomingMessage as HttpIncomingMessage } from "http";
declare namespace Consul {
types/cwise-compiler/index.d.ts
Vendored
+1
View File
@@ -2,6 +2,7 @@
// Project: https://github.com/scijs/cwise-compiler
// Definitions by: taoqf <https://github.com/taoqf>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.3
import { CompiledRoutine } from 'cwise-parser';
import * as ndarray from 'ndarray';
types/cwise/index.d.ts
Vendored
+1
View File
@@ -2,6 +2,7 @@
// Project: https://github.com/scijs/cwise#readme
// Definitions by: taoqf <https://github.com/taoqf>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.3
import { ArgType } from "cwise-compiler";
import * as ndarray from "ndarray";
types/d3-hsv/d3-hsv-tests.ts
+2 -2
View File
@@ -6,8 +6,8 @@
* are not intended as functional tests.
*/
import {hsv, HSVColor} from 'd3-hsv';
import {rgb, RGBColor} from 'd3-color';
import { hsv, HSVColor } from 'd3-hsv';
import { rgb, RGBColor } from 'd3-color';
let c: RGBColor;
let cHSV: HSVColor;
types/d3-hsv/index.d.ts
Vendored
+1 -1
View File
@@ -5,7 +5,7 @@
// Last module patch version validated against: 0.0.3
import {Color, RGBColor, ColorSpaceObject, ColorCommonInstance} from 'd3-color';
import { Color, RGBColor, ColorSpaceObject, ColorCommonInstance } from 'd3-color';
export type ColorSpaceObjectWithHSV = ColorSpaceObject | HSVColor;
types/d3-selection-multi/index.d.ts
Vendored
+2 -2
View File
@@ -5,8 +5,8 @@
// Last module patch version validated against: 1.0.0
import {Selection, BaseType, ArrayLike, ValueFn} from 'd3-selection';
import {Transition} from 'd3-transition';
import { Selection, BaseType, ArrayLike, ValueFn } from 'd3-selection';
import { Transition } from 'd3-transition';
/**
* An object mapping attribute (or style or property) names to value accessors
types/d3-tip/index.d.ts
Vendored
+1 -1
View File
@@ -3,7 +3,7 @@
// Definitions by: Gert Braspenning <https://github.com/brspnnggrt>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
import {Primitive} from "d3";
import { Primitive } from "d3";
declare module "d3" {
type TooltipDirection = ("n" | "s" | "e" | "w" | "nw" | "ne" | "sw" | "se");
types/datatables.net-rowreorder/datatables.net-rowreorder-tests.ts
+14
View File
@@ -0,0 +1,14 @@
$(document).ready(() => {
const config: DataTables.Settings = {
// reorder extension options
rowReorder: {
dataSrc: "somesrc",
editor: {},
enable: true,
formOptions: {},
selector: "someselector",
snapX: true,
update: true,
},
};
});
types/datatables.net-rowreorder/index.d.ts
Vendored
+48
View File
@@ -0,0 +1,48 @@
// Type definitions for JQuery DataTables RowReorder extension 1.1
// Project: http://datatables.net/extensions/rowreorder/
// Definitions by: Vincent Biret <https://github.com/baywet>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.3
/// <reference types="jquery" />
/// <reference types="datatables.net"/>
declare namespace DataTables {
interface Settings {
/**
* Enable and configure the RowReorder extension for DataTables
*/
rowReorder?: RowReorderSettings;
}
interface RowReorderSettings {
/**
* Configure the data point that will be used for the reordering data
*/
dataSrc?: string;
/**
* Attach an Editor instance for database updating
*/
editor?: any;
/**
* Enable / disable RowReorder's user interaction
*/
enable?: boolean;
/**
* Set the options for the Editor form when submitting data
*/
formOptions?: any;
/**
* Define the selector used to pick the elements that will start a drag
*/
selector?: string;
/**
* Horizontal position control of the row being dragged
*/
snapX?: number | boolean;
/**
* Control automatic of data when a row is dropped
*/
update?: boolean;
}
}
types/datatables.net-rowreorder/tsconfig.json
+23
View File
@@ -0,0 +1,23 @@
{
"compilerOptions": {
"module": "commonjs",
"lib": [
"es6",
"dom"
],
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": true,
"baseUrl": "../",
"typeRoots": [
"../"
],
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true
},
"files": [
"index.d.ts",
"datatables.net-rowreorder-tests.ts"
]
}
types/datatables.net-rowreorder/tslint.json
+5
View File
@@ -0,0 +1,5 @@
{
"extends": "dtslint/dt.json",
"rules": {
}
}
types/debessmann/debessmann-tests.ts
+1 -1
View File
@@ -1,4 +1,4 @@
import {DM, Event, EventId} from 'debessmann';
import { DM, Event, EventId } from 'debessmann';
let eventId: EventId = {seq: 0, time: new Date()};
let e: Event = {_id: eventId, headers: {header1: 'header1Val'}};
types/decay/decay-tests.ts
+1 -1
View File
@@ -1,4 +1,4 @@
import {redditHot, hackerHot, wilsonScore} from 'decay';
import { redditHot, hackerHot, wilsonScore } from 'decay';
const upvotes = 42;
const downvotes = 12;
types/decorum/decorum-tests.ts
+1 -1
View File
@@ -1,4 +1,4 @@
import {Required} from 'decorum';
import { Required } from 'decorum';
import {Email} from 'decorum';
import {MinLength} from 'decorum';
import {MaxLength} from 'decorum';
types/dockerode/dockerode-tests.ts
+4
View File
@@ -74,6 +74,10 @@ docker.buildImage('archive.tar', { t: 'imageName' }, (err, response) => {
// NOOP
});
docker.buildImage({context: '.', src: ['Dockerfile', 'test.sh']}, { t: 'imageName' }, (err, response) => {
// NOOP
});
docker.createContainer({ Tty: true }, (err, container) => {
container.start((err, data) => {
// NOOP
types/dockerode/index.d.ts
Vendored
+11 -4
View File
@@ -1,6 +1,8 @@
// Type definitions for dockerode 2.4
// Project: https://github.com/apocas/dockerode
// Definitions by: Carl Winkler <https://github.com/seikho>, Nicolas Laplante <https://github.com/nlaplante>
// Definitions by: Carl Winkler <https://github.com/seikho>
// Nicolas Laplante <https://github.com/nlaplante>
// ByeongHun Yoo <https://github.com/isac322>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.2
@@ -804,6 +806,11 @@ declare namespace Dockerode {
tail?: number;
timestamps?: boolean;
}
interface ImageBuildContext {
context: string;
src: string[];
}
}
type Callback<T> = (error?: any, result?: T) => void;
@@ -830,9 +837,9 @@ declare class Dockerode {
checkAuth(options: any, callback: Callback<any>): void;
checkAuth(options: any): Promise<any>;
buildImage(file: string | NodeJS.ReadableStream, options: {}, callback: Callback<any>): void;
buildImage(file: string | NodeJS.ReadableStream, callback: Callback<any>): void;
buildImage(file: string | NodeJS.ReadableStream, options?: {}): Promise<any>;
buildImage(file: string | NodeJS.ReadableStream | Dockerode.ImageBuildContext, options: {}, callback: Callback<any>): void;
buildImage(file: string | NodeJS.ReadableStream | Dockerode.ImageBuildContext, callback: Callback<any>): void;
buildImage(file: string | NodeJS.ReadableStream | Dockerode.ImageBuildContext, options?: {}): Promise<any>;
getContainer(id: string): Dockerode.Container;
types/dookie/dookie-tests.ts
+1 -1
View File
@@ -1,4 +1,4 @@
import {push, pull} from 'dookie';
import { push, pull } from 'dookie';
(async () => {
await push('mongodb://localhost:27017/test', {test: [{ok: 1}, {ok: 2}]});
types/dot-prop/dot-prop-tests.ts
+17 -5
View File
@@ -1,11 +1,23 @@
/// <reference types="node"/>
import dotProp = require('dot-prop');
import { get, has, set } from 'dot-prop';
import * as dotProp from 'dot-prop';
dotProp.get({foo: {bar: 'unicorn'}}, 'foo.bar');
get({foo: {bar: 'unicorn'}}, 'foo.bar');
dotProp.get({foo: {bar: 'a'}}, 'foo.notDefined.deep');
dotProp.get({foo: {bar: 'a'}}, 'foo.notDefined.deep', 'default value');
dotProp.get({foo: {'dot.dot': 'unicorn'}}, 'foo.dot\\.dot');
const obj = {foo: {bar: 'a'}};
dotProp.set(obj, 'foo.bar', 'b');
set(obj, 'foo.bar', 'b');
console.log(obj);
dotProp.set(obj, 'foo.baz', 'x');
dotProp.set(obj, 'foo.dot\\.dot', 'unicorn');
console.log(obj);
has({foo: {bar: 'unicorn'}}, 'foo.bar');
dotProp.has({foo: {bar: 'unicorn'}}, 'foo.bar');
dotProp.delete(obj, 'foo.bar');
console.log(obj);
(<any> obj).foo.bar = {x: 'y', y: 'x'};
dotProp.delete(obj, 'foo.bar.x');
console.log(obj);
types/dot-prop/index.d.ts
Vendored
+13 -4
View File
@@ -1,8 +1,17 @@
// Type definitions for dot-prop
// Project: https://github.com/sindresorhus/dot-prop
// Type definitions for dot-prop 4.1
// Project: https://github.com/sindresorhus/dot-prop#readme
// Definitions by: Sam Verschueren <https://github.com/samverschueren>
// BendingBender <https://github.com/BendingBender>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.2
interface DotProp {
get(obj: object, path: string, defaultValue?: any): any;
set(obj: object, path: string, value: any): void;
has(obj: object, path: string): boolean;
delete(obj: object, path: string): boolean;
}
export declare function get(object: any, path: string): any;
export declare function set(object: any, path: string, value: any): void;
declare const dotProp: DotProp;
export = dotProp;
types/dot-prop/tsconfig.json
+2 -2
View File
@@ -6,7 +6,7 @@
],
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": false,
"strictNullChecks": true,
"baseUrl": "../",
"typeRoots": [
"../"
@@ -19,4 +19,4 @@
"index.d.ts",
"dot-prop-tests.ts"
]
}
}
types/dot-prop/tslint.json
+1
View File
@@ -0,0 +1 @@
{ "extends": "dtslint/dt.json" }
types/dot-prop/v2/dot-prop-tests.ts
+10
View File
@@ -0,0 +1,10 @@
import * as dotProp from 'dot-prop';
dotProp.get({foo: {bar: 'unicorn'}}, 'foo.bar');
dotProp.get({foo: {bar: 'a'}}, 'foo.notDefined.deep');
dotProp.get({foo: {'dot.dot': 'unicorn'}}, 'foo.dot\\.dot');
const obj = {foo: {bar: 'a'}};
dotProp.set(obj, 'foo.bar', 'b');
dotProp.set(obj, 'foo.baz', 'x');
dotProp.set(obj, 'foo.dot\\.dot', 'unicorn');
types/dot-prop/v2/index.d.ts
Vendored
+7
View File
@@ -0,0 +1,7 @@
// Type definitions for dot-prop 2.x
// Project: https://github.com/sindresorhus/dot-prop
// Definitions by: Sam Verschueren <https://github.com/samverschueren>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
export function get(object: any, path: string): any;
export function set(object: any, path: string, value: any): void;
types/dot-prop/v2/tsconfig.json
+25
View File
@@ -0,0 +1,25 @@
{
"compilerOptions": {
"module": "commonjs",
"lib": [
"es6"
],
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": false,
"baseUrl": "../../",
"typeRoots": [
"../../"
],
"paths": {
"dot-prop": ["dot-prop/v2"]
},
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true
},
"files": [
"index.d.ts",
"dot-prop-tests.ts"
]
}
types/dot-prop/v2/tslint.json
+1
View File
@@ -0,0 +1 @@
{ "extends": "dtslint/dt.json" }
types/draft-js/draft-js-tests.tsx
+1 -1
View File
@@ -1,6 +1,6 @@
import * as React from "react";
import * as ReactDOM from "react-dom";
import {Map} from "immutable";
import { Map } from "immutable";
import {
ContentBlock,
types/draft-js/index.d.ts
Vendored
+2
View File
@@ -903,6 +903,7 @@ declare namespace Draft {
}
import Editor = Draft.Component.Base.DraftEditor;
import EditorProps = Draft.Component.Base.DraftEditorProps;
import EditorBlock = Draft.Component.Components.DraftEditorBlock;
import EditorState = Draft.Model.ImmutableData.EditorState;
@@ -936,6 +937,7 @@ import getVisibleSelectionRect = Draft.Component.Selection.getVisibleSelectionRe
export {
Editor,
EditorProps,
EditorBlock,
EditorState,
types/ebongarde-root/ebongarde-root-tests.ts
+1 -1
View File
@@ -1,3 +1,3 @@
import {ROOT} from 'ebongarde-root';
import { ROOT } from 'ebongarde-root';
console.log(ROOT);
types/electron-json-storage/electron-json-storage-tests.ts
-2
View File
@@ -1,5 +1,3 @@
/// <reference types="electron" />
import electron = require('electron');
import storage = require('electron-json-storage');
types/electron-json-storage/index.d.ts
Vendored
+1 -1
View File
@@ -2,7 +2,7 @@
// Project: https://github.com/jviotti/electron-json-storage
// Definitions by: Sam Saint-Pettersen <https://github.com/stpettersens>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.1
export declare function get(key: string, callback: (error: any, data: Object) => void): void;
export declare function set(key: string, json: Object, callback: (error: any) => void): void;
types/electron-json-storage/package.json
+5
View File
@@ -0,0 +1,5 @@
{
"dependencies": {
"electron": "^1.7.5"
}
}
types/electron-notifications/index.d.ts
Vendored
+1
View File
@@ -2,6 +2,7 @@
// Project: https://github.com/blainesch/electron-notifications
// Definitions by: Daniel Pereira <https://github.com/djpereira>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.1
import * as Electron from 'electron';
types/electron-notifications/package.json
+5
View File
@@ -0,0 +1,5 @@
{
"dependencies": {
"electron": "^1.7.5"
}
}
types/electron-notify/index.d.ts
Vendored
+3 -2
View File
@@ -2,6 +2,7 @@
// Project: https://github.com/hankbao/electron-notify
// Definitions by: Daniel Pereira <https://github.com/djpereira>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.1
/// <reference types="electron" />
@@ -18,7 +19,7 @@ export interface ICustomConfig {
appIcon?: string,
pathToModule?: string,
logging?: boolean,
defaultWindow?: Electron.BrowserWindowOptions,
defaultWindow?: Electron.BrowserWindowConstructorOptions,
defaultStyleContainer?: any,
defaultStyleAppIcon?: any,
defaultStyleImage?: any,
@@ -57,4 +58,4 @@ export function closeAll(): void;
export function getTemplatePath(): string;
export function setTemplatePath(path: string): void;
export function setTemplatePath(path: string): void;
types/electron-notify/package.json
+5
View File
@@ -0,0 +1,5 @@
{
"dependencies": {
"electron": "^1.7.5"
}
}
types/electron-window-state/electron-window-state-tests.ts
+1 -1
View File
@@ -1,6 +1,6 @@
import {app, BrowserWindow} from 'electron';
import { app, BrowserWindow } from 'electron';
import windowStateKeeper = require('electron-window-state');
let win: Electron.BrowserWindow = null;
types/electron-window-state/index.d.ts
Vendored
+1
View File
@@ -2,6 +2,7 @@
// Project: https://github.com/mawie81/electron-window-state
// Definitions by: rhysd <https://github.com/rhysd>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.1
/// <reference types="electron" />
types/electron-window-state/package.json
+5
View File
@@ -0,0 +1,5 @@
{
"dependencies": {
"electron": "^1.7.5"
}
}
types/engine.io-client/engine.io-client-tests.ts
+77
View File
@@ -0,0 +1,77 @@
import engine = require('engine.io');
import client = require('engine.io-client');
let server: engine.Server;
let socket: client.Socket;
let options: client.SocketOptions = {};
options.agent = false;
options.upgrade = true;
options.forceJSONP = false;
options.jsonp = false;
options.forceBase64 = false;
options.enablesXDR = false;
options.timestampRequests = true;
options.timestampParam = 't';
options.policyPort = 843;
options.path = '/engine.io';
options.transports = ['websocket'];
options.transportOptions = {};
options.rememberUpgrade = true;
options.pfx = '';
options.key = '';
options.passphrase = '';
options.cert = '';
options.ca = '';
options.ciphers = undefined;
options.rejectUnauthorized = true;
options.perMessageDeflate = false;
options.extraHeaders = {foo: 'bar'};
options.onlyBinaryUpgrades = true;
options.forceNode = false;
options.localAddress = 'localhost';
socket = client("ws://localhost:32767", options);
socket.on('close', (mes, detail) => {
console.log('CLOSE', mes, detail);
});
socket.on('error', (err) => {
console.log('ERROR', err);
});
server = engine.listen(8000, {pingTimeout: 100, pingInterval: 30});
server.on("connection", socket => {
socket.send('hello');
});
socket = client("ws://localhost:8000");
socket.on("message", (data) => {
console.log('MESSAGE', data);
});
socket.on('close', (mes, detail) => {
console.log('CLOSE', mes, detail);
});
socket.on('ping', () => {
console.log('client ping callback');
});
socket.on('pong', () => {
console.log('client pong callback');
});
socket.on('flush', () => {
console.log('client flush callback');
});
socket.on('drain', () => {
console.log('client drain callback');
});
socket.on("open", () => {
socket.send("hi", {compress: false}, () => {
console.log('client send callback');
setTimeout(() => {
socket.close();
setTimeout(() => {
server.close();
server.httpServer!.close();
}, 200);
}, 200);
});
});
types/engine.io-client/index.d.ts
Vendored
+184
View File
@@ -0,0 +1,184 @@
// Type definitions for engine.io-client 3.1
// Project: https://github.com/socketio/engine.io-client
// Definitions by: KentarouTakeda <https://github.com/KentarouTakeda/>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
/// <reference types="node" />
import http = require('http');
declare namespace client {
type Transport = 'polling'|'websocket';
type Message = string|ArrayBuffer|ArrayBufferView|Blob;
interface MessageOptions {
compress?: boolean;
}
interface SocketOptions {
/**
* http.Agent to use, defaults to false (NodeJS only)
*/
agent?: http.Agent|false;
/**
* defaults to true, whether the client should try to upgrade the transport from long-polling to something better.
*/
upgrade?: boolean;
/**
* forces JSONP for polling transport.
*/
forceJSONP?: boolean;
/**
* determines whether to use JSONP when necessary for polling.
* If disabled (by settings to false) an error will be emitted (saying "No transports available")
* if no other transports are available. If another transport is available
* for opening a connection (e.g. WebSocket) that transport will be used instead.
*/
jsonp?: boolean;
/**
* forces base 64 encoding for polling transport even when XHR2 responseType is available and WebSocket even if the used standard supports binary.
*/
forceBase64?: boolean;
/**
* enables XDomainRequest for IE8 to avoid loading bar flashing with click sound. default to false because XDomainRequest has a flaw of not sending cookie.
*/
enablesXDR?: boolean;
/**
* whether to add the timestamp with each transport request. Note: polling requests are always stamped unless this option is explicitly set to false (false)
*/
timestampRequests?: boolean;
/**
* timestamp parameter (t)
*/
timestampParam?: string;
/**
* port the policy server listens on (843)
*/
policyPort?: number;
/**
* path to connect to, default is /engine.io
*/
path?: string;
/**
* a list of transports to try (in order). Defaults to ['polling', 'websocket']. Engine always attempts to connect directly with the first one, provided the feature detection test for it passes.
*/
transports?: Transport[];
/**
* hash of options, indexed by transport name, overriding the common options for the given transport
*/
transportOptions?: {[key: string]: SocketOptions};
/**
* defaults to false. If true and if the previous websocket connection to the server succeeded,
* the connection attempt will bypass the normal upgrade process and will initially try websocket.
* A connection attempt following a transport error will use the normal upgrade process.
* It is recommended you turn this on only when using SSL/TLS connections,
* or if you know that your network does not block websockets.
*/
rememberUpgrade?: boolean;
/**
* Certificate, Private key and CA certificates to use for SSL. Can be used in Node.js client environment to manually specify certificate information.
*/
pfx?: string;
/**
* Private key to use for SSL. Can be used in Node.js client environment to manually specify certificate information.
*/
key?: string;
/**
* A string of passphrase for the private key or pfx. Can be used in Node.js client environment to manually specify certificate information.
*/
passphrase?: string;
/**
* Public x509 certificate to use. Can be used in Node.js client environment to manually specify certificate information.
*/
cert?: string;
/**
* An authority certificate or array of authority certificates to check the remote host against.
* Can be used in Node.js client environment to manually specify certificate information.
*/
ca?: string|string[];
/**
* A string describing the ciphers to use or exclude. Consult the cipher format list for details on the format.
* Can be used in Node.js client environment to manually specify certificate information.
*/
ciphers?: string;
/**
* If true, the server certificate is verified against the list of supplied CAs.
* An 'error' event is emitted if verification fails. Verification happens at the connection level,
* before the HTTP request is sent. Can be used in Node.js client environment to manually specify certificate information.
*/
rejectUnauthorized?: boolean;
/**
* parameters of the WebSocket permessage-deflate extension (see ws module api docs). Set to false to disable. (true)
*/
perMessageDeflate?: any;
/**
* Headers that will be passed for each request to the server (via xhr-polling and via websockets).
* These values then can be used during handshake or for special proxies. Can only be used in Node.js client environment.
*/
extraHeaders?: {[header: string]: string};
/**
* whether transport upgrades should be restricted to transports supporting binary data (false)
*/
onlyBinaryUpgrades?: boolean;
/**
* Uses NodeJS implementation for websockets - even if there is a native Browser-Websocket available,
* which is preferred by default over the NodeJS implementation. (This is useful when using hybrid platforms
* like nw.js or electron) (false, NodeJS only)
*/
forceNode?: boolean;
/**
* the local IP address to connect to
*/
localAddress?: string;
}
interface UpgradeError extends Error {
transport: string;
}
class Socket {
protocol?: number;
binaryType?: 'arraybuffer'|'blob';
/*
* open: Fired upon successful connection.
* flush: Fired upon completing a buffer flush
* drain: Fired after drain event of transport if writeBuffer is empty
* ping: Fired upon flushing a ping packet (ie: actual packet write out)
* pong: Fired upon receiving a pong packet.
*/
on(ev: 'open'|'flush'|'drain'|'ping'|'pong' , cb: () => void): this;
/*
* Fired when data is received from the server.
*/
on(ev: 'message' , cb: (data: string|ArrayBuffer) => void): this;
/*
* Fired upon disconnection. In compliance with the WebSocket API spec, this event may be fired even if the open event does not occur (i.e. due to connection error or close()).
*/
on(ev: 'close' , cb: (mes: string, detail?: Error) => void): this;
/*
* Fired when an error occurs.
*/
on(ev: 'error' , cb: (err: Error) => void): this;
/*
* Fired if an error occurs with a transport we're trying to upgrade to.
*/
on(ev: 'upgradeError' , cb: (err: UpgradeError) => void): this;
/*
* Fired upon upgrade success, after the new transport is set
*/
on(ev: 'upgrade' , cb: (transport: any) => void): this;
/**
* Sends a message to the server
*/
send(message: Message, opts?: MessageOptions, cb?: () => void): this;
/**
* Disconnects the client.
*/
close(): this;
}
}
declare function client(url?: string, opts?: client.SocketOptions): client.Socket;
export = client;
types/engine.io-client/tsconfig.json
+25
View File
@@ -0,0 +1,25 @@
{
"compilerOptions": {
"module": "commonjs",
"lib": [
"dom",
"es6"
],
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": true,
"noImplicitReturns": true,
"strict": true,
"baseUrl": "../",
"typeRoots": [
"../"
],
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true
},
"files": [
"index.d.ts",
"engine.io-client-tests.ts"
]
}
types/engine.io-client/tslint.json
+1
View File
@@ -0,0 +1 @@
{ "extends": "dtslint/dt.json" }
types/epub/index.d.ts
Vendored
+1 -1
View File
@@ -32,7 +32,7 @@
**/
declare module "epub" {
import {EventEmitter} from "events";
import { EventEmitter } from "events";
interface TocElement {
level: number;
types/ethjs-signer/ethjs-signer-tests.ts
+16
View File
@@ -0,0 +1,16 @@
import { sign, recover } from "ethjs-signer";
const nonce = 0;
const privateKey = '0xecbcd9838f7f2afa6e809df8d7cdae69aa5dfc14d563ee98e97effd3f6a652f2';
const transaction = {
to: '0xce31a19193d4b23f4e9d6163d7247243bAF801c3',
value: 300000,
gasPrice: 2000000,
nonce
};
const signedTransactionString = sign(transaction, privateKey) as string;
const signedTransaction = sign(transaction, privateKey, true) as any[];
const publicKey = recover(signedTransactionString, -1, signedTransaction[7], signedTransaction[8]);
types/ethjs-signer/index.d.ts
Vendored
+18
View File
@@ -0,0 +1,18 @@
// Type definitions for ethjs-signer 0.1
// Project: https://github.com/ethjs/ethjs-signer/
// Definitions by: Bryson Thill <https://github.com/doppio>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.3
/// <reference types="node" />
/**
* Signs a raw transaction and return it either as a serialized hex string or raw tx object.
*/
export function sign(transaction: object, privateKey: string, toObject?: false): string;
export function sign(transaction: object, privateKey: string, toObject: true): any[];
/**
* Recovers a ECDSA public key from a raw transaction.
*/
export function recover(rawTx: string | Buffer, v: number, r: Buffer, s: Buffer): Buffer;
types/ethjs-signer/tsconfig.json
+22
View File
@@ -0,0 +1,22 @@
{
"compilerOptions": {
"module": "commonjs",
"lib": [
"es6"
],
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": true,
"baseUrl": "../",
"typeRoots": [
"../"
],
"types": [ ],
"noEmit": true,
"forceConsistentCasingInFileNames": true
},
"files": [
"index.d.ts",
"ethjs-signer-tests.ts"
]
}
types/ethjs-signer/tslint.json
+3
View File
@@ -0,0 +1,3 @@
{
"extends": "dtslint/dt.json"
}
types/exceljs/index.d.ts
Vendored
+3 -3
View File
@@ -501,17 +501,17 @@ export interface Column {
/**
* Can be a string to set one row high header or an array to set multi-row high header
*/
header: string | string[];
header?: string | string[];
/**
* The name of the properties associated with this column in each row
*/
key: string;
key?: string;
/**
* The width of the column
*/
width: number;
width?: number;
/**
* Set an outline level for columns
types/expect/expect-tests.ts
+1 -1
View File
@@ -1,6 +1,6 @@
/// <reference types="mocha"" />
import {Expectation, Extension, Spy, createSpy, isSpy, assert, spyOn, extend, restoreSpies} from 'expect';
import { Expectation, Extension, Spy, createSpy, isSpy, assert, spyOn, extend, restoreSpies } from 'expect';
import * as expect from 'expect';
describe('chaining assertions', () => {
types/falcor-express/index.d.ts
Vendored
+1 -1
View File
@@ -7,6 +7,6 @@
import {Request, Response, Handler} from 'express';
import { Request, Response, Handler } from 'express';
import {DataSource} from 'falcor';
declare function dataSourceRoute(getDataSource: (req: Request, res: Response) => DataSource): Handler;
types/falcor-http-datasource/falcor-http-datasource-tests.ts
+1 -1
View File
@@ -1,5 +1,5 @@
import HttpDataSource from 'falcor-http-datasource';
import {Model} from 'falcor';
import { Model } from 'falcor';
const model = new Model({
source: new HttpDataSource('/model.json')
types/falcor-json-graph/falcor-json-graph-tests.ts
+1 -1
View File
@@ -1,6 +1,6 @@
import {Key, KeySet, Path, PathSet, ref, atom, error, pathValue, pathInvalidation} from 'falcor-json-graph';
import { Key, KeySet, Path, PathSet, ref, atom, error, pathValue, pathInvalidation } from 'falcor-json-graph';
const stringKey: Key = "productsById";
const numberKey: Key = 10;
types/file-saver/file-saver-tests.ts
+1 -1
View File
@@ -1,6 +1,6 @@
import {saveAs as importedSaveAs} from "file-saver";
import { saveAs as importedSaveAs } from "file-saver";
function testImportedSaveAs() {
var data: Blob = new Blob(["Hello, world!"], {type: "text/plain;charset=utf-8"});
var filename: string = 'hello world.txt';
types/finalhandler/finalhandler-tests.ts
+1 -1
View File
@@ -1,5 +1,5 @@
import {ServerRequest, ServerResponse} from "http";
import { ServerRequest, ServerResponse } from "http";
import * as finalHandler from "finalhandler";
let req: ServerRequest;
types/finalhandler/index.d.ts
Vendored
+1 -1
View File
@@ -5,7 +5,7 @@
/// <reference types="node" />
import {ServerRequest, ServerResponse} from "http";
import { ServerRequest, ServerResponse } from "http";
declare function finalHandler(req: ServerRequest, res: ServerResponse, options?: finalHandler.Options): (err: any) => void;
types/fixed-data-table/fixed-data-table-tests.tsx
+1 -1
View File
@@ -1,5 +1,5 @@
import * as React from "react";
import {Table, Cell, Column, CellProps} from "fixed-data-table";
import { Table, Cell, Column, CellProps } from "fixed-data-table";
// create your Table
class MyTable1 extends React.Component {
types/flat/flat-tests.ts
+1 -1
View File
@@ -1,6 +1,6 @@
import {flatten, unflatten} from "flat";
import { flatten, unflatten } from "flat";
namespace TestFlatten {
let options: {
types/geokdbush/index.d.ts
Vendored
+1 -1
View File
@@ -3,7 +3,7 @@
// Definitions by: Denis Carriere <https://github.com/DenisCarriere>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
import {KDBush} from 'kdbush';
import { KDBush } from 'kdbush';
export function around<T>(
index: KDBush<T>,
types/gl-matrix/gl-matrix-tests.ts
+1 -1
View File
@@ -1,5 +1,5 @@
// common
import {vec2, mat2, mat3, mat4, vec3, vec4, mat2d, quat} from "gl-matrix";
import { vec2, mat2, mat3, mat4, vec3, vec4, mat2d, quat } from "gl-matrix";
var outVal: number;
var outBool: boolean;
types/google-libphonenumber/google-libphonenumber-tests.ts
+1 -1
View File
@@ -1,6 +1,6 @@
import libphonenumber = require('google-libphonenumber');
import {PhoneNumberFormat, PhoneNumberUtil, AsYouTypeFormatter} from 'google-libphonenumber';
import { PhoneNumberFormat, PhoneNumberUtil, AsYouTypeFormatter } from 'google-libphonenumber';
() => {
// Require `PhoneNumberFormat`.
types/graphql-date/graphql-date-tests.ts
+1 -1
View File
@@ -1,4 +1,4 @@
import {GraphQLObjectType} from 'graphql';
import { GraphQLObjectType } from 'graphql';
import * as GraphQLDate from 'graphql-date';
const fooType = new GraphQLObjectType({
types/graphql-date/index.d.ts
Vendored
+1 -1
View File
@@ -3,7 +3,7 @@
// Definitions by: Eric Naeseth <https://github.com/enaeseth>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
import {GraphQLScalarType} from 'graphql';
import { GraphQLScalarType } from 'graphql';
declare const date: GraphQLScalarType;
types/graphql-type-json/graphql-type-json-tests.ts
+1 -1
View File
@@ -1,4 +1,4 @@
import {GraphQLObjectType, GraphQLInputObjectType} from "graphql";
import { GraphQLObjectType, GraphQLInputObjectType } from "graphql";
import * as GraphQLJSON from "graphql-type-json";
const TestType = new GraphQLObjectType({
types/graphql-type-json/index.d.ts
Vendored
+1 -1
View File
@@ -2,7 +2,7 @@
// Project: https://github.com/taion/graphql-type-json#readme
// Definitions by: Pavel Ivanov <https://github.com/schfkt>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
import {GraphQLScalarType} from "graphql";
import { GraphQLScalarType } from "graphql";
declare const GraphQLJSON: GraphQLScalarType;
export = GraphQLJSON;
types/gulp-watch/index.d.ts
Vendored
+1 -1
View File
@@ -5,7 +5,7 @@
/// <reference types="node" />
import {SrcOptions} from "vinyl-fs";
import { SrcOptions } from "vinyl-fs";
interface IOptions extends SrcOptions {
ignoreInitial?: boolean;
types/hapi-auth-jwt2/index.d.ts
Vendored
+1 -1
View File
@@ -2,7 +2,7 @@
// Project: http://github.com/dwyl/hapi-auth-jwt2
// Definitions by: Warren Seymour <http://github.com/warrenseymour>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
import {Request, Response, PluginFunction} from 'hapi';
import { Request, Response, PluginFunction } from 'hapi';
declare namespace hapiAuthJwt2 {
/**
types/hapi/index.d.ts
Vendored
+1 -1
View File
@@ -42,7 +42,7 @@ import {
type JoiValidationObject = JoiSchema | JoiSchemaMap | (JoiSchema | JoiSchemaMap)[];
import * as Catbox from 'catbox';
import {MimosOptions} from 'mimos';
import { MimosOptions } from 'mimos';
import Podium = require('podium');
import * as Shot from 'shot';

Some files were not shown because too many files have changed in this diff Show More