vhad/DefinitelyTyped
1
0
Fork 0
mirror of https://github.com/gosticks/DefinitelyTyped.git synced 2025-10-16 12:05:41 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'upstream/master'

Browse Source
This commit is contained in:
Kei Ito 2019-02-28 15:27:05 +09:00
commit e572afd596
No known key found for this signature in database
GPG Key ID: 375A55DAC33045D5
310 changed files with 7225 additions and 3046 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
notNeededPackages.json
View File

@ -396,6 +396,12 @@
"sourceRepoURL": "https://github.com/date-fns/date-fns",
"asOfVersion": "2.6.0"
},
{
"libraryName": "dd-trace",
"typingsPackageName": "dd-trace",
"sourceRepoURL": "https://github.com/DataDog/dd-trace-js",
"asOfVersion": "0.9.0"
},
{
"libraryName": "decimal.js",
"typingsPackageName": "decimal.js",
@ -414,6 +420,12 @@
"sourceRepoURL": "https://github.com/sindresorhus/delay",
"asOfVersion": "3.1.0"
},
{
"libraryName": "detect-browser",
"typingsPackageName": "detect-browser",
"sourceRepoURL": "https://github.com/DamonOehlman/detect-browser",
"asOfVersion": "4.0.0"
},
{
"libraryName": "DevExtreme",
"typingsPackageName": "devextreme",
@ -730,7 +742,7 @@
"libraryName": "i18next-browser-languagedetector",
"typingsPackageName": "i18next-browser-languagedetector",
"sourceRepoURL": "https://github.com/i18next/i18next-browser-languagedetector",
"asOfVersion": "2.0.2"
"asOfVersion": "3.0.0"
},
{
"libraryName": "i18next-xhr-backend",
@ -768,6 +780,12 @@
"sourceRepoURL": "https://github.com/taye/interact.js",
"asOfVersion": "1.3.0"
},
{
"libraryName": "internal-ip",
"typingsPackageName": "internal-ip",
"sourceRepoURL": "https://github.com/sindresorhus/internal-ip",
"asOfVersion": "4.1.0"
},
{
"libraryName": "inversify",
"typingsPackageName": "inversify",
@ -1122,11 +1140,23 @@
"sourceRepoURL": "http://onsen.io",
"asOfVersion": "2.0.0"
},
{
"libraryName": "p-map",
"typingsPackageName": "p-map",
"sourceRepoURL": "https://github.com/sindresorhus/p-map",
"asOfVersion": "2.0.0"
},
{
"libraryName": "p-pipe",
"typingsPackageName": "p-pipe",
"sourceRepoURL": "https://github.com/sindresorhus/p-pipe",
"asOfVersion": "2.0.1"
},
{
"libraryName": "p-throttle",
"typingsPackageName": "p-throttle",
"sourceRepoURL": "https://github.com/sindresorhus/p-throttle",
"asOfVersion": "2.0.0"
"asOfVersion": "2.1.0"
},
{
"libraryName": "param-case",
@ -1776,6 +1806,12 @@
"sourceRepoURL": "https://github.com/vuejs/vue-router",
"asOfVersion": "2.0.0"
},
{
"libraryName": "wait-for-localhost",
"typingsPackageName": "wait-for-localhost",
"sourceRepoURL": "https://github.com/sindresorhus/wait-for-localhost",
"asOfVersion": "3.1.0"
},
{
"libraryName": "webcola",
"typingsPackageName": "webcola",

5
types/angular-material/index.d.ts vendored
View File

@ -512,5 +512,10 @@ declare module 'angular' {
}
type IStickyService = (scope: IScope, element: JQuery, elementClone?: JQuery) => void;
interface IInteractionService {
getLastInteractionType(): string|null;
isUserInvoked(checkDelay?: number): boolean;
}
}
}

31
types/argparse/argparse-tests.ts
View File

@ -1,6 +1,12 @@
// near copy of each of the tests from https://github.com/nodeca/argparse/tree/master/examples
import { ArgumentParser, RawDescriptionHelpFormatter } from 'argparse';
import {
ArgumentParser,
RawDescriptionHelpFormatter,
Action,
ActionConstructorOptions,
Namespace,
} from 'argparse';
let args: any;
const simpleExample = new ArgumentParser({
@ -276,3 +282,26 @@ group.addArgument(['--bar'], {
help: 'bar help'
});
formatterExample.printHelp();
class CustomAction1 extends Action {
constructor(options: ActionConstructorOptions) {
super(options);
}
call(parser: ArgumentParser, namespace: Namespace, values: string | string[], optionString: string | null) {
console.log('custom action 1');
}
}
class CustomAction2 extends Action {
call(parser: ArgumentParser, namespace: Namespace, values: string | string[], optionString: string | null) {
console.log('custom action 2');
}
}
const customActionExample = new ArgumentParser({ addHelp: false });
customActionExample.addArgument('--abc', {
action: CustomAction1,
});
customActionExample.addArgument('--def', {
action: CustomAction2,
});

14
types/argparse/index.d.ts vendored
View File

@ -3,6 +3,7 @@
// Definitions by: Andrew Schurman <https://github.com/arcticwaters>
// Tomasz Łaziuk <https://github.com/tlaziuk>
// Sebastian Silbermann <https://github.com/eps1lon>
// Kannan Goundan <https://github.com/cakoose>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.2
@ -79,13 +80,24 @@ export interface ArgumentGroupOptions {
description?: string;
}
export abstract class Action {
protected dest: string;
constructor(options: ActionConstructorOptions);
abstract call(parser: ArgumentParser, namespace: Namespace, values: string | string[], optionString: string | null): void;
}
// Passed to the Action constructor. Subclasses are just expected to relay this to
// the super() constructor, so using an "opaque type" pattern is probably fine.
// Someone may want to fill this out in the future.
export type ActionConstructorOptions = number & {_: 'ActionConstructorOptions'};
export class HelpFormatter { }
export class ArgumentDefaultsHelpFormatter { }
export class RawDescriptionHelpFormatter { }
export class RawTextHelpFormatter { }
export interface ArgumentOptions {
action?: string;
action?: string | { new(options: ActionConstructorOptions): Action };
optionStrings?: string[];
dest?: string;
nargs?: string | number;

2
types/argparse/tsconfig.json
View File

@ -21,4 +21,4 @@
"index.d.ts",
"argparse-tests.ts"
]
}
}

6
types/assets-webpack-plugin/assets-webpack-plugin-tests.ts
View File

@ -8,15 +8,21 @@ const config: webpack.Configuration = {
filename: 'assets.json'
}),
new AssetsPlugin({
entrypoints: true,
filename: 'assets.json',
fullPath: false,
fileTypes: ['css'],
includeManifest: true,
includeAllFileTypes: false,
keepInMemory: true,
manifestFirst: true,
path: '/foo/bar',
prettyPrint: true,
processOutput: (assets) => (
'window.assets = ' + JSON.stringify(assets)
),
update: true,
useCompilerPath: true,
metadata: {
meta: 'data'
},

39
types/assets-webpack-plugin/index.d.ts vendored
View File

@ -1,4 +1,4 @@
// Type definitions for assets-webpack-plugin 3.5
// Type definitions for assets-webpack-plugin 3.9
// Project: https://github.com/ztoben/assets-webpack-plugin
// Definitions by: Michael Strobel <https://github.com/kryops>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
@ -16,18 +16,36 @@ declare namespace AssetsWebpackPlugin {
type ProcessOutputFn = (assets: Assets) => string;
interface Options {
/**
* If the "entrypoints" option is given, the output will be limited to the entrypoints and the chunks associated with them.
* false by default
*/
entrypoints?: boolean;
/**
* Name for the created json file.
* "webpack-assets.json" by default
*/
filename?: string;
/**
* When set and "includeAllFileTypes" is set false, only assets matching these types will be included in the assets file.
* ['js', 'css'] by default
*/
fileTypes?: string[];
/**
* If false the output will not include the full path of the generated file.
* true by default
*/
fullPath?: boolean;
/**
* When set false, falls back to the "fileTypes" option array to decide which file types to include in the assets file.
* true by default
*/
includeAllFileTypes?: boolean;
/**
* Inserts the manifest javascript as a text property in your assets.
* Accepts the name of your manifest chunk.
@ -38,6 +56,19 @@ declare namespace AssetsWebpackPlugin {
*/
includeManifest?: boolean;
/**
* When set the assets file will only be generated in memory while running webpack-dev-server and not written to disk.
* false by default
*/
keepInMemory?: boolean;
/**
* Orders the assets output so that manifest is the first entry.
* This is useful for cases where script tags are generated from the assets json output, and order of import is important.
* false by default
*/
manifestFirst?: boolean;
/**
* Inject metadata into the output file. All values will be injected into the key "metadata"
*/
@ -66,6 +97,12 @@ declare namespace AssetsWebpackPlugin {
* false by default
*/
update?: boolean;
/**
* Will override the path to use the compiler output path set in your webpack config.
* false by default
*/
useCompilerPath?: boolean;
}
}

47
types/aws-iot-device-sdk/aws-iot-device-sdk-tests.ts
View File

@ -101,3 +101,50 @@ const thingShadows = new awsIot.thingShadow({
thingShadows.on("timeout", function(thingName: string, clientToken: string) {
});
const jobs = new awsIot.jobs({
keyPath: "",
certPath: "",
caPath: "",
clientId: "",
region: "",
baseReconnectTimeMs: 1000,
protocol: "wss",
port: 443,
host: "",
debug: false
});
jobs.subscribeToJobs("thingname", "operationname", (err, job) => {
console.error("Error", err);
if (err || !job) {
return;
}
console.log("job id", job.id);
console.log("job info", job.document);
console.log("job op", job.operation);
console.log("job status", job.status);
console.log("job status details", job.status.statusDetails);
console.log(
"job status details progress",
job.status.statusDetails.progress
);
job.inProgress({ progress: "1" }, err =>
console.error("Job progress error", err)
);
job.failed({ progress: "2" }, err =>
console.error("Job failed error", err)
);
job.succeeded({ progress: "3" }, err =>
console.error("Job failed error", err)
);
});
jobs.startJobNotifications("thingname", err =>
console.error("Start job notification error", err)
);
jobs.unsubscribeFromJobs("thingname", "operationame", err =>
console.error("Unsubscribe from jobs error", err)
);

114
types/aws-iot-device-sdk/index.d.ts vendored
View File

@ -1,4 +1,4 @@
// Type definitions for aws-iot-device-sdk 2.1.0
// Type definitions for aws-iot-device-sdk 2.2.0
// Project: https://github.com/aws/aws-iot-device-sdk-js
// Definitions by: Markus Olsson <https://github.com/niik>
// Margus Lamp <https://github.com/mlamp>
@ -391,3 +391,115 @@ export class thingShadow extends NodeJS.EventEmitter {
/** Emitted when a different client"s update or delete operation is accepted on the shadow. */
on(event: "foreignStateChange", listener: (thingName: string, operation: "update" | "delete", stateObject: any) => void): this;
}
export interface statusDetails {
progress: string;
}
export interface jobStatus {
status: string;
statusDetails: statusDetails;
}
export interface jobDocument {
[key: string]: any
}
export interface job {
/** Object that contains job execution information and functions for updating job execution status. */
/** Returns the job id. */
id: string;
/**
* The JSON document describing details of the job to be executed eg.
* {
* "operation": "install",
* "otherProperty": "value",
* ...
* }
*/
document: jobDocument;
/**
* Returns the job operation from the job document. Eg. 'install', 'reboot', etc.
*/
operation: string;
/**
* Returns the current job status according to AWS Orchestra.
*/
status: jobStatus;
/**
* Update the status of the job execution to be IN_PROGRESS for the thing associated with the job.
*
* @param statusDetails - optional document describing the status details of the in progress job
* @param callback - function(err) optional callback for when the operation completes, err is null if no error occurred
*/
inProgress(statusDetails?: statusDetails, callback?: (err: Error) => void): void;
/**
* Update the status of the job execution to be FAILED for the thing associated with the job.
*
* @param statusDetails - optional document describing the status details of the in progress job e.g.
* @param callback - function(err) optional callback for when the operation completes, err is null if no error occurred
*/
failed(statusDetails?: statusDetails, callback?: (err: Error) => void): void;
/**
* Update the status of the job execution to be SUCCESS for the thing associated with the job.
*
* @param statusDetails - optional document describing the status details of the in progress job e.g.
* @param callback - function(err) optional callback for when the operation completes, err is null if no error occurred
*/
succeeded(statusDetails?: statusDetails, callback?: (err: Error) => void): void;
}
export class jobs extends device {
/**
* The `jobs` class wraps an instance of the `device` class with additional functionality to
* handle job execution management through the AWS IoT Jobs platform. Arguments in `deviceOptions`
* are the same as those in the device class and the `jobs` class supports all of the
* same events and functions as the `device` class.
*/
constructor(options?: DeviceOptions);
/**
* Subscribes to job execution notifications for the thing named `thingName`. If
* `operationName` is specified then the callback will only be called when a job
* ready for execution contains a property called `operation` in its job document with
* a value matching `operationName`. If `operationName` is omitted then the callback
* will be called for every job ready for execution that does not match another
* `subscribeToJobs` subscription.
*
* @param thingName - name of the Thing to receive job execution notifications
* @param operationName - optionally filter job execution notifications to jobs with a value
* for the `operation` property that matches `operationName
* @param callback - function (err, job) callback for when a job execution is ready for processing or an error occurs
* - `err` a subscription error or an error that occurs when client is disconnecting
* - `job` an object that contains job execution information and functions for updating job execution status.
*/
subscribeToJobs(thingName: string, operationName: string, callback?: (err: Error, job: job) => void): void;
/**
* Causes any existing queued job executions for the given thing to be published
* to the appropriate subscribeToJobs handler. Only needs to be called once per thing.
*
* @param thingName - name of the Thing to cancel job execution notifications for
* @param callback - function (err) callback for when the startJobNotifications operation completes
*/
startJobNotifications(thingName: string, callback: (error: Error) => void): mqtt.Client;
/**
* Unsubscribes from job execution notifications for the thing named `thingName` having
* operations with a value of the given `operationName`. If `operationName` is omitted then
* the default handler for the thing with the given name is unsubscribed.
*
* @param thingName - name of the Thing to cancel job execution notifications for
* @param operationName - optional name of previously subscribed operation names
* @param callback - function (err) callback for when the unsubscribe operation completes
*/
unsubscribeFromJobs(thingName: string, operationName: string, callback: (err: Error) => void): void;
}

6
types/babel-types/babel-types-tests.ts
View File

@ -53,6 +53,12 @@ traverse(ast, {
}
});
// Node type checks
t.isIdentifier(t.identifier("id"));
t.isIdentifier(exp);
t.isIdentifier(null);
t.isIdentifier(undefined);
// TypeScript Types
// TODO: Test all variants of these functions' signatures

928
types/babel-types/index.d.ts vendored
View File

@ -1514,246 +1514,246 @@ export function TSUndefinedKeyword(): TSUndefinedKeyword;
export function TSUnionType(types: TSType[]): TSUnionType;
export function TSVoidKeyword(): TSVoidKeyword;
export function isArrayExpression(node: object, opts?: object): node is ArrayExpression;
export function isAssignmentExpression(node: object, opts?: object): node is AssignmentExpression;
export function isBinaryExpression(node: object, opts?: object): node is BinaryExpression;
export function isDirective(node: object, opts?: object): node is Directive;
export function isDirectiveLiteral(node: object, opts?: object): node is DirectiveLiteral;
export function isBlockStatement(node: object, opts?: object): node is BlockStatement;
export function isBreakStatement(node: object, opts?: object): node is BreakStatement;
export function isCallExpression(node: object, opts?: object): node is CallExpression;
export function isCatchClause(node: object, opts?: object): node is CatchClause;
export function isConditionalExpression(node: object, opts?: object): node is ConditionalExpression;
export function isContinueStatement(node: object, opts?: object): node is ContinueStatement;
export function isDebuggerStatement(node: object, opts?: object): node is DebuggerStatement;
export function isDoWhileStatement(node: object, opts?: object): node is DoWhileStatement;
export function isEmptyStatement(node: object, opts?: object): node is EmptyStatement;
export function isExpressionStatement(node: object, opts?: object): node is ExpressionStatement;
export function isFile(node: object, opts?: object): node is File;
export function isForInStatement(node: object, opts?: object): node is ForInStatement;
export function isForStatement(node: object, opts?: object): node is ForStatement;
export function isFunctionDeclaration(node: object, opts?: object): node is FunctionDeclaration;
export function isFunctionExpression(node: object, opts?: object): node is FunctionExpression;
export function isIdentifier(node: object, opts?: object): node is Identifier;
export function isIfStatement(node: object, opts?: object): node is IfStatement;
export function isLabeledStatement(node: object, opts?: object): node is LabeledStatement;
export function isStringLiteral(node: object, opts?: object): node is StringLiteral;
export function isNumericLiteral(node: object, opts?: object): node is NumericLiteral;
export function isNullLiteral(node: object, opts?: object): node is NullLiteral;
export function isBooleanLiteral(node: object, opts?: object): node is BooleanLiteral;
export function isRegExpLiteral(node: object, opts?: object): node is RegExpLiteral;
export function isLogicalExpression(node: object, opts?: object): node is LogicalExpression;
export function isMemberExpression(node: object, opts?: object): node is MemberExpression;
export function isNewExpression(node: object, opts?: object): node is NewExpression;
export function isProgram(node: object, opts?: object): node is Program;
export function isObjectExpression(node: object, opts?: object): node is ObjectExpression;
export function isObjectMethod(node: object, opts?: object): node is ObjectMethod;
export function isObjectProperty(node: object, opts?: object): node is ObjectProperty;
export function isRestElement(node: object, opts?: object): node is RestElement;
export function isReturnStatement(node: object, opts?: object): node is ReturnStatement;
export function isSequenceExpression(node: object, opts?: object): node is SequenceExpression;
export function isSwitchCase(node: object, opts?: object): node is SwitchCase;
export function isSwitchStatement(node: object, opts?: object): node is SwitchStatement;
export function isThisExpression(node: object, opts?: object): node is ThisExpression;
export function isThrowStatement(node: object, opts?: object): node is ThrowStatement;
export function isTryStatement(node: object, opts?: object): node is TryStatement;
export function isUnaryExpression(node: object, opts?: object): node is UnaryExpression;
export function isUpdateExpression(node: object, opts?: object): node is UpdateExpression;
export function isVariableDeclaration(node: object, opts?: object): node is VariableDeclaration;
export function isVariableDeclarator(node: object, opts?: object): node is VariableDeclarator;
export function isWhileStatement(node: object, opts?: object): node is WhileStatement;
export function isWithStatement(node: object, opts?: object): node is WithStatement;
export function isAssignmentPattern(node: object, opts?: object): node is AssignmentPattern;
export function isArrayPattern(node: object, opts?: object): node is ArrayPattern;
export function isArrowFunctionExpression(node: object, opts?: object): node is ArrowFunctionExpression;
export function isClassBody(node: object, opts?: object): node is ClassBody;
export function isClassDeclaration(node: object, opts?: object): node is ClassDeclaration;
export function isClassExpression(node: object, opts?: object): node is ClassExpression;
export function isExportAllDeclaration(node: object, opts?: object): node is ExportAllDeclaration;
export function isExportDefaultDeclaration(node: object, opts?: object): node is ExportDefaultDeclaration;
export function isExportNamedDeclaration(node: object, opts?: object): node is ExportNamedDeclaration;
export function isExportSpecifier(node: object, opts?: object): node is ExportSpecifier;
export function isForOfStatement(node: object, opts?: object): node is ForOfStatement;
export function isImportDeclaration(node: object, opts?: object): node is ImportDeclaration;
export function isImportDefaultSpecifier(node: object, opts?: object): node is ImportDefaultSpecifier;
export function isImportNamespaceSpecifier(node: object, opts?: object): node is ImportNamespaceSpecifier;
export function isImportSpecifier(node: object, opts?: object): node is ImportSpecifier;
export function isMetaProperty(node: object, opts?: object): node is MetaProperty;
export function isClassMethod(node: object, opts?: object): node is ClassMethod;
export function isObjectPattern(node: object, opts?: object): node is ObjectPattern;
export function isSpreadElement(node: object, opts?: object): node is SpreadElement;
export function isSuper(node: object, opts?: object): node is Super;
export function isTaggedTemplateExpression(node: object, opts?: object): node is TaggedTemplateExpression;
export function isTemplateElement(node: object, opts?: object): node is TemplateElement;
export function isTemplateLiteral(node: object, opts?: object): node is TemplateLiteral;
export function isYieldExpression(node: object, opts?: object): node is YieldExpression;
export function isAnyTypeAnnotation(node: object, opts?: object): node is AnyTypeAnnotation;
export function isArrayTypeAnnotation(node: object, opts?: object): node is ArrayTypeAnnotation;
export function isBooleanTypeAnnotation(node: object, opts?: object): node is BooleanTypeAnnotation;
export function isBooleanLiteralTypeAnnotation(node: object, opts?: object): node is BooleanLiteralTypeAnnotation;
export function isNullLiteralTypeAnnotation(node: object, opts?: object): node is NullLiteralTypeAnnotation;
export function isClassImplements(node: object, opts?: object): node is ClassImplements;
export function isClassProperty(node: object, opts?: object): node is ClassProperty;
export function isDeclareClass(node: object, opts?: object): node is DeclareClass;
export function isDeclareFunction(node: object, opts?: object): node is DeclareFunction;
export function isDeclareInterface(node: object, opts?: object): node is DeclareInterface;
export function isDeclareModule(node: object, opts?: object): node is DeclareModule;
export function isDeclareTypeAlias(node: object, opts?: object): node is DeclareTypeAlias;
export function isDeclareVariable(node: object, opts?: object): node is DeclareVariable;
export function isExistentialTypeParam(node: object, opts?: object): node is ExistentialTypeParam;
export function isFunctionTypeAnnotation(node: object, opts?: object): node is FunctionTypeAnnotation;
export function isFunctionTypeParam(node: object, opts?: object): node is FunctionTypeParam;
export function isGenericTypeAnnotation(node: object, opts?: object): node is GenericTypeAnnotation;
export function isInterfaceExtends(node: object, opts?: object): node is InterfaceExtends;
export function isInterfaceDeclaration(node: object, opts?: object): node is InterfaceDeclaration;
export function isIntersectionTypeAnnotation(node: object, opts?: object): node is IntersectionTypeAnnotation;
export function isMixedTypeAnnotation(node: object, opts?: object): node is MixedTypeAnnotation;
export function isNullableTypeAnnotation(node: object, opts?: object): node is NullableTypeAnnotation;
export function isNumericLiteralTypeAnnotation(node: object, opts?: object): node is NumericLiteralTypeAnnotation;
export function isNumberTypeAnnotation(node: object, opts?: object): node is NumberTypeAnnotation;
export function isStringLiteralTypeAnnotation(node: object, opts?: object): node is StringLiteralTypeAnnotation;
export function isStringTypeAnnotation(node: object, opts?: object): node is StringTypeAnnotation;
export function isThisTypeAnnotation(node: object, opts?: object): node is ThisTypeAnnotation;
export function isTupleTypeAnnotation(node: object, opts?: object): node is TupleTypeAnnotation;
export function isTypeofTypeAnnotation(node: object, opts?: object): node is TypeofTypeAnnotation;
export function isTypeAlias(node: object, opts?: object): node is TypeAlias;
export function isTypeAnnotation(node: object, opts?: object): node is TypeAnnotation;
export function isTypeCastExpression(node: object, opts?: object): node is TypeCastExpression;
export function isTypeParameter(node: object, opts?: object): node is TypeParameter;
export function isTypeParameterDeclaration(node: object, opts?: object): node is TypeParameterDeclaration;
export function isTypeParameterInstantiation(node: object, opts?: object): node is TypeParameterInstantiation;
export function isObjectTypeAnnotation(node: object, opts?: object): node is ObjectTypeAnnotation;
export function isObjectTypeCallProperty(node: object, opts?: object): node is ObjectTypeCallProperty;
export function isObjectTypeIndexer(node: object, opts?: object): node is ObjectTypeIndexer;
export function isObjectTypeProperty(node: object, opts?: object): node is ObjectTypeProperty;
export function isQualifiedTypeIdentifier(node: object, opts?: object): node is QualifiedTypeIdentifier;
export function isUnionTypeAnnotation(node: object, opts?: object): node is UnionTypeAnnotation;
export function isVoidTypeAnnotation(node: object, opts?: object): node is VoidTypeAnnotation;
export function isJSXAttribute(node: object, opts?: object): node is JSXAttribute;
export function isJSXClosingElement(node: object, opts?: object): node is JSXClosingElement;
export function isJSXElement(node: object, opts?: object): node is JSXElement;
export function isJSXEmptyExpression(node: object, opts?: object): node is JSXEmptyExpression;
export function isJSXExpressionContainer(node: object, opts?: object): node is JSXExpressionContainer;
export function isJSXIdentifier(node: object, opts?: object): node is JSXIdentifier;
export function isJSXMemberExpression(node: object, opts?: object): node is JSXMemberExpression;
export function isJSXNamespacedName(node: object, opts?: object): node is JSXNamespacedName;
export function isJSXOpeningElement(node: object, opts?: object): node is JSXOpeningElement;
export function isJSXSpreadAttribute(node: object, opts?: object): node is JSXSpreadAttribute;
export function isJSXText(node: object, opts?: object): node is JSXText;
export function isNoop(node: object, opts?: object): node is Noop;
export function isParenthesizedExpression(node: object, opts?: object): node is ParenthesizedExpression;
export function isAwaitExpression(node: object, opts?: object): node is AwaitExpression;
export function isBindExpression(node: object, opts?: object): node is BindExpression;
export function isDecorator(node: object, opts?: object): node is Decorator;
export function isDoExpression(node: object, opts?: object): node is DoExpression;
export function isExportDefaultSpecifier(node: object, opts?: object): node is ExportDefaultSpecifier;
export function isExportNamespaceSpecifier(node: object, opts?: object): node is ExportNamespaceSpecifier;
export function isRestProperty(node: object, opts?: object): node is RestProperty;
export function isSpreadProperty(node: object, opts?: object): node is SpreadProperty;
export function isExpression(node: object, opts?: object): node is Expression;
export function isBinary(node: object, opts?: object): node is Binary;
export function isScopable(node: object, opts?: object): node is Scopable;
export function isBlockParent(node: object, opts?: object): node is BlockParent;
export function isBlock(node: object, opts?: object): node is Block;
export function isStatement(node: object, opts?: object): node is Statement;
export function isTerminatorless(node: object, opts?: object): node is Terminatorless;
export function isCompletionStatement(node: object, opts?: object): node is CompletionStatement;
export function isConditional(node: object, opts?: object): node is Conditional;
export function isLoop(node: object, opts?: object): node is Loop;
export function isWhile(node: object, opts?: object): node is While;
export function isExpressionWrapper(node: object, opts?: object): node is ExpressionWrapper;
export function isFor(node: object, opts?: object): node is For;
export function isForXStatement(node: object, opts?: object): node is ForXStatement;
export function isArrayExpression(node: object | null | undefined, opts?: object): node is ArrayExpression;
export function isAssignmentExpression(node: object | null | undefined, opts?: object): node is AssignmentExpression;
export function isBinaryExpression(node: object | null | undefined, opts?: object): node is BinaryExpression;
export function isDirective(node: object | null | undefined, opts?: object): node is Directive;
export function isDirectiveLiteral(node: object | null | undefined, opts?: object): node is DirectiveLiteral;
export function isBlockStatement(node: object | null | undefined, opts?: object): node is BlockStatement;
export function isBreakStatement(node: object | null | undefined, opts?: object): node is BreakStatement;
export function isCallExpression(node: object | null | undefined, opts?: object): node is CallExpression;
export function isCatchClause(node: object | null | undefined, opts?: object): node is CatchClause;
export function isConditionalExpression(node: object | null | undefined, opts?: object): node is ConditionalExpression;
export function isContinueStatement(node: object | null | undefined, opts?: object): node is ContinueStatement;
export function isDebuggerStatement(node: object | null | undefined, opts?: object): node is DebuggerStatement;
export function isDoWhileStatement(node: object | null | undefined, opts?: object): node is DoWhileStatement;
export function isEmptyStatement(node: object | null | undefined, opts?: object): node is EmptyStatement;
export function isExpressionStatement(node: object | null | undefined, opts?: object): node is ExpressionStatement;
export function isFile(node: object | null | undefined, opts?: object): node is File;
export function isForInStatement(node: object | null | undefined, opts?: object): node is ForInStatement;
export function isForStatement(node: object | null | undefined, opts?: object): node is ForStatement;
export function isFunctionDeclaration(node: object | null | undefined, opts?: object): node is FunctionDeclaration;
export function isFunctionExpression(node: object | null | undefined, opts?: object): node is FunctionExpression;
export function isIdentifier(node: object | null | undefined, opts?: object): node is Identifier;
export function isIfStatement(node: object | null | undefined, opts?: object): node is IfStatement;
export function isLabeledStatement(node: object | null | undefined, opts?: object): node is LabeledStatement;
export function isStringLiteral(node: object | null | undefined, opts?: object): node is StringLiteral;
export function isNumericLiteral(node: object | null | undefined, opts?: object): node is NumericLiteral;
export function isNullLiteral(node: object | null | undefined, opts?: object): node is NullLiteral;
export function isBooleanLiteral(node: object | null | undefined, opts?: object): node is BooleanLiteral;
export function isRegExpLiteral(node: object | null | undefined, opts?: object): node is RegExpLiteral;
export function isLogicalExpression(node: object | null | undefined, opts?: object): node is LogicalExpression;
export function isMemberExpression(node: object | null | undefined, opts?: object): node is MemberExpression;
export function isNewExpression(node: object | null | undefined, opts?: object): node is NewExpression;
export function isProgram(node: object | null | undefined, opts?: object): node is Program;
export function isObjectExpression(node: object | null | undefined, opts?: object): node is ObjectExpression;
export function isObjectMethod(node: object | null | undefined, opts?: object): node is ObjectMethod;
export function isObjectProperty(node: object | null | undefined, opts?: object): node is ObjectProperty;
export function isRestElement(node: object | null | undefined, opts?: object): node is RestElement;
export function isReturnStatement(node: object | null | undefined, opts?: object): node is ReturnStatement;
export function isSequenceExpression(node: object | null | undefined, opts?: object): node is SequenceExpression;
export function isSwitchCase(node: object | null | undefined, opts?: object): node is SwitchCase;
export function isSwitchStatement(node: object | null | undefined, opts?: object): node is SwitchStatement;
export function isThisExpression(node: object | null | undefined, opts?: object): node is ThisExpression;
export function isThrowStatement(node: object | null | undefined, opts?: object): node is ThrowStatement;
export function isTryStatement(node: object | null | undefined, opts?: object): node is TryStatement;
export function isUnaryExpression(node: object | null | undefined, opts?: object): node is UnaryExpression;
export function isUpdateExpression(node: object | null | undefined, opts?: object): node is UpdateExpression;
export function isVariableDeclaration(node: object | null | undefined, opts?: object): node is VariableDeclaration;
export function isVariableDeclarator(node: object | null | undefined, opts?: object): node is VariableDeclarator;
export function isWhileStatement(node: object | null | undefined, opts?: object): node is WhileStatement;
export function isWithStatement(node: object | null | undefined, opts?: object): node is WithStatement;
export function isAssignmentPattern(node: object | null | undefined, opts?: object): node is AssignmentPattern;
export function isArrayPattern(node: object | null | undefined, opts?: object): node is ArrayPattern;
export function isArrowFunctionExpression(node: object | null | undefined, opts?: object): node is ArrowFunctionExpression;
export function isClassBody(node: object | null | undefined, opts?: object): node is ClassBody;
export function isClassDeclaration(node: object | null | undefined, opts?: object): node is ClassDeclaration;
export function isClassExpression(node: object | null | undefined, opts?: object): node is ClassExpression;
export function isExportAllDeclaration(node: object | null | undefined, opts?: object): node is ExportAllDeclaration;
export function isExportDefaultDeclaration(node: object | null | undefined, opts?: object): node is ExportDefaultDeclaration;
export function isExportNamedDeclaration(node: object | null | undefined, opts?: object): node is ExportNamedDeclaration;
export function isExportSpecifier(node: object | null | undefined, opts?: object): node is ExportSpecifier;
export function isForOfStatement(node: object | null | undefined, opts?: object): node is ForOfStatement;
export function isImportDeclaration(node: object | null | undefined, opts?: object): node is ImportDeclaration;
export function isImportDefaultSpecifier(node: object | null | undefined, opts?: object): node is ImportDefaultSpecifier;
export function isImportNamespaceSpecifier(node: object | null | undefined, opts?: object): node is ImportNamespaceSpecifier;
export function isImportSpecifier(node: object | null | undefined, opts?: object): node is ImportSpecifier;
export function isMetaProperty(node: object | null | undefined, opts?: object): node is MetaProperty;
export function isClassMethod(node: object | null | undefined, opts?: object): node is ClassMethod;
export function isObjectPattern(node: object | null | undefined, opts?: object): node is ObjectPattern;
export function isSpreadElement(node: object | null | undefined, opts?: object): node is SpreadElement;
export function isSuper(node: object | null | undefined, opts?: object): node is Super;
export function isTaggedTemplateExpression(node: object | null | undefined, opts?: object): node is TaggedTemplateExpression;
export function isTemplateElement(node: object | null | undefined, opts?: object): node is TemplateElement;
export function isTemplateLiteral(node: object | null | undefined, opts?: object): node is TemplateLiteral;
export function isYieldExpression(node: object | null | undefined, opts?: object): node is YieldExpression;
export function isAnyTypeAnnotation(node: object | null | undefined, opts?: object): node is AnyTypeAnnotation;
export function isArrayTypeAnnotation(node: object | null | undefined, opts?: object): node is ArrayTypeAnnotation;
export function isBooleanTypeAnnotation(node: object | null | undefined, opts?: object): node is BooleanTypeAnnotation;
export function isBooleanLiteralTypeAnnotation(node: object | null | undefined, opts?: object): node is BooleanLiteralTypeAnnotation;
export function isNullLiteralTypeAnnotation(node: object | null | undefined, opts?: object): node is NullLiteralTypeAnnotation;
export function isClassImplements(node: object | null | undefined, opts?: object): node is ClassImplements;
export function isClassProperty(node: object | null | undefined, opts?: object): node is ClassProperty;
export function isDeclareClass(node: object | null | undefined, opts?: object): node is DeclareClass;
export function isDeclareFunction(node: object | null | undefined, opts?: object): node is DeclareFunction;
export function isDeclareInterface(node: object | null | undefined, opts?: object): node is DeclareInterface;
export function isDeclareModule(node: object | null | undefined, opts?: object): node is DeclareModule;
export function isDeclareTypeAlias(node: object | null | undefined, opts?: object): node is DeclareTypeAlias;
export function isDeclareVariable(node: object | null | undefined, opts?: object): node is DeclareVariable;
export function isExistentialTypeParam(node: object | null | undefined, opts?: object): node is ExistentialTypeParam;
export function isFunctionTypeAnnotation(node: object | null | undefined, opts?: object): node is FunctionTypeAnnotation;
export function isFunctionTypeParam(node: object | null | undefined, opts?: object): node is FunctionTypeParam;
export function isGenericTypeAnnotation(node: object | null | undefined, opts?: object): node is GenericTypeAnnotation;
export function isInterfaceExtends(node: object | null | undefined, opts?: object): node is InterfaceExtends;
export function isInterfaceDeclaration(node: object | null | undefined, opts?: object): node is InterfaceDeclaration;
export function isIntersectionTypeAnnotation(node: object | null | undefined, opts?: object): node is IntersectionTypeAnnotation;
export function isMixedTypeAnnotation(node: object | null | undefined, opts?: object): node is MixedTypeAnnotation;
export function isNullableTypeAnnotation(node: object | null | undefined, opts?: object): node is NullableTypeAnnotation;
export function isNumericLiteralTypeAnnotation(node: object | null | undefined, opts?: object): node is NumericLiteralTypeAnnotation;
export function isNumberTypeAnnotation(node: object | null | undefined, opts?: object): node is NumberTypeAnnotation;
export function isStringLiteralTypeAnnotation(node: object | null | undefined, opts?: object): node is StringLiteralTypeAnnotation;
export function isStringTypeAnnotation(node: object | null | undefined, opts?: object): node is StringTypeAnnotation;
export function isThisTypeAnnotation(node: object | null | undefined, opts?: object): node is ThisTypeAnnotation;
export function isTupleTypeAnnotation(node: object | null | undefined, opts?: object): node is TupleTypeAnnotation;
export function isTypeofTypeAnnotation(node: object | null | undefined, opts?: object): node is TypeofTypeAnnotation;
export function isTypeAlias(node: object | null | undefined, opts?: object): node is TypeAlias;
export function isTypeAnnotation(node: object | null | undefined, opts?: object): node is TypeAnnotation;
export function isTypeCastExpression(node: object | null | undefined, opts?: object): node is TypeCastExpression;
export function isTypeParameter(node: object | null | undefined, opts?: object): node is TypeParameter;
export function isTypeParameterDeclaration(node: object | null | undefined, opts?: object): node is TypeParameterDeclaration;
export function isTypeParameterInstantiation(node: object | null | undefined, opts?: object): node is TypeParameterInstantiation;
export function isObjectTypeAnnotation(node: object | null | undefined, opts?: object): node is ObjectTypeAnnotation;
export function isObjectTypeCallProperty(node: object | null | undefined, opts?: object): node is ObjectTypeCallProperty;
export function isObjectTypeIndexer(node: object | null | undefined, opts?: object): node is ObjectTypeIndexer;
export function isObjectTypeProperty(node: object | null | undefined, opts?: object): node is ObjectTypeProperty;
export function isQualifiedTypeIdentifier(node: object | null | undefined, opts?: object): node is QualifiedTypeIdentifier;
export function isUnionTypeAnnotation(node: object | null | undefined, opts?: object): node is UnionTypeAnnotation;
export function isVoidTypeAnnotation(node: object | null | undefined, opts?: object): node is VoidTypeAnnotation;
export function isJSXAttribute(node: object | null | undefined, opts?: object): node is JSXAttribute;
export function isJSXClosingElement(node: object | null | undefined, opts?: object): node is JSXClosingElement;
export function isJSXElement(node: object | null | undefined, opts?: object): node is JSXElement;
export function isJSXEmptyExpression(node: object | null | undefined, opts?: object): node is JSXEmptyExpression;
export function isJSXExpressionContainer(node: object | null | undefined, opts?: object): node is JSXExpressionContainer;
export function isJSXIdentifier(node: object | null | undefined, opts?: object): node is JSXIdentifier;
export function isJSXMemberExpression(node: object | null | undefined, opts?: object): node is JSXMemberExpression;
export function isJSXNamespacedName(node: object | null | undefined, opts?: object): node is JSXNamespacedName;
export function isJSXOpeningElement(node: object | null | undefined, opts?: object): node is JSXOpeningElement;
export function isJSXSpreadAttribute(node: object | null | undefined, opts?: object): node is JSXSpreadAttribute;
export function isJSXText(node: object | null | undefined, opts?: object): node is JSXText;
export function isNoop(node: object | null | undefined, opts?: object): node is Noop;
export function isParenthesizedExpression(node: object | null | undefined, opts?: object): node is ParenthesizedExpression;
export function isAwaitExpression(node: object | null | undefined, opts?: object): node is AwaitExpression;
export function isBindExpression(node: object | null | undefined, opts?: object): node is BindExpression;
export function isDecorator(node: object | null | undefined, opts?: object): node is Decorator;
export function isDoExpression(node: object | null | undefined, opts?: object): node is DoExpression;
export function isExportDefaultSpecifier(node: object | null | undefined, opts?: object): node is ExportDefaultSpecifier;
export function isExportNamespaceSpecifier(node: object | null | undefined, opts?: object): node is ExportNamespaceSpecifier;
export function isRestProperty(node: object | null | undefined, opts?: object): node is RestProperty;
export function isSpreadProperty(node: object | null | undefined, opts?: object): node is SpreadProperty;
export function isExpression(node: object | null | undefined, opts?: object): node is Expression;
export function isBinary(node: object | null | undefined, opts?: object): node is Binary;
export function isScopable(node: object | null | undefined, opts?: object): node is Scopable;
export function isBlockParent(node: object | null | undefined, opts?: object): node is BlockParent;
export function isBlock(node: object | null | undefined, opts?: object): node is Block;
export function isStatement(node: object | null | undefined, opts?: object): node is Statement;
export function isTerminatorless(node: object | null | undefined, opts?: object): node is Terminatorless;
export function isCompletionStatement(node: object | null | undefined, opts?: object): node is CompletionStatement;
export function isConditional(node: object | null | undefined, opts?: object): node is Conditional;
export function isLoop(node: object | null | undefined, opts?: object): node is Loop;
export function isWhile(node: object | null | undefined, opts?: object): node is While;
export function isExpressionWrapper(node: object | null | undefined, opts?: object): node is ExpressionWrapper;
export function isFor(node: object | null | undefined, opts?: object): node is For;
export function isForXStatement(node: object | null | undefined, opts?: object): node is ForXStatement;
// tslint:disable-next-line ban-types
export function isFunction(node: object, opts?: object): node is Function;
export function isFunctionParent(node: object, opts?: object): node is FunctionParent;
export function isPureish(node: object, opts?: object): node is Pureish;
export function isDeclaration(node: object, opts?: object): node is Declaration;
export function isLVal(node: object, opts?: object): node is LVal;
export function isLiteral(node: object, opts?: object): node is Literal;
export function isImmutable(node: object, opts?: object): node is Immutable;
export function isUserWhitespacable(node: object, opts?: object): node is UserWhitespacable;
export function isMethod(node: object, opts?: object): node is Method;
export function isObjectMember(node: object, opts?: object): node is ObjectMember;
export function isProperty(node: object, opts?: object): node is Property;
export function isUnaryLike(node: object, opts?: object): node is UnaryLike;
export function isPattern(node: object, opts?: object): node is Pattern;
export function isClass(node: object, opts?: object): node is Class;
export function isModuleDeclaration(node: object, opts?: object): node is ModuleDeclaration;
export function isExportDeclaration(node: object, opts?: object): node is ExportDeclaration;
export function isModuleSpecifier(node: object, opts?: object): node is ModuleSpecifier;
export function isFlow(node: object, opts?: object): node is Flow;
export function isFlowBaseAnnotation(node: object, opts?: object): node is FlowBaseAnnotation;
export function isFlowDeclaration(node: object, opts?: object): node is FlowDeclaration;
export function isJSX(node: object, opts?: object): node is JSX;
export function isNumberLiteral(node: object, opts?: object): node is NumericLiteral;
export function isRegexLiteral(node: object, opts?: object): node is RegExpLiteral;
export function isFunction(node: object | null | undefined, opts?: object): node is Function;
export function isFunctionParent(node: object | null | undefined, opts?: object): node is FunctionParent;
export function isPureish(node: object | null | undefined, opts?: object): node is Pureish;
export function isDeclaration(node: object | null | undefined, opts?: object): node is Declaration;
export function isLVal(node: object | null | undefined, opts?: object): node is LVal;
export function isLiteral(node: object | null | undefined, opts?: object): node is Literal;
export function isImmutable(node: object | null | undefined, opts?: object): node is Immutable;
export function isUserWhitespacable(node: object | null | undefined, opts?: object): node is UserWhitespacable;
export function isMethod(node: object | null | undefined, opts?: object): node is Method;
export function isObjectMember(node: object | null | undefined, opts?: object): node is ObjectMember;
export function isProperty(node: object | null | undefined, opts?: object): node is Property;
export function isUnaryLike(node: object | null | undefined, opts?: object): node is UnaryLike;
export function isPattern(node: object | null | undefined, opts?: object): node is Pattern;
export function isClass(node: object | null | undefined, opts?: object): node is Class;
export function isModuleDeclaration(node: object | null | undefined, opts?: object): node is ModuleDeclaration;
export function isExportDeclaration(node: object | null | undefined, opts?: object): node is ExportDeclaration;
export function isModuleSpecifier(node: object | null | undefined, opts?: object): node is ModuleSpecifier;
export function isFlow(node: object | null | undefined, opts?: object): node is Flow;
export function isFlowBaseAnnotation(node: object | null | undefined, opts?: object): node is FlowBaseAnnotation;
export function isFlowDeclaration(node: object | null | undefined, opts?: object): node is FlowDeclaration;
export function isJSX(node: object | null | undefined, opts?: object): node is JSX;
export function isNumberLiteral(node: object | null | undefined, opts?: object): node is NumericLiteral;
export function isRegexLiteral(node: object | null | undefined, opts?: object): node is RegExpLiteral;
export function isReferencedIdentifier(node: object, opts?: object): node is Identifier | JSXIdentifier;
export function isReferencedMemberExpression(node: object, opts?: object): node is MemberExpression;
export function isBindingIdentifier(node: object, opts?: object): node is Identifier;
export function isScope(node: object, opts?: object): node is Scopable;
export function isReferenced(node: object, opts?: object): boolean;
export function isBlockScoped(node: object, opts?: object): node is FunctionDeclaration | ClassDeclaration | VariableDeclaration;
export function isVar(node: object, opts?: object): node is VariableDeclaration;
export function isUser(node: object, opts?: object): boolean;
export function isGenerated(node: object, opts?: object): boolean;
export function isPure(node: object, opts?: object): boolean;
export function isReferencedIdentifier(node: object | null | undefined, opts?: object): node is Identifier | JSXIdentifier;
export function isReferencedMemberExpression(node: object | null | undefined, opts?: object): node is MemberExpression;
export function isBindingIdentifier(node: object | null | undefined, opts?: object): node is Identifier;
export function isScope(node: object | null | undefined, opts?: object): node is Scopable;
export function isReferenced(node: object | null | undefined, opts?: object): boolean;
export function isBlockScoped(node: object | null | undefined, opts?: object): node is FunctionDeclaration | ClassDeclaration | VariableDeclaration;
export function isVar(node: object | null | undefined, opts?: object): node is VariableDeclaration;
export function isUser(node: object | null | undefined, opts?: object): boolean;
export function isGenerated(node: object | null | undefined, opts?: object): boolean;
export function isPure(node: object | null | undefined, opts?: object): boolean;
export function isTSAnyKeyword(node: object, opts?: object): node is TSAnyKeyword;
export function isTSArrayType(node: object, opts?: object): node is TSArrayType;
export function isTSAsExpression(node: object, opts?: object): node is TSAsExpression;
export function isTSBooleanKeyword(node: object, opts?: object): node is TSBooleanKeyword;
export function isTSCallSignatureDeclaration(node: object, opts?: object): node is TSCallSignatureDeclaration;
export function isTSConstructSignatureDeclaration(node: object, opts?: object): node is TSTypeElement;
export function isTSConstructorType(node: object, opts?: object): node is TSConstructorType;
export function isTSDeclareFunction(node: object, opts?: object): node is TSDeclareFunction;
export function isTSDeclareMethod(node: object, opts?: object): node is TSDeclareMethod;
export function isTSEnumDeclaration(node: object, opts?: object): node is TSEnumDeclaration;
export function isTSEnumMember(node: object, opts?: object): node is TSEnumMember;
export function isTSExportAssignment(node: object, opts?: object): node is TSExportAssignment;
export function isTSExpressionWithTypeArguments(node: object, opts?: object): node is TSExpressionWithTypeArguments;
export function isTSExternalModuleReference(node: object, opts?: object): node is TSExternalModuleReference;
export function isTSFunctionType(node: object, opts?: object): node is TSFunctionType;
export function isTSImportEqualsDeclaration(node: object, opts?: object): node is TSImportEqualsDeclaration;
export function isTSIndexSignature(node: object, opts?: object): node is TSIndexSignature;
export function isTSIndexedAccessType(node: object, opts?: object): node is TSIndexedAccessType;
export function isTSInterfaceBody(node: object, opts?: object): node is TSInterfaceBody;
export function isTSInterfaceDeclaration(node: object, opts?: object): node is TSInterfaceDeclaration;
export function isTSIntersectionType(node: object, opts?: object): node is TSIntersectionType;
export function isTSLiteralType(node: object, opts?: object): node is TSLiteralType;
export function isTSMappedType(node: object, opts?: object): node is TSMappedType;
export function isTSMethodSignature(node: object, opts?: object): node is TSMethodSignature;
export function isTSModuleBlock(node: object, opts?: object): node is TSModuleBlock;
export function isTSModuleDeclaration(node: object, opts?: object): node is TSModuleDeclaration;
export function isTSNamespaceExportDeclaration(node: object, opts?: object): node is TSNamespaceExportDeclaration;
export function isTSNeverKeyword(node: object, opts?: object): node is TSNeverKeyword;
export function isTSNonNullExpression(node: object, opts?: object): node is TSNonNullExpression;
export function isTSNullKeyword(node: object, opts?: object): node is TSNullKeyword;
export function isTSNumberKeyword(node: object, opts?: object): node is TSNumberKeyword;
export function isTSObjectKeyword(node: object, opts?: object): node is TSObjectKeyword;
export function isTSParameterProperty(node: object, opts?: object): node is TSParameterProperty;
export function isTSParenthesizedType(node: object, opts?: object): node is TSParenthesizedType;
export function isTSPropertySignature(node: object, opts?: object): node is TSPropertySignature;
export function isTSQualifiedName(node: object, opts?: object): node is TSQualifiedName;
export function isTSStringKeyword(node: object, opts?: object): node is TSStringKeyword;
export function isTSSymbolKeyword(node: object, opts?: object): node is TSSymbolKeyword;
export function isTSThisType(node: object, opts?: object): node is TSThisType;
export function isTSTupleType(node: object, opts?: object): node is TSTupleType;
export function isTSTypeAliasDeclaration(node: object, opts?: object): node is TSTypeAliasDeclaration;
export function isTSTypeAnnotation(node: object, opts?: object): node is TSTypeAnnotation;
export function isTSTypeAssertion(node: object, opts?: object): node is TSTypeAssertion;
export function isTSTypeLiteral(node: object, opts?: object): node is TSTypeLiteral;
export function isTSTypeOperator(node: object, opts?: object): node is TSTypeOperator;
export function isTSTypeParameter(node: object, opts?: object): node is TSTypeParameter;
export function isTSTypeParameterDeclaration(node: object, opts?: object): node is TSTypeParameterDeclaration;
export function isTSTypeParameterInstantiation(node: object, opts?: object): node is TSTypeParameterInstantiation;
export function isTSTypePredicate(node: object, opts?: object): node is TSTypePredicate;
export function isTSTypeQuery(node: object, opts?: object): node is TSTypeQuery;
export function isTSTypeReference(node: object, opts?: object): node is TSTypeReference;
export function isTSUndefinedKeyword(node: object, opts?: object): node is TSUndefinedKeyword;
export function isTSUnionType(node: object, opts?: object): node is TSUnionType;
export function isTSVoidKeyword(node: object, opts?: object): node is TSVoidKeyword;
export function isTSAnyKeyword(node: object | null | undefined, opts?: object): node is TSAnyKeyword;
export function isTSArrayType(node: object | null | undefined, opts?: object): node is TSArrayType;
export function isTSAsExpression(node: object | null | undefined, opts?: object): node is TSAsExpression;
export function isTSBooleanKeyword(node: object | null | undefined, opts?: object): node is TSBooleanKeyword;
export function isTSCallSignatureDeclaration(node: object | null | undefined, opts?: object): node is TSCallSignatureDeclaration;
export function isTSConstructSignatureDeclaration(node: object | null | undefined, opts?: object): node is TSTypeElement;
export function isTSConstructorType(node: object | null | undefined, opts?: object): node is TSConstructorType;
export function isTSDeclareFunction(node: object | null | undefined, opts?: object): node is TSDeclareFunction;
export function isTSDeclareMethod(node: object | null | undefined, opts?: object): node is TSDeclareMethod;
export function isTSEnumDeclaration(node: object | null | undefined, opts?: object): node is TSEnumDeclaration;
export function isTSEnumMember(node: object | null | undefined, opts?: object): node is TSEnumMember;
export function isTSExportAssignment(node: object | null | undefined, opts?: object): node is TSExportAssignment;
export function isTSExpressionWithTypeArguments(node: object | null | undefined, opts?: object): node is TSExpressionWithTypeArguments;
export function isTSExternalModuleReference(node: object | null | undefined, opts?: object): node is TSExternalModuleReference;
export function isTSFunctionType(node: object | null | undefined, opts?: object): node is TSFunctionType;
export function isTSImportEqualsDeclaration(node: object | null | undefined, opts?: object): node is TSImportEqualsDeclaration;
export function isTSIndexSignature(node: object | null | undefined, opts?: object): node is TSIndexSignature;
export function isTSIndexedAccessType(node: object | null | undefined, opts?: object): node is TSIndexedAccessType;
export function isTSInterfaceBody(node: object | null | undefined, opts?: object): node is TSInterfaceBody;
export function isTSInterfaceDeclaration(node: object | null | undefined, opts?: object): node is TSInterfaceDeclaration;
export function isTSIntersectionType(node: object | null | undefined, opts?: object): node is TSIntersectionType;
export function isTSLiteralType(node: object | null | undefined, opts?: object): node is TSLiteralType;
export function isTSMappedType(node: object | null | undefined, opts?: object): node is TSMappedType;
export function isTSMethodSignature(node: object | null | undefined, opts?: object): node is TSMethodSignature;
export function isTSModuleBlock(node: object | null | undefined, opts?: object): node is TSModuleBlock;
export function isTSModuleDeclaration(node: object | null | undefined, opts?: object): node is TSModuleDeclaration;
export function isTSNamespaceExportDeclaration(node: object | null | undefined, opts?: object): node is TSNamespaceExportDeclaration;
export function isTSNeverKeyword(node: object | null | undefined, opts?: object): node is TSNeverKeyword;
export function isTSNonNullExpression(node: object | null | undefined, opts?: object): node is TSNonNullExpression;
export function isTSNullKeyword(node: object | null | undefined, opts?: object): node is TSNullKeyword;
export function isTSNumberKeyword(node: object | null | undefined, opts?: object): node is TSNumberKeyword;
export function isTSObjectKeyword(node: object | null | undefined, opts?: object): node is TSObjectKeyword;
export function isTSParameterProperty(node: object | null | undefined, opts?: object): node is TSParameterProperty;
export function isTSParenthesizedType(node: object | null | undefined, opts?: object): node is TSParenthesizedType;
export function isTSPropertySignature(node: object | null | undefined, opts?: object): node is TSPropertySignature;
export function isTSQualifiedName(node: object | null | undefined, opts?: object): node is TSQualifiedName;
export function isTSStringKeyword(node: object | null | undefined, opts?: object): node is TSStringKeyword;
export function isTSSymbolKeyword(node: object | null | undefined, opts?: object): node is TSSymbolKeyword;
export function isTSThisType(node: object | null | undefined, opts?: object): node is TSThisType;
export function isTSTupleType(node: object | null | undefined, opts?: object): node is TSTupleType;
export function isTSTypeAliasDeclaration(node: object | null | undefined, opts?: object): node is TSTypeAliasDeclaration;
export function isTSTypeAnnotation(node: object | null | undefined, opts?: object): node is TSTypeAnnotation;
export function isTSTypeAssertion(node: object | null | undefined, opts?: object): node is TSTypeAssertion;
export function isTSTypeLiteral(node: object | null | undefined, opts?: object): node is TSTypeLiteral;
export function isTSTypeOperator(node: object | null | undefined, opts?: object): node is TSTypeOperator;
export function isTSTypeParameter(node: object | null | undefined, opts?: object): node is TSTypeParameter;
export function isTSTypeParameterDeclaration(node: object | null | undefined, opts?: object): node is TSTypeParameterDeclaration;
export function isTSTypeParameterInstantiation(node: object | null | undefined, opts?: object): node is TSTypeParameterInstantiation;
export function isTSTypePredicate(node: object | null | undefined, opts?: object): node is TSTypePredicate;
export function isTSTypeQuery(node: object | null | undefined, opts?: object): node is TSTypeQuery;
export function isTSTypeReference(node: object | null | undefined, opts?: object): node is TSTypeReference;
export function isTSUndefinedKeyword(node: object | null | undefined, opts?: object): node is TSUndefinedKeyword;
export function isTSUnionType(node: object | null | undefined, opts?: object): node is TSUnionType;
export function isTSVoidKeyword(node: object | null | undefined, opts?: object): node is TSVoidKeyword;
// React specific
export interface ReactHelpers {
@ -1762,231 +1762,231 @@ export interface ReactHelpers {
}
export const react: ReactHelpers;
export function assertArrayExpression(node: object, opts?: object): void;
export function assertAssignmentExpression(node: object, opts?: object): void;
export function assertBinaryExpression(node: object, opts?: object): void;
export function assertDirective(node: object, opts?: object): void;
export function assertDirectiveLiteral(node: object, opts?: object): void;
export function assertBlockStatement(node: object, opts?: object): void;
export function assertBreakStatement(node: object, opts?: object): void;
export function assertCallExpression(node: object, opts?: object): void;
export function assertCatchClause(node: object, opts?: object): void;
export function assertConditionalExpression(node: object, opts?: object): void;
export function assertContinueStatement(node: object, opts?: object): void;
export function assertDebuggerStatement(node: object, opts?: object): void;
export function assertDoWhileStatement(node: object, opts?: object): void;
export function assertEmptyStatement(node: object, opts?: object): void;
export function assertExpressionStatement(node: object, opts?: object): void;
export function assertFile(node: object, opts?: object): void;
export function assertForInStatement(node: object, opts?: object): void;
export function assertForStatement(node: object, opts?: object): void;
export function assertFunctionDeclaration(node: object, opts?: object): void;
export function assertFunctionExpression(node: object, opts?: object): void;
export function assertIdentifier(node: object, opts?: object): void;
export function assertIfStatement(node: object, opts?: object): void;
export function assertLabeledStatement(node: object, opts?: object): void;
export function assertStringLiteral(node: object, opts?: object): void;
export function assertNumericLiteral(node: object, opts?: object): void;
export function assertNullLiteral(node: object, opts?: object): void;
export function assertBooleanLiteral(node: object, opts?: object): void;
export function assertRegExpLiteral(node: object, opts?: object): void;
export function assertLogicalExpression(node: object, opts?: object): void;
export function assertMemberExpression(node: object, opts?: object): void;
export function assertNewExpression(node: object, opts?: object): void;
export function assertProgram(node: object, opts?: object): void;
export function assertObjectExpression(node: object, opts?: object): void;
export function assertObjectMethod(node: object, opts?: object): void;
export function assertObjectProperty(node: object, opts?: object): void;
export function assertRestElement(node: object, opts?: object): void;
export function assertReturnStatement(node: object, opts?: object): void;
export function assertSequenceExpression(node: object, opts?: object): void;
export function assertSwitchCase(node: object, opts?: object): void;
export function assertSwitchStatement(node: object, opts?: object): void;
export function assertThisExpression(node: object, opts?: object): void;
export function assertThrowStatement(node: object, opts?: object): void;
export function assertTryStatement(node: object, opts?: object): void;
export function assertUnaryExpression(node: object, opts?: object): void;
export function assertUpdateExpression(node: object, opts?: object): void;
export function assertVariableDeclaration(node: object, opts?: object): void;
export function assertVariableDeclarator(node: object, opts?: object): void;
export function assertWhileStatement(node: object, opts?: object): void;
export function assertWithStatement(node: object, opts?: object): void;
export function assertAssignmentPattern(node: object, opts?: object): void;
export function assertArrayPattern(node: object, opts?: object): void;
export function assertArrowFunctionExpression(node: object, opts?: object): void;
export function assertClassBody(node: object, opts?: object): void;
export function assertClassDeclaration(node: object, opts?: object): void;
export function assertClassExpression(node: object, opts?: object): void;
export function assertExportAllDeclaration(node: object, opts?: object): void;
export function assertExportDefaultDeclaration(node: object, opts?: object): void;
export function assertExportNamedDeclaration(node: object, opts?: object): void;
export function assertExportSpecifier(node: object, opts?: object): void;
export function assertForOfStatement(node: object, opts?: object): void;
export function assertImportDeclaration(node: object, opts?: object): void;
export function assertImportDefaultSpecifier(node: object, opts?: object): void;
export function assertImportNamespaceSpecifier(node: object, opts?: object): void;
export function assertImportSpecifier(node: object, opts?: object): void;
export function assertMetaProperty(node: object, opts?: object): void;
export function assertClassMethod(node: object, opts?: object): void;
export function assertObjectPattern(node: object, opts?: object): void;
export function assertSpreadElement(node: object, opts?: object): void;
export function assertSuper(node: object, opts?: object): void;
export function assertTaggedTemplateExpression(node: object, opts?: object): void;
export function assertTemplateElement(node: object, opts?: object): void;
export function assertTemplateLiteral(node: object, opts?: object): void;
export function assertYieldExpression(node: object, opts?: object): void;
export function assertAnyTypeAnnotation(node: object, opts?: object): void;
export function assertArrayTypeAnnotation(node: object, opts?: object): void;
export function assertBooleanTypeAnnotation(node: object, opts?: object): void;
export function assertBooleanLiteralTypeAnnotation(node: object, opts?: object): void;
export function assertNullLiteralTypeAnnotation(node: object, opts?: object): void;
export function assertClassImplements(node: object, opts?: object): void;
export function assertClassProperty(node: object, opts?: object): void;
export function assertDeclareClass(node: object, opts?: object): void;
export function assertDeclareFunction(node: object, opts?: object): void;
export function assertDeclareInterface(node: object, opts?: object): void;
export function assertDeclareModule(node: object, opts?: object): void;
export function assertDeclareTypeAlias(node: object, opts?: object): void;
export function assertDeclareVariable(node: object, opts?: object): void;
export function assertExistentialTypeParam(node: object, opts?: object): void;
export function assertFunctionTypeAnnotation(node: object, opts?: object): void;
export function assertFunctionTypeParam(node: object, opts?: object): void;
export function assertGenericTypeAnnotation(node: object, opts?: object): void;
export function assertInterfaceExtends(node: object, opts?: object): void;
export function assertInterfaceDeclaration(node: object, opts?: object): void;
export function assertIntersectionTypeAnnotation(node: object, opts?: object): void;
export function assertMixedTypeAnnotation(node: object, opts?: object): void;
export function assertNullableTypeAnnotation(node: object, opts?: object): void;
export function assertNumericLiteralTypeAnnotation(node: object, opts?: object): void;
export function assertNumberTypeAnnotation(node: object, opts?: object): void;
export function assertStringLiteralTypeAnnotation(node: object, opts?: object): void;
export function assertStringTypeAnnotation(node: object, opts?: object): void;
export function assertThisTypeAnnotation(node: object, opts?: object): void;
export function assertTupleTypeAnnotation(node: object, opts?: object): void;
export function assertTypeofTypeAnnotation(node: object, opts?: object): void;
export function assertTypeAlias(node: object, opts?: object): void;
export function assertTypeAnnotation(node: object, opts?: object): void;
export function assertTypeCastExpression(node: object, opts?: object): void;
export function assertTypeParameter(node: object, opts?: object): void;
export function assertTypeParameterDeclaration(node: object, opts?: object): void;
export function assertTypeParameterInstantiation(node: object, opts?: object): void;
export function assertObjectTypeAnnotation(node: object, opts?: object): void;
export function assertObjectTypeCallProperty(node: object, opts?: object): void;
export function assertObjectTypeIndexer(node: object, opts?: object): void;
export function assertObjectTypeProperty(node: object, opts?: object): void;
export function assertQualifiedTypeIdentifier(node: object, opts?: object): void;
export function assertUnionTypeAnnotation(node: object, opts?: object): void;
export function assertVoidTypeAnnotation(node: object, opts?: object): void;
export function assertJSXAttribute(node: object, opts?: object): void;
export function assertJSXClosingElement(node: object, opts?: object): void;
export function assertJSXElement(node: object, opts?: object): void;
export function assertJSXEmptyExpression(node: object, opts?: object): void;
export function assertJSXExpressionContainer(node: object, opts?: object): void;
export function assertJSXIdentifier(node: object, opts?: object): void;
export function assertJSXMemberExpression(node: object, opts?: object): void;
export function assertJSXNamespacedName(node: object, opts?: object): void;
export function assertJSXOpeningElement(node: object, opts?: object): void;
export function assertJSXSpreadAttribute(node: object, opts?: object): void;
export function assertJSXText(node: object, opts?: object): void;
export function assertNoop(node: object, opts?: object): void;
export function assertParenthesizedExpression(node: object, opts?: object): void;
export function assertAwaitExpression(node: object, opts?: object): void;
export function assertBindExpression(node: object, opts?: object): void;
export function assertDecorator(node: object, opts?: object): void;
export function assertDoExpression(node: object, opts?: object): void;
export function assertExportDefaultSpecifier(node: object, opts?: object): void;
export function assertExportNamespaceSpecifier(node: object, opts?: object): void;
export function assertRestProperty(node: object, opts?: object): void;
export function assertSpreadProperty(node: object, opts?: object): void;
export function assertExpression(node: object, opts?: object): void;
export function assertBinary(node: object, opts?: object): void;
export function assertScopable(node: object, opts?: object): void;
export function assertBlockParent(node: object, opts?: object): void;
export function assertBlock(node: object, opts?: object): void;
export function assertStatement(node: object, opts?: object): void;
export function assertTerminatorless(node: object, opts?: object): void;
export function assertCompletionStatement(node: object, opts?: object): void;
export function assertConditional(node: object, opts?: object): void;
export function assertLoop(node: object, opts?: object): void;
export function assertWhile(node: object, opts?: object): void;
export function assertExpressionWrapper(node: object, opts?: object): void;
export function assertFor(node: object, opts?: object): void;
export function assertForXStatement(node: object, opts?: object): void;
export function assertFunction(node: object, opts?: object): void;
export function assertFunctionParent(node: object, opts?: object): void;
export function assertPureish(node: object, opts?: object): void;
export function assertDeclaration(node: object, opts?: object): void;
export function assertLVal(node: object, opts?: object): void;
export function assertLiteral(node: object, opts?: object): void;
export function assertImmutable(node: object, opts?: object): void;
export function assertUserWhitespacable(node: object, opts?: object): void;
export function assertMethod(node: object, opts?: object): void;
export function assertObjectMember(node: object, opts?: object): void;
export function assertProperty(node: object, opts?: object): void;
export function assertUnaryLike(node: object, opts?: object): void;
export function assertPattern(node: object, opts?: object): void;
export function assertClass(node: object, opts?: object): void;
export function assertModuleDeclaration(node: object, opts?: object): void;
export function assertExportDeclaration(node: object, opts?: object): void;
export function assertModuleSpecifier(node: object, opts?: object): void;
export function assertFlow(node: object, opts?: object): void;
export function assertFlowBaseAnnotation(node: object, opts?: object): void;
export function assertFlowDeclaration(node: object, opts?: object): void;
export function assertJSX(node: object, opts?: object): void;
export function assertNumberLiteral(node: object, opts?: object): void;
export function assertRegexLiteral(node: object, opts?: object): void;
export function assertArrayExpression(node: object | null | undefined, opts?: object): void;
export function assertAssignmentExpression(node: object | null | undefined, opts?: object): void;
export function assertBinaryExpression(node: object | null | undefined, opts?: object): void;
export function assertDirective(node: object | null | undefined, opts?: object): void;
export function assertDirectiveLiteral(node: object | null | undefined, opts?: object): void;
export function assertBlockStatement(node: object | null | undefined, opts?: object): void;
export function assertBreakStatement(node: object | null | undefined, opts?: object): void;
export function assertCallExpression(node: object | null | undefined, opts?: object): void;
export function assertCatchClause(node: object | null | undefined, opts?: object): void;
export function assertConditionalExpression(node: object | null | undefined, opts?: object): void;
export function assertContinueStatement(node: object | null | undefined, opts?: object): void;
export function assertDebuggerStatement(node: object | null | undefined, opts?: object): void;
export function assertDoWhileStatement(node: object | null | undefined, opts?: object): void;
export function assertEmptyStatement(node: object | null | undefined, opts?: object): void;
export function assertExpressionStatement(node: object | null | undefined, opts?: object): void;
export function assertFile(node: object | null | undefined, opts?: object): void;
export function assertForInStatement(node: object | null | undefined, opts?: object): void;
export function assertForStatement(node: object | null | undefined, opts?: object): void;
export function assertFunctionDeclaration(node: object | null | undefined, opts?: object): void;
export function assertFunctionExpression(node: object | null | undefined, opts?: object): void;
export function assertIdentifier(node: object | null | undefined, opts?: object): void;
export function assertIfStatement(node: object | null | undefined, opts?: object): void;
export function assertLabeledStatement(node: object | null | undefined, opts?: object): void;
export function assertStringLiteral(node: object | null | undefined, opts?: object): void;
export function assertNumericLiteral(node: object | null | undefined, opts?: object): void;
export function assertNullLiteral(node: object | null | undefined, opts?: object): void;
export function assertBooleanLiteral(node: object | null | undefined, opts?: object): void;
export function assertRegExpLiteral(node: object | null | undefined, opts?: object): void;
export function assertLogicalExpression(node: object | null | undefined, opts?: object): void;
export function assertMemberExpression(node: object | null | undefined, opts?: object): void;
export function assertNewExpression(node: object | null | undefined, opts?: object): void;
export function assertProgram(node: object | null | undefined, opts?: object): void;
export function assertObjectExpression(node: object | null | undefined, opts?: object): void;
export function assertObjectMethod(node: object | null | undefined, opts?: object): void;
export function assertObjectProperty(node: object | null | undefined, opts?: object): void;
export function assertRestElement(node: object | null | undefined, opts?: object): void;
export function assertReturnStatement(node: object | null | undefined, opts?: object): void;
export function assertSequenceExpression(node: object | null | undefined, opts?: object): void;
export function assertSwitchCase(node: object | null | undefined, opts?: object): void;
export function assertSwitchStatement(node: object | null | undefined, opts?: object): void;
export function assertThisExpression(node: object | null | undefined, opts?: object): void;
export function assertThrowStatement(node: object | null | undefined, opts?: object): void;
export function assertTryStatement(node: object | null | undefined, opts?: object): void;
export function assertUnaryExpression(node: object | null | undefined, opts?: object): void;
export function assertUpdateExpression(node: object | null | undefined, opts?: object): void;
export function assertVariableDeclaration(node: object | null | undefined, opts?: object): void;
export function assertVariableDeclarator(node: object | null | undefined, opts?: object): void;
export function assertWhileStatement(node: object | null | undefined, opts?: object): void;
export function assertWithStatement(node: object | null | undefined, opts?: object): void;
export function assertAssignmentPattern(node: object | null | undefined, opts?: object): void;
export function assertArrayPattern(node: object | null | undefined, opts?: object): void;
export function assertArrowFunctionExpression(node: object | null | undefined, opts?: object): void;
export function assertClassBody(node: object | null | undefined, opts?: object): void;
export function assertClassDeclaration(node: object | null | undefined, opts?: object): void;
export function assertClassExpression(node: object | null | undefined, opts?: object): void;
export function assertExportAllDeclaration(node: object | null | undefined, opts?: object): void;
export function assertExportDefaultDeclaration(node: object | null | undefined, opts?: object): void;
export function assertExportNamedDeclaration(node: object | null | undefined, opts?: object): void;
export function assertExportSpecifier(node: object | null | undefined, opts?: object): void;
export function assertForOfStatement(node: object | null | undefined, opts?: object): void;
export function assertImportDeclaration(node: object | null | undefined, opts?: object): void;
export function assertImportDefaultSpecifier(node: object | null | undefined, opts?: object): void;
export function assertImportNamespaceSpecifier(node: object | null | undefined, opts?: object): void;
export function assertImportSpecifier(node: object | null | undefined, opts?: object): void;
export function assertMetaProperty(node: object | null | undefined, opts?: object): void;
export function assertClassMethod(node: object | null | undefined, opts?: object): void;
export function assertObjectPattern(node: object | null | undefined, opts?: object): void;
export function assertSpreadElement(node: object | null | undefined, opts?: object): void;
export function assertSuper(node: object | null | undefined, opts?: object): void;
export function assertTaggedTemplateExpression(node: object | null | undefined, opts?: object): void;
export function assertTemplateElement(node: object | null | undefined, opts?: object): void;
export function assertTemplateLiteral(node: object | null | undefined, opts?: object): void;
export function assertYieldExpression(node: object | null | undefined, opts?: object): void;
export function assertAnyTypeAnnotation(node: object | null | undefined, opts?: object): void;
export function assertArrayTypeAnnotation(node: object | null | undefined, opts?: object): void;
export function assertBooleanTypeAnnotation(node: object | null | undefined, opts?: object): void;
export function assertBooleanLiteralTypeAnnotation(node: object | null | undefined, opts?: object): void;
export function assertNullLiteralTypeAnnotation(node: object | null | undefined, opts?: object): void;
export function assertClassImplements(node: object | null | undefined, opts?: object): void;
export function assertClassProperty(node: object | null | undefined, opts?: object): void;
export function assertDeclareClass(node: object | null | undefined, opts?: object): void;
export function assertDeclareFunction(node: object | null | undefined, opts?: object): void;
export function assertDeclareInterface(node: object | null | undefined, opts?: object): void;
export function assertDeclareModule(node: object | null | undefined, opts?: object): void;
export function assertDeclareTypeAlias(node: object | null | undefined, opts?: object): void;
export function assertDeclareVariable(node: object | null | undefined, opts?: object): void;
export function assertExistentialTypeParam(node: object | null | undefined, opts?: object): void;
export function assertFunctionTypeAnnotation(node: object | null | undefined, opts?: object): void;
export function assertFunctionTypeParam(node: object | null | undefined, opts?: object): void;
export function assertGenericTypeAnnotation(node: object | null | undefined, opts?: object): void;
export function assertInterfaceExtends(node: object | null | undefined, opts?: object): void;
export function assertInterfaceDeclaration(node: object | null | undefined, opts?: object): void;
export function assertIntersectionTypeAnnotation(node: object | null | undefined, opts?: object): void;
export function assertMixedTypeAnnotation(node: object | null | undefined, opts?: object): void;
export function assertNullableTypeAnnotation(node: object | null | undefined, opts?: object): void;
export function assertNumericLiteralTypeAnnotation(node: object | null | undefined, opts?: object): void;
export function assertNumberTypeAnnotation(node: object | null | undefined, opts?: object): void;
export function assertStringLiteralTypeAnnotation(node: object | null | undefined, opts?: object): void;
export function assertStringTypeAnnotation(node: object | null | undefined, opts?: object): void;
export function assertThisTypeAnnotation(node: object | null | undefined, opts?: object): void;
export function assertTupleTypeAnnotation(node: object | null | undefined, opts?: object): void;
export function assertTypeofTypeAnnotation(node: object | null | undefined, opts?: object): void;
export function assertTypeAlias(node: object | null | undefined, opts?: object): void;
export function assertTypeAnnotation(node: object | null | undefined, opts?: object): void;
export function assertTypeCastExpression(node: object | null | undefined, opts?: object): void;
export function assertTypeParameter(node: object | null | undefined, opts?: object): void;
export function assertTypeParameterDeclaration(node: object | null | undefined, opts?: object): void;
export function assertTypeParameterInstantiation(node: object | null | undefined, opts?: object): void;
export function assertObjectTypeAnnotation(node: object | null | undefined, opts?: object): void;
export function assertObjectTypeCallProperty(node: object | null | undefined, opts?: object): void;
export function assertObjectTypeIndexer(node: object | null | undefined, opts?: object): void;
export function assertObjectTypeProperty(node: object | null | undefined, opts?: object): void;
export function assertQualifiedTypeIdentifier(node: object | null | undefined, opts?: object): void;
export function assertUnionTypeAnnotation(node: object | null | undefined, opts?: object): void;
export function assertVoidTypeAnnotation(node: object | null | undefined, opts?: object): void;
export function assertJSXAttribute(node: object | null | undefined, opts?: object): void;
export function assertJSXClosingElement(node: object | null | undefined, opts?: object): void;
export function assertJSXElement(node: object | null | undefined, opts?: object): void;
export function assertJSXEmptyExpression(node: object | null | undefined, opts?: object): void;
export function assertJSXExpressionContainer(node: object | null | undefined, opts?: object): void;
export function assertJSXIdentifier(node: object | null | undefined, opts?: object): void;
export function assertJSXMemberExpression(node: object | null | undefined, opts?: object): void;
export function assertJSXNamespacedName(node: object | null | undefined, opts?: object): void;
export function assertJSXOpeningElement(node: object | null | undefined, opts?: object): void;
export function assertJSXSpreadAttribute(node: object | null | undefined, opts?: object): void;
export function assertJSXText(node: object | null | undefined, opts?: object): void;
export function assertNoop(node: object | null | undefined, opts?: object): void;
export function assertParenthesizedExpression(node: object | null | undefined, opts?: object): void;
export function assertAwaitExpression(node: object | null | undefined, opts?: object): void;
export function assertBindExpression(node: object | null | undefined, opts?: object): void;
export function assertDecorator(node: object | null | undefined, opts?: object): void;
export function assertDoExpression(node: object | null | undefined, opts?: object): void;
export function assertExportDefaultSpecifier(node: object | null | undefined, opts?: object): void;
export function assertExportNamespaceSpecifier(node: object | null | undefined, opts?: object): void;
export function assertRestProperty(node: object | null | undefined, opts?: object): void;
export function assertSpreadProperty(node: object | null | undefined, opts?: object): void;
export function assertExpression(node: object | null | undefined, opts?: object): void;
export function assertBinary(node: object | null | undefined, opts?: object): void;
export function assertScopable(node: object | null | undefined, opts?: object): void;
export function assertBlockParent(node: object | null | undefined, opts?: object): void;
export function assertBlock(node: object | null | undefined, opts?: object): void;
export function assertStatement(node: object | null | undefined, opts?: object): void;
export function assertTerminatorless(node: object | null | undefined, opts?: object): void;
export function assertCompletionStatement(node: object | null | undefined, opts?: object): void;
export function assertConditional(node: object | null | undefined, opts?: object): void;
export function assertLoop(node: object | null | undefined, opts?: object): void;
export function assertWhile(node: object | null | undefined, opts?: object): void;
export function assertExpressionWrapper(node: object | null | undefined, opts?: object): void;
export function assertFor(node: object | null | undefined, opts?: object): void;
export function assertForXStatement(node: object | null | undefined, opts?: object): void;
export function assertFunction(node: object | null | undefined, opts?: object): void;
export function assertFunctionParent(node: object | null | undefined, opts?: object): void;
export function assertPureish(node: object | null | undefined, opts?: object): void;
export function assertDeclaration(node: object | null | undefined, opts?: object): void;
export function assertLVal(node: object | null | undefined, opts?: object): void;
export function assertLiteral(node: object | null | undefined, opts?: object): void;
export function assertImmutable(node: object | null | undefined, opts?: object): void;
export function assertUserWhitespacable(node: object | null | undefined, opts?: object): void;
export function assertMethod(node: object | null | undefined, opts?: object): void;
export function assertObjectMember(node: object | null | undefined, opts?: object): void;
export function assertProperty(node: object | null | undefined, opts?: object): void;
export function assertUnaryLike(node: object | null | undefined, opts?: object): void;
export function assertPattern(node: object | null | undefined, opts?: object): void;
export function assertClass(node: object | null | undefined, opts?: object): void;
export function assertModuleDeclaration(node: object | null | undefined, opts?: object): void;
export function assertExportDeclaration(node: object | null | undefined, opts?: object): void;
export function assertModuleSpecifier(node: object | null | undefined, opts?: object): void;
export function assertFlow(node: object | null | undefined, opts?: object): void;
export function assertFlowBaseAnnotation(node: object | null | undefined, opts?: object): void;
export function assertFlowDeclaration(node: object | null | undefined, opts?: object): void;
export function assertJSX(node: object | null | undefined, opts?: object): void;
export function assertNumberLiteral(node: object | null | undefined, opts?: object): void;
export function assertRegexLiteral(node: object | null | undefined, opts?: object): void;
export function assertTSAnyKeyword(node: object, opts?: object): void;
export function assertTSArrayType(node: object, opts?: object): void;
export function assertTSAsExpression(node: object, opts?: object): void;
export function assertTSBooleanKeyword(node: object, opts?: object): void;
export function assertTSCallSignatureDeclaration(node: object, opts?: object): void;
export function assertTSConstructSignatureDeclaration(node: object, opts?: object): void;
export function assertTSConstructorType(node: object, opts?: object): void;
export function assertTSDeclareFunction(node: object, opts?: object): void;
export function assertTSDeclareMethod(node: object, opts?: object): void;
export function assertTSEnumDeclaration(node: object, opts?: object): void;
export function assertTSEnumMember(node: object, opts?: object): void;
export function assertTSExportAssignment(node: object, opts?: object): void;
export function assertTSExpressionWithTypeArguments(node: object, opts?: object): void;
export function assertTSExternalModuleReference(node: object, opts?: object): void;
export function assertTSFunctionType(node: object, opts?: object): void;
export function assertTSImportEqualsDeclaration(node: object, opts?: object): void;
export function assertTSIndexSignature(node: object, opts?: object): void;
export function assertTSIndexedAccessType(node: object, opts?: object): void;
export function assertTSInterfaceBody(node: object, opts?: object): void;
export function assertTSInterfaceDeclaration(node: object, opts?: object): void;
export function assertTSIntersectionType(node: object, opts?: object): void;
export function assertTSLiteralType(node: object, opts?: object): void;
export function assertTSMappedType(node: object, opts?: object): void;
export function assertTSMethodSignature(node: object, opts?: object): void;
export function assertTSModuleBlock(node: object, opts?: object): void;
export function assertTSModuleDeclaration(node: object, opts?: object): void;
export function assertTSNamespaceExportDeclaration(node: object, opts?: object): void;
export function assertTSNeverKeyword(node: object, opts?: object): void;
export function assertTSNonNullExpression(node: object, opts?: object): void;
export function assertTSNullKeyword(node: object, opts?: object): void;
export function assertTSNumberKeyword(node: object, opts?: object): void;
export function assertTSObjectKeyword(node: object, opts?: object): void;
export function assertTSParameterProperty(node: object, opts?: object): void;
export function assertTSParenthesizedType(node: object, opts?: object): void;
export function assertTSPropertySignature(node: object, opts?: object): void;
export function assertTSQualifiedName(node: object, opts?: object): void;
export function assertTSStringKeyword(node: object, opts?: object): void;
export function assertTSSymbolKeyword(node: object, opts?: object): void;
export function assertTSThisType(node: object, opts?: object): void;
export function assertTSTupleType(node: object, opts?: object): void;
export function assertTSTypeAliasDeclaration(node: object, opts?: object): void;
export function assertTSTypeAnnotation(node: object, opts?: object): void;
export function assertTSTypeAssertion(node: object, opts?: object): void;
export function assertTSTypeLiteral(node: object, opts?: object): void;
export function assertTSTypeOperator(node: object, opts?: object): void;
export function assertTSTypeParameter(node: object, opts?: object): void;
export function assertTSTypeParameterDeclaration(node: object, opts?: object): void;
export function assertTSTypeParameterInstantiation(node: object, opts?: object): void;
export function assertTSTypePredicate(node: object, opts?: object): void;
export function assertTSTypeQuery(node: object, opts?: object): void;
export function assertTSTypeReference(node: object, opts?: object): void;
export function assertTSUndefinedKeyword(node: object, opts?: object): void;
export function assertTSUnionType(node: object, opts?: object): void;
export function assertTSVoidKeyword(node: object, opts?: object): void;
export function assertTSAnyKeyword(node: object | null | undefined, opts?: object): void;
export function assertTSArrayType(node: object | null | undefined, opts?: object): void;
export function assertTSAsExpression(node: object | null | undefined, opts?: object): void;
export function assertTSBooleanKeyword(node: object | null | undefined, opts?: object): void;
export function assertTSCallSignatureDeclaration(node: object | null | undefined, opts?: object): void;
export function assertTSConstructSignatureDeclaration(node: object | null | undefined, opts?: object): void;
export function assertTSConstructorType(node: object | null | undefined, opts?: object): void;
export function assertTSDeclareFunction(node: object | null | undefined, opts?: object): void;
export function assertTSDeclareMethod(node: object | null | undefined, opts?: object): void;
export function assertTSEnumDeclaration(node: object | null | undefined, opts?: object): void;
export function assertTSEnumMember(node: object | null | undefined, opts?: object): void;
export function assertTSExportAssignment(node: object | null | undefined, opts?: object): void;
export function assertTSExpressionWithTypeArguments(node: object | null | undefined, opts?: object): void;
export function assertTSExternalModuleReference(node: object | null | undefined, opts?: object): void;
export function assertTSFunctionType(node: object | null | undefined, opts?: object): void;
export function assertTSImportEqualsDeclaration(node: object | null | undefined, opts?: object): void;
export function assertTSIndexSignature(node: object | null | undefined, opts?: object): void;
export function assertTSIndexedAccessType(node: object | null | undefined, opts?: object): void;
export function assertTSInterfaceBody(node: object | null | undefined, opts?: object): void;
export function assertTSInterfaceDeclaration(node: object | null | undefined, opts?: object): void;
export function assertTSIntersectionType(node: object | null | undefined, opts?: object): void;
export function assertTSLiteralType(node: object | null | undefined, opts?: object): void;
export function assertTSMappedType(node: object | null | undefined, opts?: object): void;
export function assertTSMethodSignature(node: object | null | undefined, opts?: object): void;
export function assertTSModuleBlock(node: object | null | undefined, opts?: object): void;
export function assertTSModuleDeclaration(node: object | null | undefined, opts?: object): void;
export function assertTSNamespaceExportDeclaration(node: object | null | undefined, opts?: object): void;
export function assertTSNeverKeyword(node: object | null | undefined, opts?: object): void;
export function assertTSNonNullExpression(node: object | null | undefined, opts?: object): void;
export function assertTSNullKeyword(node: object | null | undefined, opts?: object): void;
export function assertTSNumberKeyword(node: object | null | undefined, opts?: object): void;
export function assertTSObjectKeyword(node: object | null | undefined, opts?: object): void;
export function assertTSParameterProperty(node: object | null | undefined, opts?: object): void;
export function assertTSParenthesizedType(node: object | null | undefined, opts?: object): void;
export function assertTSPropertySignature(node: object | null | undefined, opts?: object): void;
export function assertTSQualifiedName(node: object | null | undefined, opts?: object): void;
export function assertTSStringKeyword(node: object | null | undefined, opts?: object): void;
export function assertTSSymbolKeyword(node: object | null | undefined, opts?: object): void;
export function assertTSThisType(node: object | null | undefined, opts?: object): void;
export function assertTSTupleType(node: object | null | undefined, opts?: object): void;
export function assertTSTypeAliasDeclaration(node: object | null | undefined, opts?: object): void;
export function assertTSTypeAnnotation(node: object | null | undefined, opts?: object): void;
export function assertTSTypeAssertion(node: object | null | undefined, opts?: object): void;
export function assertTSTypeLiteral(node: object | null | undefined, opts?: object): void;
export function assertTSTypeOperator(node: object | null | undefined, opts?: object): void;
export function assertTSTypeParameter(node: object | null | undefined, opts?: object): void;
export function assertTSTypeParameterDeclaration(node: object | null | undefined, opts?: object): void;
export function assertTSTypeParameterInstantiation(node: object | null | undefined, opts?: object): void;
export function assertTSTypePredicate(node: object | null | undefined, opts?: object): void;
export function assertTSTypeQuery(node: object | null | undefined, opts?: object): void;
export function assertTSTypeReference(node: object | null | undefined, opts?: object): void;
export function assertTSUndefinedKeyword(node: object | null | undefined, opts?: object): void;
export function assertTSUnionType(node: object | null | undefined, opts?: object): void;
export function assertTSVoidKeyword(node: object | null | undefined, opts?: object): void;

2
types/babel-types/tsconfig.json
View File

@ -6,7 +6,7 @@
],
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": false,
"strictNullChecks": true,
"strictFunctionTypes": true,
"baseUrl": "../",
"typeRoots": [

56
types/babel__core/babel__core-tests.ts
View File

@ -39,3 +39,59 @@ babel.transformFromAstAsync(parsedAst!, sourceCode, options).then(transformFromA
const { code, map, ast } = transformFromAstAsyncResult!;
const { body } = ast!.program;
});
function checkOptions(_options: babel.TransformOptions) {}
function checkConfigFunction(_config: babel.ConfigFunction) {}
checkOptions({ envName: 'banana' });
// babel uses object destructuring default to provide the envName fallback so null is not allowed
// $ExpectError
checkOptions({ envName: null });
checkOptions({ caller: { name: '@babel/register' } });
checkOptions({ caller: { name: 'babel-jest', supportsStaticESM: false } });
// don't add an index signature; users should augment the interface instead if they need to
// $ExpectError
checkOptions({ caller: { name: '', tomato: true } });
checkOptions({ rootMode: 'upward-optional' });
// $ExpectError
checkOptions({ rootMode: 'potato' });
// $ExpectError
checkConfigFunction(() => {});
// you technically can do that though you probably shouldn't
checkConfigFunction(() => ({}));
checkConfigFunction(api => {
api.assertVersion(7);
api.assertVersion("^7.2");
api.cache.forever();
api.cache.never();
api.cache.using(() => true);
api.cache.using(() => 1);
api.cache.using(() => '1');
api.cache.using(() => null);
api.cache.using(() => undefined);
// $ExpectError
api.cache.using(() => ({}));
api.cache.invalidate(() => 2);
// $ExpectType string
api.env();
api.env('development');
api.env(['production', 'test']);
// $ExpectType 42
api.env(name => 42);
// $ExpectType string
api.version;
return {
shouldPrintComment(comment) {
// $ExpectType string
comment;
return true;
}
};
});

155
types/babel__core/index.d.ts vendored
View File

@ -1,8 +1,9 @@
// Type definitions for @babel/core 7.0
// Type definitions for @babel/core 7.1
// Project: https://github.com/babel/babel/tree/master/packages/babel-core, https://babeljs.io
// Definitions by: Troy Gerwien <https://github.com/yortus>
// Marvin Hagemeister <https://github.com/marvinhagemeister>
// Melvin Groenhoff <https://github.com/mgroenhoff>
// Jessica Franco <https://github.com/Jessidhia>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.9
@ -54,6 +55,15 @@ export interface TransformOptions {
*/
root?: string | null;
/**
* This option, combined with the "root" value, defines how Babel chooses its project root.
* The different modes define different ways that Babel can process the "root" value to get
* the final project root.
*
* @see https://babeljs.io/docs/en/next/options#rootmode
*/
rootMode?: 'root' | 'upward' | 'upward-optional';
/**
* The config file to load Babel's config from. Defaults to searching for "babel.config.js" inside the "root" folder. `false` will disable searching for config files.
*
@ -82,7 +92,7 @@ export interface TransformOptions {
*
* Default: env vars
*/
envName?: string | null;
envName?: string;
/**
* Enable code generation
@ -112,6 +122,14 @@ export interface TransformOptions {
*/
cwd?: string | null;
/**
* Utilities may pass a caller object to identify themselves to Babel and
* pass capability-related flags for use by configs, presets and plugins.
*
* @see https://babeljs.io/docs/en/next/options#caller
*/
caller?: TransformCaller;
/**
* This is an object of keys that represent different environments. For example, you may have: `{ env: { production: { \/* specific options *\/ } } }`
* which will use those options when the `envName` is `production`
@ -284,6 +302,14 @@ export interface TransformOptions {
wrapPluginVisitorMethod?: ((pluginAlias: string, visitorType: "enter" | "exit", callback: (path: NodePath, state: any) => void) => (path: NodePath, state: any) => void) | null;
}
export interface TransformCaller {
// the only required property
name: string;
// e.g. set to true by `babel-loader` and false by `babel-jest`
supportsStaticESM?: boolean;
// augment this with a "declare module '@babel/core' { ... }" if you need more keys
}
export type FileResultCallback = (err: Error | null, result: BabelFileResult | null) => any;
/**
@ -528,4 +554,129 @@ export interface CreateConfigItemOptions {
*/
export function createConfigItem(value: PluginTarget | [PluginTarget, PluginOptions] | [PluginTarget, PluginOptions, string | undefined], options?: CreateConfigItemOptions): ConfigItem;
// NOTE: the documentation says the ConfigAPI also exposes @babel/core's exports, but it actually doesn't
/**
* @see https://babeljs.io/docs/en/next/config-files#config-function-api
*/
export interface ConfigAPI {
/**
* The version string for the Babel version that is loading the config file.
*
* @see https://babeljs.io/docs/en/next/config-files#apiversion
*/
version: string;
/**
* @see https://babeljs.io/docs/en/next/config-files#apicache
*/
cache: SimpleCacheConfigurator;
/**
* @see https://babeljs.io/docs/en/next/config-files#apienv
*/
env: EnvFunction;
// undocumented; currently hardcoded to return 'false'
// async(): boolean
/**
* This API is used as a way to access the `caller` data that has been passed to Babel.
* Since many instances of Babel may be running in the same process with different `caller` values,
* this API is designed to automatically configure `api.cache`, the same way `api.env()` does.
*
* The `caller` value is available as the first parameter of the callback function.
* It is best used with something like this to toggle configuration behavior
* based on a specific environment:
*
* @example
* function isBabelRegister(caller?: { name: string }) {
* return !!(caller && caller.name === "@babel/register")
* }
* api.caller(isBabelRegister)
*
* @see https://babeljs.io/docs/en/next/config-files#apicallercb
*/
caller<T extends SimpleCacheKey>(callerCallback: (caller: TransformOptions['caller']) => T): T;
/**
* While `api.version` can be useful in general, it's sometimes nice to just declare your version.
* This API exposes a simple way to do that with:
*
* @example
* api.assertVersion(7) // major version only
* api.assertVersion("^7.2")
*
* @see https://babeljs.io/docs/en/next/config-files#apiassertversionrange
*/
assertVersion(versionRange: number | string): boolean;
// NOTE: this is an undocumented reexport from "@babel/parser" but it's missing from its types
// tokTypes: typeof tokTypes
}
/**
* JS configs are great because they can compute a config on the fly,
* but the downside there is that it makes caching harder.
* Babel wants to avoid re-executing the config function every time a file is compiled,
* because then it would also need to re-execute any plugin and preset functions
* referenced in that config.
*
* To avoid this, Babel expects users of config functions to tell it how to manage caching
* within a config file.
*
* @see https://babeljs.io/docs/en/next/config-files#apicache
*/
export interface SimpleCacheConfigurator {
// there is an undocumented call signature that is a shorthand for forever()/never()/using().
// (ever: boolean): void
// <T extends SimpleCacheKey>(callback: CacheCallback<T>): T
/**
* Permacache the computed config and never call the function again.
*/
forever(): void;
/**
* Do not cache this config, and re-execute the function every time.
*/
never(): void;
/**
* Any time the using callback returns a value other than the one that was expected,
* the overall config function will be called again and a new entry will be added to the cache.
*
* @example
* api.cache.using(() => process.env.NODE_ENV)
*/
using<T extends SimpleCacheKey>(callback: SimpleCacheCallback<T>): T;
/**
* Any time the using callback returns a value other than the one that was expected,
* the overall config function will be called again and all entries in the cache will
* be replaced with the result.
*
* @example
* api.cache.invalidate(() => process.env.NODE_ENV)
*/
invalidate<T extends SimpleCacheKey>(callback: SimpleCacheCallback<T>): T;
}
// https://github.com/babel/babel/blob/v7.3.3/packages/babel-core/src/config/caching.js#L231
export type SimpleCacheKey = string | boolean | number | null | undefined;
export type SimpleCacheCallback<T extends SimpleCacheKey> = () => T;
/**
* Since `NODE_ENV` is a fairly common way to toggle behavior, Babel also includes an API function
* meant specifically for that. This API is used as a quick way to check the `"envName"` that Babel
* was loaded with, which takes `NODE_ENV` into account if no other overriding environment is set.
*
* @see https://babeljs.io/docs/en/next/config-files#apienv
*/
export interface EnvFunction {
/**
* @returns the current `envName` string
*/
(): string;
/**
* @returns `true` if the `envName` is `===` any of the given strings
*/
(envName: string | ReadonlyArray<string>): boolean;
// the official documentation is misleading for this one...
// this just passes the callback to `cache.using` but with an additional argument.
// it returns its result instead of necessarily returning a boolean.
<T extends SimpleCacheKey>(envCallback: (envName: NonNullable<TransformOptions['envName']>) => T): T;
}
export type ConfigFunction = (api: ConfigAPI) => TransformOptions;
export as namespace babel;

2
types/baidu-app/index.d.ts vendored
View File

@ -4287,7 +4287,7 @@ declare namespace swan {
Methods,
Props
> = object &
ComponentOptions<V, Data | ((this: V) => Data), Methods, Props> &
ComponentOptions<V, Data, Methods, Props> &
ThisType<CombinedInstance<V, Data, Methods, Readonly<Props>>>;
interface ComponentRelation<D = any, P = any> {

23
types/bit-twiddle/bit-twiddle-tests.ts Normal file
View File

@ -0,0 +1,23 @@
import * as bitTwiddle from "bit-twiddle";
bitTwiddle.INT_BITS;
bitTwiddle.INT_MAX;
bitTwiddle.INT_MIN;
bitTwiddle.sign(5);
bitTwiddle.abs(-5);
bitTwiddle.min(1, 6);
bitTwiddle.max(6, 1);
bitTwiddle.isPow2(3);
bitTwiddle.log2(3);
bitTwiddle.log10(3);
bitTwiddle.popCount(4);
bitTwiddle.countTrailingZeros(3.0000003);
bitTwiddle.nextPow2(31.315);
bitTwiddle.prevPow2(31.315);
bitTwiddle.parity(123);
bitTwiddle.interleave2(12, 24);
bitTwiddle.deinterleave2(24, 12);
bitTwiddle.interleave3(24, 12, 6);
bitTwiddle.deinterleave3(24, 12);
bitTwiddle.nextCombination(41.935);

101
types/bit-twiddle/index.d.ts vendored Normal file
View File

@ -0,0 +1,101 @@
// Type definitions for bit-twiddle 1.0
// Project: https://github.com/mikolalysenko/bit-twiddle
// Definitions by: Adam Zerella <https://github.com/adamzerella>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 3.3
export const INT_BITS: number;
export const INT_MAX: number;
export const INT_MIN: number;
/**
* Computes the sign of the integer.
*/
export function sign(value: number): number;
/**
* Returns the absolute value of the integer.
*/
export function abs(value: number): number;
/**
* Computes the minimum of integers x and y.
*/
export function min(x: number, y: number): number;
/**
* Computes the maximum of integers x and y.
*/
export function max(x: number, y: number): number;
/**
* Returns true if value is a power of 2, otherwise false.
*/
export function isPow2(value: number): boolean;
/**
* Returns an integer approximation of the log-base 2 of value.
*/
export function log2(value: number): number;
/**
* Returns an integer approximation of the log-base 10 of value.
*/
export function log10(value: number): number;
/**
* Counts the number of bits set in value.
*/
export function popCount(value: number): number;
/**
* Counts the number of trailing zeros.
*/
export function countTrailingZeros(value: number): number;
/**
* Rounds value up to the next power of 2.
*/
export function nextPow2(value: number): number;
/**
* Rounds value down to the previous power of 2.
*/
export function prevPow2(value: number): number;
/**
* Computes the parity of the bits in value.
*/
export function parity(value: number): number;
/**
* Reverses the bits of value.
*/
export function reverse(value: number): number;
/**
* Interleaves a pair of 16 bit integers. Useful for fast quadtree style indexing.
* @see http://en.wikipedia.org/wiki/Z-order_curve
*/
export function interleave2(x: number, y: number): number;
/**
* Deinterleaves the bits of value, returns the nth part.
* If both x and y are 16 bit.
*/
export function deinterleave2(x: number, y: number): number;
/**
* Interleaves a triple of 10 bit integers. Useful for fast octree indexing.
*/
export function interleave3(x: number, y: number, z: number): number;
/**
* Same deal as deinterleave2, only for triples instead of pairs.
*/
export function deinterleave3(x: number, y: number): number;
/**
* Returns next combination ordered colexicographically.
*/
export function nextCombination(x: number): number;

25
types/bit-twiddle/tsconfig.json Normal file
View File

@ -0,0 +1,25 @@
{
"compilerOptions": {
"module": "commonjs",
"lib": [
"es6"
],
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": true,
"strictFunctionTypes": true,
"baseUrl": "../",
"typeRoots": [
"../"
],
"types": [
],
"noEmit": true,
"forceConsistentCasingInFileNames": true
},
"files": [
"index.d.ts",
"bit-twiddle-tests.ts"
]
}

3
types/bit-twiddle/tslint.json Normal file
View File

@ -0,0 +1,3 @@
{
"extends": "dtslint/dt.json"
}

24
types/bluebird-global/index.d.ts vendored
View File

@ -113,12 +113,15 @@
import Bluebird = require("bluebird");
declare global {
type IterateFunction<T, R> = (item: T, index: number, arrayLength: number) => (R | PromiseLike<R>);
/*
* Patch all instance method
*/
interface Promise<T> {
all: Bluebird<T>["all"];
any: Bluebird<T>["any"];
all(this: Promise<Iterable<{}>>): Bluebird<T>;
all(): Bluebird<never>;
any<Q>(this: Promise<T & Iterable<Q>>): Bluebird<Q>;
any(): Bluebird<never>;
asCallback: Bluebird<T>["asCallback"];
bind: Bluebird<T>["bind"];
call: Bluebird<T>["call"];
@ -128,9 +131,9 @@ declare global {
delay: Bluebird<T>["delay"];
disposer: Bluebird<T>["disposer"];
done: Bluebird<T>["done"];
each: Bluebird<T>["each"];
each<Q>(this: Promise<T & Iterable<Q>>, iterator: IterateFunction<Q, any>): Bluebird<T>;
error: Bluebird<T>["error"];
filter: Bluebird<T>["filter"];
filter<Q>(this: Promise<T & Iterable<Q>>, filterer: IterateFunction<Q, boolean>, options?: Bluebird.ConcurrencyOption): Bluebird<T>;
// finally: Bluebird<T>["finally"]; // Provided by lib.es2018.promise.d.ts
get: Bluebird<T>["get"];
isCancelled: Bluebird<T>["isCancelled"];
@ -139,17 +142,18 @@ declare global {
isRejected: Bluebird<T>["isRejected"];
isResolved: Bluebird<T>["isResolved"];
lastly: Bluebird<T>["lastly"];
map: Bluebird<T>["map"];
mapSeries: Bluebird<T>["mapSeries"];
map<U, Q>(this: Promise<T & Iterable<Q>>, mapper: IterateFunction<Q, U>, options?: Bluebird.ConcurrencyOption): Bluebird<U[]>;
mapSeries<U, Q>(this: Promise<T & Iterable<Q>>, iterator: IterateFunction<Q, U>): Bluebird<U[]>;
nodeify: Bluebird<T>["nodeify"];
props: Bluebird<T>["props"];
race: Bluebird<T>["race"];
race<Q>(this: Promise<T & Iterable<Q>>): Bluebird<Q>;
race(): Bluebird<never>;
reason: Bluebird<T>["reason"];
reduce: Bluebird<T>["reduce"];
reduce<U, Q>(this: Promise<T & Iterable<Q>>, reducer: (memo: U, item: Q, index: number, arrayLength: number) => (U | PromiseLike<U>), initialValue?: U): Bluebird<U>;
reflect: Bluebird<T>["reflect"];
return: Bluebird<T>["return"];
some: Bluebird<T>["some"];
spread: Bluebird<T>["spread"];
some(this: Promise<Iterable<{}>>, count: number): Bluebird<T>;
spread<U, Q>(this: Bluebird<T & Iterable<Q>>, fulfilledHandler: (...values: Q[]) => (U | PromiseLike<U>)): Bluebird<U>;
suppressUnhandledRejections: Bluebird<T>["suppressUnhandledRejections"];
tap: Bluebird<T>["tap"];
tapCatch: Bluebird<T>["tapCatch"];

46
types/bluebird/index.d.ts vendored
View File

@ -37,8 +37,6 @@
type Constructor<E> = new (...args: any[]) => E;
type CatchFilter<E> = ((error: E) => boolean) | (object & E);
type IterableItem<R> = R extends Iterable<infer U> ? U : never;
type IterableOrNever<R> = Extract<R, Iterable<any>>;
type Resolvable<R> = R | PromiseLike<R>;
type IterateFunction<T, R> = (item: T, index: number, arrayLength: number) => Resolvable<R>;
@ -352,7 +350,7 @@ declare class Bluebird<R> implements PromiseLike<R>, Bluebird.Inspection<R> {
* });
* </code>
*/
call<U extends keyof R>(propertyName: U, ...args: any[]): Bluebird<R[U] extends (...args: any[]) => any ? ReturnType<R[U]> : never>;
call<U extends keyof Q, Q>(this: Bluebird<Q>, propertyName: U, ...args: any[]): Bluebird<Q[U] extends (...args: any[]) => any ? ReturnType<Q[U]> : never>;
/**
* This is a convenience method for doing:
@ -562,12 +560,17 @@ declare class Bluebird<R> implements PromiseLike<R>, Bluebird.Inspection<R> {
/**
* Like calling `.then`, but the fulfillment value or rejection reason is assumed to be an array, which is flattened to the formal parameters of the handlers.
*/
spread<U>(fulfilledHandler: (...values: Array<IterableItem<R>>) => Resolvable<U>): Bluebird<U>;
spread<U, Q>(this: Bluebird<R & Iterable<Q>>, fulfilledHandler: (...values: Q[]) => Resolvable<U>): Bluebird<U>;
/**
* Same as calling `Promise.all(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
*/
all(): Bluebird<IterableOrNever<R>>;
all(this: Bluebird<Iterable<{}>>): Bluebird<R>;
/**
* Same as calling `Promise.all(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
*/
all(): Bluebird<never>;
/**
* Same as calling `Promise.props(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
@ -578,42 +581,59 @@ declare class Bluebird<R> implements PromiseLike<R>, Bluebird.Inspection<R> {
/**
* Same as calling `Promise.any(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
*/
any(): Bluebird<IterableItem<R>>;
any<Q>(this: Bluebird<R & Iterable<Q>>): Bluebird<Q>;
/**
* Same as calling `Promise.any(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
*/
any(): Bluebird<never>;
/**
* Same as calling `Promise.some(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
* Same as calling `Promise.some(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
*/
some(count: number): Bluebird<IterableOrNever<R>>;
some(this: Bluebird<Iterable<{}>>, count: number): Bluebird<R>;
/**
* Same as calling `Promise.some(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
* Same as calling `Promise.some(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
*/
some(count: number): Bluebird<never>;
/**
* Same as calling `Promise.race(thisPromise, count)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
*/
race(): Bluebird<IterableItem<R>>;
race<Q>(this: Bluebird<R & Iterable<Q>>): Bluebird<Q>;
/**
* Same as calling `Promise.race(thisPromise, count)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
*/
race(): Bluebird<never>;
/**
* Same as calling `Bluebird.map(thisPromise, mapper)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
*/
map<U>(mapper: IterateFunction<IterableItem<R>, U>, options?: Bluebird.ConcurrencyOption): Bluebird<R extends Iterable<any> ? U[] : never>;
map<U, Q>(this: Bluebird<R & Iterable<Q>>, mapper: IterateFunction<Q, U>, options?: Bluebird.ConcurrencyOption): Bluebird<U[]>;
/**
* Same as calling `Promise.reduce(thisPromise, Function reducer, initialValue)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
*/
reduce<U>(reducer: (memo: U, item: IterableItem<R>, index: number, arrayLength: number) => Resolvable<U>, initialValue?: U): Bluebird<R extends Iterable<any> ? U : never>;
reduce<U, Q>(this: Bluebird<R & Iterable<Q>>, reducer: (memo: U, item: Q, index: number, arrayLength: number) => Resolvable<U>, initialValue?: U): Bluebird<U>;
/**
* Same as calling ``Promise.filter(thisPromise, filterer)``. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
*/
filter(filterer: IterateFunction<IterableItem<R>, boolean>, options?: Bluebird.ConcurrencyOption): Bluebird<IterableOrNever<R>>;
filter<Q>(this: Bluebird<R & Iterable<Q>>, filterer: IterateFunction<Q, boolean>, options?: Bluebird.ConcurrencyOption): Bluebird<R>;
/**
* Same as calling ``Bluebird.each(thisPromise, iterator)``. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
*/
each(iterator: IterateFunction<IterableItem<R>, any>): Bluebird<IterableOrNever<R>>;
each<Q>(this: Bluebird<R & Iterable<Q>>, iterator: IterateFunction<Q, any>): Bluebird<R>;
/**
* Same as calling ``Bluebird.mapSeries(thisPromise, iterator)``. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
*/
mapSeries<U>(iterator: IterateFunction<IterableItem<R>, U>): Bluebird<R extends Iterable<any> ? U[] : never>;
mapSeries<U, Q>(this: Bluebird<R & Iterable<Q>>, iterator: IterateFunction<Q, U>): Bluebird<U[]>;
/**
* Cancel this `promise`. Will not do anything if this promise is already settled or if the cancellation feature has not been enabled

36
types/camljs/camljs-tests.ts
View File

@ -1,4 +1,4 @@
import CamlBuilder from 'camljs'
var caml = new CamlBuilder().Where()
.Any(
@ -53,3 +53,37 @@ caml = CamlBuilder.Expression()
.ToString();
caml = new CamlBuilder().Where().DateTimeField("Created").GreaterThan(new Date(Date.UTC(2013,0,1))).ToString();
// Aggregations and extended syntax of GroupBy
var query = new CamlBuilder()
.View(["Category", { count: "ID" }, { sum: "Amount" }])
.Query()
.GroupBy("Category", true, 100)
.ToString();
// ContentTypeId field
var query = new CamlBuilder()
.Where()
.TextField("Title").EqualTo("Document")
.And()
.ContentTypeIdField().BeginsWith("0x101")
.ToString();
// joins
var query = new CamlBuilder()
.View(["Title", "Country", "Population"])
.LeftJoin("Country", "Country").Select("y4r6", "Population")
.Query()
.Where()
.NumberField("Population").LessThan(10)
.ToString();
// RowLimit & Scope
var camlBuilder1 = new CamlBuilder()
.View(["ID", "Created"])
.RowLimit(20, true)
.Scope(CamlBuilder.ViewScope.RecursiveAll)
.Query()
.Where()
.TextField("Title").BeginsWith("A")
.ToString();

77
types/camljs/index.d.ts vendored
View File

@ -1,8 +1,8 @@
// Type definitions for camljs
// Project: http://camljs.codeplex.com
// Definitions by: Andrey Markeev <http://markeev.com>
// Project: https://github.com/andrei-markeev/camljs
// Definitions by: Andrey Markeev <https://github.com/andrei-markeev>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.7
declare class CamlBuilder {
constructor();
@ -10,25 +10,43 @@ declare class CamlBuilder {
Where(): CamlBuilder.IFieldExpression;
/** Generate <View> tag for SP.CamlQuery
@param viewFields If omitted, default view fields are requested; otherwise, only values for the fields with the specified internal names are returned.
Specifying view fields is a good practice, as it decreases traffic between server and client. */
View(viewFields?: string[]): CamlBuilder.IView;
Specifying view fields is a good practice, as it decreases traffic between server and client.
Additionally you can specify aggregated fields, e.g. { count: "<field name>" }, { sum: "<field name>" }, etc.. */
View(viewFields?: CamlBuilder.ViewField[]): CamlBuilder.IView;
/** Generate <ViewFields> tag for SPServices */
ViewFields(viewFields: string[]): CamlBuilder.IFinalizableToString;
/** Use for:
1. SPServices CAMLQuery attribute
2. Creating partial expressions
3. In conjunction with Any & All clauses
*/
*/
static Expression(): CamlBuilder.IFieldExpression;
static FromXml(xml: string): CamlBuilder.IRawQuery;
}
declare namespace CamlBuilder {
interface IView extends IJoinable, IFinalizable {
declare module CamlBuilder {
type Aggregation = {
count: string;
} | {
sum: string;
} | {
avg: string;
} | {
max: string;
} | {
min: string;
} | {
stdev: string;
} | {
var: string;
};
type ViewField = string | Aggregation;
interface IView extends IFinalizable {
/** Define query */
Query(): IQuery;
/** Define maximum amount of returned records */
RowLimit(limit: number, paged?: boolean): IView;
/** Define view scope */
Scope(scope: ViewScope): IView;
}
interface IJoinable {
/** Join the list you're querying with another list.
Joins are only allowed through a lookup field relation.
@param lookupFieldInternalName Internal name of the lookup field, that points to the list you're going to join in.
@ -40,22 +58,39 @@ declare namespace CamlBuilder {
@alias alias for the joined list */
LeftJoin(lookupFieldInternalName: string, alias: string): IJoin;
}
interface IJoinable {
/** Join the list you're querying with another list.
Joins are only allowed through a lookup field relation.
@param lookupFieldInternalName Internal name of the lookup field, that points to the list you're going to join in.
@param alias Alias for the joined list
@param fromList (optional) List where the lookup column resides - use it only for nested joins */
InnerJoin(lookupFieldInternalName: string, alias: string, fromList?: string): IJoin;
/** Join the list you're querying with another list.
Joins are only allowed through a lookup field relation.
@param lookupFieldInternalName Internal name of the lookup field, that points to the list you're going to join in.
@param alias Alias for the joined list
@param fromList (optional) List where the lookup column resides - use it only for nested joins */
LeftJoin(lookupFieldInternalName: string, alias: string, fromList?: string): IJoin;
}
interface IJoin extends IJoinable {
/** Select projected field for using in the main Query body
@param remoteFieldAlias By this alias, the field can be used in the main Query body. */
Select(remoteFieldInternalName: string, remoteFieldAlias: string): IProjectableView;
}
interface IProjectableView extends IView {
interface IProjectableView extends IJoinable {
/** Define query */
Query(): IQuery;
/** Define maximum amount of returned records */
RowLimit(limit: number, paged?: boolean): IView;
/** Define view scope */
Scope(scope: ViewScope): IView;
/** Select projected field for using in the main Query body
@param remoteFieldAlias By this alias, the field can be used in the main Query body. */
Select(remoteFieldInternalName: string, remoteFieldAlias: string): IProjectableView;
}
enum ViewScope {
/** */
Recursive = 0,
/** */
RecursiveAll = 1,
/** */
FilesOnly = 2,
}
interface IQuery extends IGroupable {
@ -85,8 +120,9 @@ declare namespace CamlBuilder {
}
interface IGroupable extends ISortable {
/** Adds GroupBy clause to the query.
@param collapse If true, only information about the groups is retrieved, otherwise items are also retrieved. */
GroupBy(fieldInternalName: any): IGroupedQuery;
@param collapse If true, only information about the groups is retrieved, otherwise items are also retrieved.
@param groupLimit Return only first N groups */
GroupBy(fieldInternalName: any, collapse?: boolean, groupLimit?: number): IGroupedQuery;
}
interface IExpression extends IGroupable {
/** Adds And clause to the query. */
@ -113,6 +149,12 @@ declare namespace CamlBuilder {
Any(conditions: IExpression[]): IExpression;
/** Specifies that a condition will be tested against the field with the specified internal name, and the type of this field is Text */
TextField(internalName: string): ITextFieldExpression;
/** Specifies that a condition will be tested against the field with the specified internal name, and the type of this field is ContentTypeId */
ContentTypeIdField(internalName?: string): ITextFieldExpression;
/** Specifies that a condition will be tested against the field with the specified internal name, and the type of this field is Choice */
ChoiceField(internalName: string): ITextFieldExpression;
/** Specifies that a condition will be tested against the field with the specified internal name, and the type of this field is Computed */
ComputedField(internalName: string): ITextFieldExpression;
/** Specifies that a condition will be tested against the field with the specified internal name, and the type of this field is Boolean */
BooleanField(internalName: string): IBooleanFieldExpression;
/** Specifies that a condition will be tested against the field with the specified internal name, and the type of this field is URL */
@ -360,7 +402,7 @@ declare namespace CamlBuilder {
Year = 4,
}
class Internal {
static createView(viewFields?: string[]): IView;
static createView(viewFields?: ViewField[]): IView;
static createViewFields(viewFields: string[]): IFinalizableToString;
static createWhere(): IFieldExpression;
static createExpression(): IFieldExpression;
@ -401,3 +443,4 @@ declare namespace CamlBuilder {
};
}
}
export = CamlBuilder;

3
types/camljs/tsconfig.json
View File

@ -14,7 +14,8 @@
],
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true
"forceConsistentCasingInFileNames": true,
"esModuleInterop": true
},
"files": [
"index.d.ts",

9
types/canvas-confetti/canvas-confetti-tests.ts
View File

@ -43,3 +43,12 @@ confetti({
y: 0.6
}
});
const canvas = document.createElement('canvas');
const myConfetti = confetti.create(canvas);
myConfetti();
myConfetti({
particleCount: 150
});

10
types/canvas-confetti/index.d.ts vendored
View File

@ -1,4 +1,4 @@
// Type definitions for canvas-confetti 0.0
// Type definitions for canvas-confetti 0.1
// Project: https://github.com/catdad/canvas-confetti#readme
// Definitions by: Martin Tracey <https://github.com/matracey>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
@ -81,6 +81,14 @@ declare namespace confetti {
*/
y?: number;
}
interface GlobalOptions {
resize: boolean;
}
function create(
canvas: HTMLCanvasElement,
options?: GlobalOptions
): (options?: Options) => Promise<null> | null;
}
export = confetti;

3
types/canvas-confetti/tsconfig.json
View File

@ -2,7 +2,8 @@
"compilerOptions": {
"module": "commonjs",
"lib": [
"es6"
"es6",
"dom"
],
"noImplicitAny": true,
"noImplicitThis": true,

7
types/cassandra-driver/index.d.ts vendored
View File

@ -87,7 +87,8 @@ export namespace policies {
interface DecisionInfo {
decision: number;
consistency: number;
consistency?: number;
useCurrentHost?: boolean;
}
interface RequestInfo {
@ -115,8 +116,8 @@ export namespace policies {
onReadTimeout(requestInfo: RequestInfo, consistency: types.consistencies, received: number, blockFor: number, isDataPresent: boolean): DecisionInfo;
onUnavailable(requestInfo: RequestInfo, consistency: types.consistencies, required: number, alive: number): DecisionInfo;
onWriteTimeout(requestInfo: RequestInfo, consistency: types.consistencies, received: number, blockFor: number, writeType: string): DecisionInfo;
rethrowResult(): { decision: retryDecision };
retryResult(consistency?: types.consistencies, useCurrentHost?: boolean): { decision: retryDecision, consistency: types.consistencies, useCurrentHost: boolean };
rethrowResult(): DecisionInfo;
retryResult(consistency?: types.consistencies, useCurrentHost?: boolean): DecisionInfo;
}
}

2
types/chai-enzyme/index.d.ts vendored
View File

@ -2,7 +2,7 @@
// Project: https://github.com/producthunt/chai-enzyme
// Definitions by: Alexey Svetliakov <https://github.com/asvetliakov>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.8
// TypeScript Version: 3.1
/// <reference types="enzyme" />

6
types/chromecast-caf-receiver/cast.framework.messages.d.ts vendored
View File

@ -1441,6 +1441,12 @@ export interface MediaInformation {
* The media tracks.
*/
tracks?: Track[];
/**
* VMAP ad request configuration. Used if breaks and breakClips are not
* provided.
*/
vmapAdsRequest?: VastAdsRequest;
}
/**

2
types/commercetools__enzyme-extensions/index.d.ts vendored
View File

@ -2,7 +2,7 @@
// Project: https://github.com/commercetools/enzyme-extensions
// Definitions by: Christian Rackerseder <https://github.com/screendriver>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.8
// TypeScript Version: 3.1
import * as enzyme from 'enzyme';

2
types/connect-datadog/index.d.ts vendored
View File

@ -1,5 +1,5 @@
// Type definitions for connect-datadog 0.0
// Project: https://github.com/AppPress/node-connect-datadog
// Project: https://github.com/datadog/node-connect-datadog
// Definitions by: Moshe Good <https://github.com/moshegood>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.2

2
types/cordova-sqlite-storage/index.d.ts vendored
View File

@ -1,5 +1,5 @@
// Type definitions for cordova-sqlite-storage 1.5
// Project: https://github.com/litehelpers/Cordova-sqlite-storage
// Project: https://github.com/xpbrew/cordova-sqlite-storage
// Definitions by: rafw87 <https://github.com/rafw87>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

4
types/cote/cote-tests.ts
View File

@ -35,6 +35,7 @@ class Readme {
});
const req = {
__subset: 'subset',
type: 'randomRequest',
payload: {
val: Math.floor(Math.random() * 10)
@ -52,7 +53,8 @@ class Readme {
name: 'Random Responder',
namespace: 'rnd',
key: 'a certain key',
respondsTo: ['randomRequest']
respondsTo: ['randomRequest'],
subset: 'subset'
});
interface RandomRequest {

7
types/cote/index.d.ts vendored
View File

@ -1,4 +1,4 @@
// Type definitions for cote 0.17
// Type definitions for cote 0.19
// Project: https://github.com/dashersw/cote#readme
// Definitions by: makepost <https://github.com/makepost>
// Labat Robin <https://github.com/roblabat>
@ -115,6 +115,11 @@ export interface ResponderAdvertisement extends Advertisement {
* Request types that a Responder can listen to.
*/
respondsTo?: string[];
/**
* Advertisement attribute that lets you target a subgroup of responders using the __subset property of a request.
*/
subset?: string;
}
export class Publisher extends Component {

16
types/cron/cron-tests.ts
View File

@ -1,5 +1,7 @@
import cron = require('cron');
import moment = require('moment');
var CronJob = cron.CronJob;
var CronTime = cron.CronTime;
@ -34,6 +36,16 @@ var job = new CronJob(new Date(), () => {
timeZone /* Time zone of this job. */
);
// Another example with Moment
var job = new CronJob(moment(), () => {
/* runs once at the specified moment. */
}, () => {
/* This function is executed when the job stops */
},
true, /* Start the job right now */
timeZone /* Time zone of this job. */
);
// For good measure
var job = new CronJob({
cronTime: '00 30 11 * * 1-5',
@ -48,7 +60,8 @@ var job = new CronJob({
timeZone: 'America/Los_Angeles'
});
console.log(job.lastDate());
console.log(job.nextDates(1));
console.log(job.nextDates());// Should be a Moment object
console.log(job.nextDates(1));// Should be an array of Moment object
console.log(job.running);
job.setTime(new CronTime('00 30 11 * * 1-2'));
job.start();
@ -67,4 +80,5 @@ try {
// Check cronTime fomat
new CronTime('* * * * * *');
new CronTime(new Date());
new CronTime(moment());

22
types/cron/index.d.ts vendored
View File

@ -4,6 +4,8 @@
// Lundarl Gholoi <https://github.com/winup>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
import { Moment } from 'moment';
export declare class CronTime {
/**
* Create a new ```CronTime```.
@ -11,13 +13,14 @@ export declare class CronTime {
* @param zone Timezone name. You can check all timezones available at [Moment Timezone Website](http://momentjs.com/timezone/).
* @param utcOffset UTC offset. Don't use both ```zone``` and ```utcOffset``` together or weird things may happen.
*/
constructor(source: string | Date, zone?: string, utcOffset?: string | number);
constructor(source: string | Date | Moment, zone?: string, utcOffset?: string | number);
/**
* Tells you when ```CronTime``` will be run.
* @param i Indicate which turn of run after now. If not given return next run time.
*/
public sendAt(i?: number): Date;
public sendAt(): Moment;
public sendAt(i?: number): Moment[];
/**
* Get the number of milliseconds in the future at which to fire our callbacks.
*/
@ -28,7 +31,7 @@ export declare interface CronJobParameters {
/**
* The time to fire off your job. This can be in the form of cron syntax or a JS ```Date``` object.
*/
cronTime: string | Date;
cronTime: string | Date | Moment;
/**
* The function to fire at the specified time. If an ```onComplete``` callback was provided, ```onTick``` will receive it as an argument. ```onTick``` may call ```onComplete``` when it has finished its work.
*/
@ -85,7 +88,7 @@ export declare class CronJob {
* @param utcOffset This allows you to specify the offset of your timezone rather than using the ```timeZone``` param. Probably don't use both ```timeZone``` and ```utcOffset``` together or weird things may happen.
* @param unrefTimeout If you have code that keeps the event loop running and want to stop the node process when that finishes regardless of the state of your cronjob, you can do so making use of this parameter. This is off by default and cron will run as if it needs to control the event loop. For more information take a look at [timers#timers_timeout_unref](https://nodejs.org/api/timers.html#timers_timeout_unref) from the NodeJS docs.
*/
constructor(cronTime: string | Date, onTick: () => void, onComplete?: () => void, start?: boolean, timeZone?: string, context?: any, runOnInit?: boolean, utcOffset?: string | number, unrefTimeout?: boolean);
constructor(cronTime: string | Date | Moment, onTick: () => void, onComplete?: () => void, start?: boolean, timeZone?: string, context?: any, runOnInit?: boolean, utcOffset?: string | number, unrefTimeout?: boolean);
/**
* Create a new ```CronJob```.
* @param options Job parameters.
@ -113,7 +116,8 @@ export declare class CronJob {
* Tells you when a ```CronTime``` will be run.
* @param i Indicate which turn of run after now. If not given return next run time.
*/
public nextDates(i?: number): Date;
public nextDates(): Moment;
public nextDates(i?: number): Moment[];
/**
* Add another ```onTick``` function.
* @param callback Target function.
@ -122,8 +126,8 @@ export declare class CronJob {
}
export declare var job:
((cronTime: string | Date, onTick: () => void, onComplete?: () => void, start?: boolean, timeZone?: string, context?: any, runOnInit?: boolean, utcOffset?: string | number, unrefTimeout?: boolean) => CronJob)
((cronTime: string | Date | Moment, onTick: () => void, onComplete?: () => void, start?: boolean, timeZone?: string, context?: any, runOnInit?: boolean, utcOffset?: string | number, unrefTimeout?: boolean) => CronJob)
| ((options: CronJobParameters) => CronJob);
export declare var time: (source: string | Date, zone?: string) => CronTime;
export declare var sendAt: (cronTime: CronTime) => Date;
export declare var timeout: (cronTime: CronTime) => number;
export declare var time: (source: string | Date | Moment, zone?: string) => CronTime;
export declare var sendAt: (cronTime: string | Date | Moment) => Moment;
export declare var timeout: (cronTime: string | Date | Moment) => number;

2
types/dd-trace/package.json → types/cron/package.json
View File

@ -1,6 +1,6 @@
{
"private": true,
"dependencies": {
"opentracing": ">=0.14.1"
"moment": ">=2.14.0"
}
}

3
types/d3-array/d3-array-tests.ts
View File

@ -608,7 +608,8 @@ const testObject = {
};
const p1: Array<number | string | Date | number[]> = d3Array.permute(testObject, ['name', 'val', 'when', 'more']);
const p2: Array<Date | number[]> = d3Array.permute(testObject, ['when', 'more']);
// $ExpectType: Array<Date | number[]>
const p2 = d3Array.permute(testObject, ['when', 'more']);
// $ExpectError
const p3 = d3Array.permute(testObject, ['when', 'unknown']);

56
types/dd-trace/dd-trace-tests.ts
View File

@ -1,56 +0,0 @@
import * as tracer from "dd-trace";
import SpanContext = require("dd-trace/src/opentracing/span_context");
tracer.init({
enabled: true,
service: "MyLovelyService",
hostname: "localhost",
port: 8126,
env: "dev",
logger: {
debug: msg => {},
error: err => {},
}
});
function useWebFrameworkPlugin(plugin: "express" | "hapi" | "koa" | "restify") {
tracer.use(plugin, {
service: "incoming-request",
headers: ["User-Agent"],
validateStatus: code => code !== 418,
});
}
tracer.use("graphql", {
depth: 1,
// Can’t use spread operator here due to https://github.com/Microsoft/TypeScript/issues/10727
// tslint:disable-next-line:prefer-object-spread
variables: variables => Object.assign({}, variables, { password: "REDACTED" }),
});
tracer.use("http", {
splitByDomain: true,
});
tracer
.trace("web.request", {
service: "my_service",
childOf: new SpanContext({ traceId: 1337, spanId: 42 }), // childOf must be an instance of this type. See: https://github.com/DataDog/dd-trace-js/blob/master/src/opentracing/tracer.js#L99
tags: {
env: "dev",
},
})
.then(span => {
span.setTag("my_tag", "my_value");
span.finish();
});
const parentScope = tracer.scopeManager().active();
const span = tracer.startSpan("memcached", {
childOf: parentScope && parentScope.span(),
tags: {
"service.name": "my-memcached",
"resource.name": "get",
"span.type": "memcached",
},
});

275
types/dd-trace/index.d.ts vendored
View File

@ -1,275 +0,0 @@
// Type definitions for dd-trace-js 0.7
// Project: https://github.com/DataDog/dd-trace-js
// Definitions by: Colin Bradley <https://github.com/ColinBradley>
// Eloy Durán <https://github.com/alloy>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.4
// Prettified with:
// $ prettier --parser typescript --tab-width 4 --semi --trailing-comma es5 --write --print-width 120 types/dd-trace/{,*}/*.ts*
import { Tracer, Span, SpanContext } from "opentracing";
import DatadogSpanContext = require("./src/opentracing/span_context");
declare var trace: TraceProxy;
export = trace;
declare class TraceProxy extends Tracer {
/**
* Initializes the tracer. This should be called before importing other libraries.
*/
init(options?: TracerOptions): this;
/**
* Enable and optionally configure a plugin.
* @param plugin The name of a built-in plugin.
* @param config Configuration options.
*/
use<P extends Plugin>(plugin: P, config: PluginConfiguration[P]): this;
/**
* Initiate a trace and creates a new span.
* @param operationName The operation name to be used for this span.
* @param options Configuration options. These will take precedence over environment variables.
*/
trace(operationName: string, options: TraceOptions): Promise<Span>;
/**
* Initiate a trace and creates a new span.
* @param operationName The operation name to be used for this span.
* @param options Configuration options. These will take precedence over environment variables.
*/
trace(operationName: string, options: TraceOptions, callback: (span: Span) => void): void;
/**
* Get the span from the current context.
* @returns The current span or null if outside a trace context.
*/
currentSpan(): Span | null;
/**
* Get the scope manager to manager context propagation for the tracer.
*/
scopeManager(): ScopeManager;
}
interface TracerOptions {
/**
* Whether to enable the tracer.
* @default true
*/
enabled?: boolean;
/**
* Enable debug logging in the tracer.
* @default false
*/
debug?: boolean;
/**
* The service name to be used for this program.
*/
service?: string;
/**
* The address of the trace agent that the tracer will submit to.
* @default 'localhost'
*/
hostname?: string;
/**
* The port of the trace agent that the tracer will submit to.
* @default 8126
*/
port?: number | string;
/**
* Set an application’s environment e.g. prod, pre-prod, stage.
*/
env?: string;
/**
* Percentage of spans to sample as a float between 0 and 1.
* @default 1
*/
sampleRate?: number;
/**
* Interval in milliseconds at which the tracer will submit traces to the agent.
* @default 2000
*/
flushInterval?: number;
/**
* Experimental features can be enabled all at once by using true or individually using key / value pairs.
* @default {}
*/
experimental?: ExperimentalOptions | boolean;
/**
* Whether to load all built-in plugins.
* @default true
*/
plugins?: boolean;
/**
* Custom logger to be used by the tracer (if debug = true),
* should support debug() and error() methods
* see https://datadog.github.io/dd-trace-js/#custom-logging__anchor
*/
logger?: {
debug: (message: string) => void;
error: (err: Error) => void;
};
/**
* Global tags that should be assigned to every span.
*/
tags?: { [key: string]: any };
}
interface ExperimentalOptions {}
interface TraceOptions {
/**
* The service name to be used for this span.
* The service name from the tracer will be used if this is not provided.
*/
service?: string;
/**
* The resource name to be used for this span.
* The operation name will be used if this is not provided.
*/
resource?: string;
/**
* The span type to be used for this span.
*/
type?: string;
/**
* The parent span or span context for the new span. Generally this is not needed as it will be
* fetched from the current context.
* If creating your own, this must be an instance of DatadogSpanContext from ./src/opentracing/span_context
* See: https://github.com/DataDog/dd-trace-js/blob/master/src/opentracing/tracer.js#L99
*/
childOf?: Span | SpanContext | DatadogSpanContext;
/**
* Global tags that should be assigned to every span.
*/
tags?: { [key: string]: any } | string;
}
declare class ScopeManager {
/**
* Get the current active scope or null if there is none.
*
* @todo The dd-trace source returns null, but opentracing's childOf span
* option is typed as taking undefined or a scope, so using undefined
* here instead.
*/
active(): Scope | undefined;
/**
* Activate a new scope wrapping the provided span.
*
* @param span The span for which to activate the new scope.
* @param finishSpanOnClose Whether to automatically finish the span when the scope is closed.
*/
activate(span: Span, finishSpanOnClose?: boolean): Scope;
}
declare class Scope {
/**
* Get the span wrapped by this scope.
*/
span(): Span;
/**
* Close the scope, and finish the span if the scope was created with `finishSpanOnClose` set to true.
*/
close(): void;
}
type Plugin =
| "amqp10"
| "amqplib"
| "bluebird"
| "elasticsearch"
| "express"
| "graphql"
| "hapi"
| "http"
| "ioredis"
| "koa"
| "memcached"
| "mongodb-core"
| "mysql"
| "mysql2"
| "pg"
| "q"
| "redis"
| "restify"
| "when";
interface BasePluginOptions {
/**
* The service name to be used for this plugin.
*/
service?: string;
}
interface BaseWebFrameworkPluginOptions extends BasePluginOptions {
/**
* An array of headers to include in the span metadata.
*/
headers?: string[];
/**
* Callback function to determine if there was an error. It should take a
* status code as its only parameter and return `true` for success or `false`
* for errors.
*/
validateStatus?: (code: number) => boolean;
}
interface ExpressPluginOptions extends BaseWebFrameworkPluginOptions {}
interface HapiPluginOptions extends BaseWebFrameworkPluginOptions {}
interface KoaPluginOptions extends BaseWebFrameworkPluginOptions {}
interface RestifyPluginOptions extends BaseWebFrameworkPluginOptions {}
interface GraphQLPluginOptions extends BasePluginOptions {
/**
* The maximum depth of fields/resolvers to instrument. Set to `0` to only
* instrument the operation or to -1 to instrument all fields/resolvers.
*/
depth?: number;
/**
* A callback to enable recording of variables. By default, no variables are
* recorded. For example, using `variables => variables` would record all
* variables.
*/
variables?: <T extends { [key: string]: any }>(variables: T) => Partial<T>;
}
interface HTTPPluginOptions extends BasePluginOptions {
/**
* Use the remote endpoint host as the service name instead of the default.
*/
splitByDomain?: boolean;
}
type PluginConfiguration = { [K in Plugin]: BasePluginOptions } & {
express: ExpressPluginOptions;
graphql: GraphQLPluginOptions;
hapi: HapiPluginOptions;
http: HTTPPluginOptions;
koa: KoaPluginOptions;
restify: RestifyPluginOptions;
};

28
types/dd-trace/src/opentracing/span_context.d.ts vendored
View File

@ -1,28 +0,0 @@
import { SpanContext } from 'opentracing';
declare class DatadogSpanContext extends SpanContext {
/**
* Used to create references to parent spans.
* See: https://github.com/DataDog/dd-trace-js/blob/master/src/opentracing/tracer.js#L99
*/
constructor(props: SpanContextLike);
}
interface SpanContextLike {
traceId: number;
spanId: number;
parentId?: number | null;
sampled?: boolean;
baggageItems?: { [key: string]: string };
trace?: {
started: number[],
finished: number[]
};
}
export = DatadogSpanContext;

64
types/detect-browser/detect-browser-tests.ts
View File

@ -1,64 +0,0 @@
import { BrowserName, BrowserInfo, detect } from 'detect-browser';
const browser = detect();
if (browser) {
const name: string | undefined = browser.name;
const version: string | undefined = browser.version;
const os: string | undefined | null = browser.os;
const bot: true | undefined = browser.bot;
}
const browserInfos: BrowserInfo[] = [];
// Those that can happen when 'detect' hits on a browser
browserInfos.push(
{
name: "chrome",
version: "1.2.3",
os: null
}
);
browserInfos.push(
{
name: "edge",
version: "24.5.3",
os: "Sun OS"
}
);
browserInfos.push(
{
name: "edge",
version: "13.0",
os: "Windows 10",
bot: true
}
);
// Those that could be returned when it's a bot
browserInfos.push(
{
name: "facebook",
version: "1.0.2",
os: "Linux",
bot: true
}
);
browserInfos.push(
{
name: "crios",
version: "2.9.4",
os: undefined,
bot: true
}
);
browserInfos.push(
{
bot: true
}
);

42
types/detect-browser/index.d.ts vendored
View File

@ -1,42 +0,0 @@
// Type definitions for detect-browser 3.0
// Project: https://github.com/DamonOehlman/detect-browser
// Definitions by: Rogier Schouten <https://github.com/rogierschouten>
// Brian Caruso <https://github.com/carusology>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
export {};
export type BrowserName =
"aol" |
"android" |
"bb10" |
"chrome" |
"crios" |
"edge" |
"facebook" |
"firefox" |
"fxios" |
"ie" |
"instagram" |
"ios" |
"ios-webview" |
"kakaotalk" |
"node" |
"opera" |
"phantomjs" |
"safari" |
"samsung" |
"vivaldi" |
"yandexbrowser";
export interface BrowserInfo {
name?: string;
version?: string;
os?: string | null;
bot?: true;
}
export function detect(): null | false | BrowserInfo;
export function detectOS(userAgentString: string): null | string;
export function parseUserAgent(userAgentString: string): null | BrowserInfo;
export function getNodeVersion(): false | BrowserInfo;

10
types/detect-browser/tslint.json
View File

@ -1,10 +0,0 @@
{
"extends": "dtslint/dt.json",
"rules": {
"indent": [
true,
"spaces",
4
]
}
}

5
types/discord-rpc/index.d.ts vendored
View File

@ -1,6 +1,7 @@
// Type definitions for discord-rpc 3.0
// Project: https://github.com/discordjs/RPC#readme
// Definitions by: Jason Bothell <https://github.com/jasonhaxstuff>
// Jack Baron <https://github.com/lolPants>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
import { EventEmitter } from 'events';
@ -66,6 +67,10 @@ export class Client extends EventEmitter {
subscribe(event: string, args: any, callback: (data: any) => void): Promise<Subscription>;
destroy(): Promise<void>;
on(event: 'ready' | 'connected', listener: () => void): this;
once(event: 'ready' | 'connected', listener: () => void): this;
off(event: 'ready' | 'connected', listener: () => void): this;
}
export interface RPCClientOptions {

2
types/drivelist/index.d.ts vendored
View File

@ -1,5 +1,5 @@
// Type definitions for drivelist 6.4
// Project: https://github.com/resin-io-modules/drivelist
// Project: https://github.com/balena-io-modules/drivelist
// Definitions by: Xiao Deng <https://github.com/WholeMilk>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

5
types/ejs/tsconfig.json
View File

@ -12,6 +12,9 @@
"typeRoots": [
"../"
],
"paths": {
"lru-cache": ["lru-cache/v4"]
},
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true
@ -20,4 +23,4 @@
"index.d.ts",
"ejs-tests.ts"
]
}
}

2
types/emojione/index.d.ts vendored
View File

@ -1,5 +1,5 @@
// Type definitions for emojione 2.2
// Project: https://github.com/Ranks/emojione, http://www.emojione.com
// Project: https://github.com/Ranks/emojione, https://www.emojione.com
// Definitions by: Danilo Bargen <https://github.com/dbrgn>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

2
types/enzyme-adapter-react-15.4/index.d.ts vendored
View File

@ -2,7 +2,7 @@
// Project: http://airbnb.io/enzyme/
// Definitions by: Nabeelah Ali <https://github.com/nali>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.8
// TypeScript Version: 3.1
import { EnzymeAdapter } from 'enzyme';

2
types/enzyme-adapter-react-15/index.d.ts vendored
View File

@ -2,7 +2,7 @@
// Project: https://github.com/airbnb/enzyme, http://airbnb.io/enzyme
// Definitions by: Tanguy Krotoff <https://github.com/tkrotoff>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.8
// TypeScript Version: 3.1
import { EnzymeAdapter } from 'enzyme';

2
types/enzyme-adapter-react-16/index.d.ts vendored
View File

@ -2,7 +2,7 @@
// Project: https://github.com/airbnb/enzyme, http://airbnb.io/enzyme
// Definitions by: Tanguy Krotoff <https://github.com/tkrotoff>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.8
// TypeScript Version: 3.1
import { EnzymeAdapter } from 'enzyme';

2
types/enzyme-async-helpers/index.d.ts vendored
View File

@ -2,7 +2,7 @@
// Project: https://github.com/zth/enzyme-async-helpers
// Definitions by: Kim Ehrenpohl <https://github.com/kimehrenpohl>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.8
// TypeScript Version: 3.1
import { ReactWrapper, EnzymeSelector } from 'enzyme';

2
types/enzyme-redux/index.d.ts vendored
View File

@ -2,7 +2,7 @@
// Project: https://github.com/Knegusen/enzyme-redux#readme
// Definitions by: Dennis Axelsson <https://github.com/knegusen>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.8
// TypeScript Version: 3.1
import { ReactWrapper, ShallowWrapper } from 'enzyme';
import { ReactElement } from 'react';

2
types/enzyme-to-json/index.d.ts vendored
View File

@ -2,7 +2,7 @@
// Project: https://github.com/adriantoine/enzyme-to-json#readme
// Definitions by: Joscha Feth <https://github.com/joscha>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.8
// TypeScript Version: 3.1
import { ReactWrapper, ShallowWrapper } from 'enzyme';

13
types/enzyme/enzyme-tests.tsx
View File

@ -10,7 +10,7 @@ import {
ShallowRendererProps,
ComponentClass as EnzymeComponentClass
} from "enzyme";
import { Component, ReactElement, HTMLAttributes, ComponentClass, StatelessComponent } from "react";
import { Component, ReactElement, ReactNode, HTMLAttributes, ComponentClass, StatelessComponent } from "react";
// Help classes/interfaces
interface MyComponentProps {
@ -35,6 +35,10 @@ interface MyComponentState {
stateProperty: string;
}
interface MyRenderPropProps {
children: (params: string) => ReactNode;
}
function toComponentType<T>(Component: ComponentClass<T> | StatelessComponent<T>): ComponentClass<T> | StatelessComponent<T> {
return Component;
}
@ -59,6 +63,8 @@ class AnotherComponent extends Component<AnotherComponentProps> {
}
}
class MyRenderPropComponent extends Component<MyRenderPropProps> {}
const MyStatelessComponent = (props: StatelessProps) => <span />;
const AnotherStatelessComponent = (props: AnotherStatelessProps) => <span />;
@ -477,6 +483,11 @@ function ShallowWrapperTest() {
shallowWrapper = new ShallowWrapper<MyComponentProps, MyComponentState>(<MyComponent stringProp="1" numberProp={1} />, undefined, { lifecycleExperimental: true });
shallowWrapper = new ShallowWrapper<MyComponentProps, MyComponentState>(<MyComponent stringProp="1" numberProp={1} />, shallowWrapper, { lifecycleExperimental: true });
}
function test_renderProp() {
let shallowWrapper = new ShallowWrapper<MyRenderPropProps>(<MyRenderPropComponent children={(params) => <div className={params} />} />);
shallowWrapper = shallowWrapper.renderProp('children')('test');
}
}
// ReactWrapper

12
types/enzyme/index.d.ts vendored
View File

@ -1,4 +1,4 @@
// Type definitions for Enzyme 3.1
// Type definitions for Enzyme 3.9
// Project: https://github.com/airbnb/enzyme
// Definitions by: Marian Palkus <https://github.com/MarianPalkus>
// Cap3 <http://www.cap3.de>
@ -8,8 +8,9 @@
// MartynasZilinskas <https://github.com/MartynasZilinskas>
// Torgeir Hovden <https://github.com/thovden>
// Martin Hochel <https://github.com/hotell>
// Christian Rackerseder <https://github.com/screendriver>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.8
// TypeScript Version: 3.1
/// <reference types="cheerio" />
import { ReactElement, Component, AllHTMLAttributes as ReactHTMLAttributes, SVGAttributes as ReactSVGAttributes } from "react";
@ -363,6 +364,8 @@ export interface CommonWrapper<P = {}, S = {}, C = Component<P, S>> {
length: number;
}
export type Parameters<T> = T extends (...args: infer A) => any ? A : never;
// tslint:disable-next-line no-empty-interface
export interface ShallowWrapper<P = {}, S = {}, C = Component> extends CommonWrapper<P, S, C> { }
export class ShallowWrapper<P = {}, S = {}, C = Component> {
@ -447,6 +450,11 @@ export class ShallowWrapper<P = {}, S = {}, C = Component> {
* Returns a wrapper with the direct parent of the node in the current wrapper.
*/
parent(): ShallowWrapper<any, any>;
/**
* Returns a wrapper of the node rendered by the provided render prop.
*/
renderProp<PropName extends keyof P>(prop: PropName): (...params: Parameters<P[PropName]>) => ShallowWrapper<any, never>;
}
// tslint:disable-next-line no-empty-interface

20
types/ethereumjs-abi/ethereumjs-abi-tests.ts
View File

@ -1,5 +1,17 @@
import { methodID, soliditySHA256, soliditySHA3 } from 'ethereumjs-abi';
import * as abi from 'ethereumjs-abi';
methodID('foo', ['uint256', 'string']);
soliditySHA3(['uint256', 'string'], [0, 'Alice']);
soliditySHA256(['uint256', 'string'], [0, 'Alice']);
const types = ['uint256', 'string'];
const values = [0, 'Alice'];
const signature = 'foo(uint256,string):(uint256)';
abi.eventID('foo', types);
abi.methodID('foo', types);
abi.soliditySHA3(types, values);
abi.soliditySHA256(types, values);
abi.solidityRIPEMD160(types, values);
const simpleEncoded = abi.simpleEncode(signature, ...values);
abi.simpleDecode(signature, simpleEncoded);
const rawEncoded = abi.rawEncode(types, values);
abi.rawDecode(types, rawEncoded);
abi.solidityPack(types, values);
const serpentSig = abi.toSerpent(['int256', 'bytes']);
abi.fromSerpent(serpentSig);

11
types/ethereumjs-abi/index.d.ts vendored
View File

@ -1,12 +1,21 @@
// Type definitions for ethereumjs-abi 0.6
// Project: https://github.com/ethereumjs/ethereumjs-abi, https://github.com/axic/ethereumjs-abi
// Definitions by: Leonid Logvinov <https://github.com/LogvinovLeon>
// Artur Kozak <https://github.com/quezak>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
/// <reference types="node" />
export function soliditySHA3(argTypes: string[], args: any[]): Buffer;
export function soliditySHA256(argTypes: string[], args: any[]): Buffer;
export function solidityRIPEMD160(argTypes: string[], args: any[]): Buffer;
export function eventID(name: string, types: string[]): Buffer;
export function methodID(name: string, types: string[]): Buffer;
export function simpleEncode(signature: string, ...args: any[]): Buffer;
export function rawDecode(signature: string[], data: Buffer): any[];
export function simpleDecode(signature: string, data: Buffer): any[];
export function rawEncode(types: string[], values: any[]): Buffer;
export function rawDecode(types: string[], data: Buffer): any[];
export function stringify(types: string[], values: any[]): string;
export function solidityPack(types: string[], values: any[]): Buffer;
export function fromSerpent(signature: string): string[];
export function toSerpent(types: string[]): string;

1
types/expo/expo-tests.tsx
View File

@ -412,6 +412,7 @@ async () => {
{ resize: { width: 300 } },
{ resize: { height: 300 } },
{ resize: { height: 300, width: 300 } },
{ crop: { originX: 0, originY: 0, height: 300, width: 300 } }
], {
compress: 0.75
});

12
types/expo/index.d.ts vendored
View File

@ -1952,14 +1952,16 @@ export namespace ImageManipulator {
}
interface Flip {
flip?: { vertical?: boolean; horizontal?: boolean };
flip: { vertical?: boolean; horizontal?: boolean };
}
interface Crop {
originX: number;
originY: number;
width: number;
height: number;
crop: {
originX: number;
originY: number;
width: number;
height: number;
};
}
interface ImageResult {

9
types/fabric/fabric-impl.d.ts vendored
View File

@ -2302,6 +2302,15 @@ interface IObjectOptions {
* Describes the object's corner position in canvas object absolute properties.
*/
aCoords?: {bl: Point, br: Point, tl: Point, tr: Point};
/**
* Describe object's corner position in canvas element coordinates. properties are tl,mt,tr,ml,mr,bl,mb,br,mtr for
* the main controls. each property is an object with x, y and corner. The `corner` property contains in a similar
* manner the 4 points of the interactive area of the corner. The coordinates depends from this properties: width,
* height, scaleX, scaleY skewX, skewY, angle, strokeWidth, viewportTransform, top, left, padding. The coordinates
* get updated with @method setCoords. You can calculate them without updating with @method calcCoords;
*/
oCoords?: { tl: Point, mt: Point, tr: Point, ml: Point, mr: Point, bl: Point, mb: Point, br: Point, mtr: Point }
}
export interface Object extends IObservable<Object>, IObjectOptions, IObjectAnimation<Object> { }
export class Object {

1
types/fabric/index.d.ts vendored
View File

@ -7,6 +7,7 @@
// Brian Martinson <https://github.com/bmartinson>
// Rogerio Teixeira <https://github.com/RogerioTeixeira>
// Bradley Hill <https://github.com/BradleyHill>
// Glenn Gartner <https://github.com/glenngartner>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.1
export import fabric = require("./fabric-impl");

1
types/got/index.d.ts vendored
View File

@ -36,6 +36,7 @@ declare class HTTPError extends StdError {
statusCode: number;
statusMessage: string;
headers: http.IncomingHttpHeaders;
body: Buffer | string | object;
}
declare class MaxRedirectsError extends StdError {

3
types/gulp-gh-pages/gulp-gh-pages-tests.ts
View File

@ -19,5 +19,8 @@ gulp.src("test.css")
gulp.src("test.css")
.pipe(ghPages({push: false}));
gulp.src("test.css")
.pipe(ghPages({ force: true }));
gulp.src("test.css")
.pipe(ghPages({message: "master"}));

2
types/gulp-gh-pages/index.d.ts vendored
View File

@ -1,6 +1,7 @@
// Type definitions for gulp-gh-pages
// Project: https://github.com/rowoot/gulp-gh-pages
// Definitions by: Asana <https://asana.com>
// Ntnyq <https://github.com/ntnyq>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
/// <reference types="node"/>
@ -12,6 +13,7 @@ interface Options {
branch?: string;
cacheDir?: string;
push?: boolean;
force?: boolean;
message?: string;
}

6
types/handlebars-helpers/package.json Normal file
View File

@ -0,0 +1,6 @@
{
"private": true,
"dependencies": {
"handlebars": ">=4.1.0"
}
}

2
types/handlebars-helpers/tsconfig.json
View File

@ -2,7 +2,7 @@
"compilerOptions": {
"module": "commonjs",
"lib": [
"es6"
"es2015"
],
"noImplicitAny": true,
"noImplicitThis": false,

6
types/hexo/package.json Normal file
View File

@ -0,0 +1,6 @@
{
"private": true,
"dependencies": {
"moment": "^2.19.4"
}
}

2
types/imap-simple/index.d.ts vendored
View File

@ -55,7 +55,7 @@ export class ImapSimple extends NodeJS.EventEmitter {
getBoxes(callback: (err: Error, boxes: Imap.MailBoxes) => void): void;
getBoxes(): Promise<Imap.MailBoxes>;
/** Search for and retrieve mail in the previously opened mailbox. */
/** Search for and retrieve mail in the currently open mailbox. */
search(searchCriteria: any[], fetchOptions: Imap.FetchOptions, callback: (err: Error, messages: Message[]) => void): void;
search(searchCriteria: any[], fetchOptions: Imap.FetchOptions): Promise<Message[]>;

9
types/indefinite/indefinite-tests.ts Normal file
View File

@ -0,0 +1,9 @@
import { indefinite } from "indefinite";
const anApple = indefinite("apple"); // "an apple"
const aBanana = indefinite('banana'); // "a banana"
const AnApple = indefinite('apple', { capitalize: true }); // "An apple"
const anEight = indefinite("8"); // "an 8"
const anEightAsNumber = indefinite(8); // "an 8"
const a1892 = indefinite("1892"); // "a 1892" -> read "a one thousand eight hundred ninety-two"
const a1892AsColloquial = indefinite("1892", { numbers: "colloquial" }); // "an 1892" -> read "an eighteen ninety-two"

11
types/indefinite/index.d.ts vendored Normal file
View File

@ -0,0 +1,11 @@
// Type definitions for indefinite 2.2
// Project: https://github.com/tandrewnichols/indefinite
// Definitions by: omaishar <https://github.com/omaishr>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
export interface Options {
capitalize?: boolean;
caseInsensitive?: boolean;
numbers?: "colloquial";
}
export function indefinite(word: string | number, opts?: Options): string;

8
types/p-map/tsconfig.json → types/indefinite/tsconfig.json
View File

@ -7,17 +7,17 @@
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": true,
"strictFunctionTypes": false,
"baseUrl": "../",
"typeRoots": [
"../"
],
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true
"forceConsistentCasingInFileNames": true,
"strictFunctionTypes": true
},
"files": [
"index.d.ts",
"p-map-tests.ts"
"indefinite-tests.ts"
]
}
}

0
types/internal-ip/tslint.json → types/indefinite/tslint.json
View File

6
types/ink-spinner/package.json Normal file
View File

@ -0,0 +1,6 @@
{
"private": true,
"dependencies": {
"chalk": "^2.1.0"
}
}

1
types/inquirer/index.d.ts vendored
View File

@ -81,6 +81,7 @@ declare namespace inquirer {
* Possible values:
* <ul>
* <li>input</li>
* <li>number</li>
* <li>confirm</li>
* <li>list</li>
* <li>rawlist</li>

12
types/internal-ip/index.d.ts vendored
View File

@ -1,12 +0,0 @@
// Type definitions for internal-ip 3.0
// Project: https://github.com/sindresorhus/internal-ip#readme
// Definitions by: BendingBender <https://github.com/BendingBender>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
export const v6: IPGetterFn;
export const v4: IPGetterFn;
export interface IPGetterFn { // tslint:disable-line:interface-name
(): Promise<string | null>;
sync(): string | null;
}

15
types/internal-ip/internal-ip-tests.ts
View File

@ -1,15 +0,0 @@
import * as internalIp from 'internal-ip';
internalIp.v6().then(ip => {
// $ExpectType string | null
ip;
});
// $ExpectType string | null
internalIp.v6.sync();
internalIp.v4().then(ip => {
// $ExpectType string | null
ip;
});
// $ExpectType string | null
internalIp.v4.sync();

7
types/internal-ip/v2/index.d.ts vendored
View File

@ -1,7 +0,0 @@
// Type definitions for internal-ip 2.0
// Project: https://github.com/sindresorhus/internal-ip#readme
// Definitions by: BendingBender <https://github.com/BendingBender>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
export function v6(): Promise<string>;
export function v4(): Promise<string>;

10
types/internal-ip/v2/internal-ip-tests.ts
View File

@ -1,10 +0,0 @@
import * as internalIp from 'internal-ip';
let str: string;
internalIp.v6().then(ip => {
str = ip;
});
internalIp.v4().then(ip => {
str = ip;
});

7
types/is-blank/index.d.ts vendored Normal file
View File

@ -0,0 +1,7 @@
// Type definitions for is-blank 2.1
// Project: https://github.com/johnotander/is-blank#readme
// Definitions by: Christian Gambardella <https://github.com/heygambo>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
declare function isBlank(input: any): boolean;
export = isBlank;

17
types/is-blank/is-blank-tests.ts Normal file
View File

@ -0,0 +1,17 @@
import isBlank = require('is-blank');
isBlank([]); // => true
isBlank({}); // => true
isBlank(0); // => true
isBlank(() => {}); // => true
isBlank(null); // => true
isBlank(undefined); // => true
isBlank(''); // => true
isBlank(' '); // => true
isBlank('\r\t\n '); // => true
isBlank(['a', 'b']); // => false
isBlank({ a: 'b' }); // => false
isBlank('string'); // => false
isBlank(42); // => false
isBlank((a: number, b: number) => a + b);

2
types/p-pipe/tsconfig.json → types/is-blank/tsconfig.json
View File

@ -18,6 +18,6 @@
},
"files": [
"index.d.ts",
"p-pipe-tests.ts"
"is-blank-tests.ts"
]
}

0
types/internal-ip/v2/tslint.json → types/is-blank/tslint.json
View File

19
types/is-natural-number/index.d.ts vendored Normal file
View File

@ -0,0 +1,19 @@
// Type definitions for is-natural-number 4.0
// Project: https://github.com/shinnn/is-natural-number.js
// Definitions by: Adam Zerella <https://github.com/adamzerella>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
interface Options {
/**
* Setting this option true makes 0 regarded as a natural number.
*/
includeZero: boolean;
}
/**
* Rreturns true if the first argument is one of the natural numbers.
* If not, or the argument is not a number, it returns false.
*/
declare function isNaturalNumber(number: number|string, option?: Options): boolean;
export = isNaturalNumber;

6
types/is-natural-number/is-natural-number-tests.ts Normal file
View File

@ -0,0 +1,6 @@
import isNaturalNumber = require("is-natural-number");
isNaturalNumber(5);
isNaturalNumber("5");
isNaturalNumber(0, {includeZero: true});
isNaturalNumber("0", {includeZero: true});

25
types/is-natural-number/tsconfig.json Normal file
View File

@ -0,0 +1,25 @@
{
"compilerOptions": {
"module": "commonjs",
"lib": [
"es6"
],
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": true,
"strictFunctionTypes": true,
"baseUrl": "../",
"typeRoots": [
"../"
],
"types": [
],
"noEmit": true,
"forceConsistentCasingInFileNames": true
},
"files": [
"index.d.ts",
"is-natural-number-tests.ts"
]
}

0
types/p-map/tslint.json → types/is-natural-number/tslint.json
View File

11
types/is-odd/index.d.ts vendored Normal file
View File

@ -0,0 +1,11 @@
// Type definitions for is-odd 3.0
// Project: https://github.com/jonschlinkert/is-odd
// Definitions by: Adam Zerella <https://github.com/adamzerella>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
/**
* Return true if a given number is odd or not.
*/
declare function isOdd(value: number|string): boolean;
export = isOdd;

4
types/is-odd/is-odd-tests.ts Normal file
View File

@ -0,0 +1,4 @@
import isOdd = require("is-odd");
isOdd(5);
isOdd("5");

25
types/is-odd/tsconfig.json Normal file
View File

@ -0,0 +1,25 @@
{
"compilerOptions": {
"module": "commonjs",
"lib": [
"es6"
],
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": true,
"strictFunctionTypes": true,
"baseUrl": "../",
"typeRoots": [
"../"
],
"types": [
],
"noEmit": true,
"forceConsistentCasingInFileNames": true
},
"files": [
"index.d.ts",
"is-odd-tests.ts"
]
}

3
types/is-odd/tslint.json Normal file
View File

@ -0,0 +1,3 @@
{
"extends": "dtslint/dt.json"
}

4
types/isotope-layout/index.d.ts vendored
View File

@ -284,6 +284,10 @@ declare global {
* Get the Isotope instance from a jQuery object. Isotope instances are useful to access Isotope properties.
*/
data(methodName: 'isotope'): Isotope;
/**
* Filters, sorts, and lays out items.
*/
isotope(): JQuery;
/**
* Lays out specified items.
* @param elements Array of Isotope.Items

1
types/isotope-layout/isotope-layout-tests.ts
View File

@ -81,6 +81,7 @@ $grid = $('.grid').isotope({
});
// test methods using jquery
$grid.isotope();
$grid.isotope('addItems', $('.items'));
$grid.isotope('appended', $('.items')[0]);
$grid.isotope('hideItemElements', [ new HTMLElement() ]);

2
types/jasmine-enzyme/index.d.ts vendored
View File

@ -2,7 +2,7 @@
// Project: https://github.com/formidablelabs/enzyme-matchers/packages/jasmine-enzyme
// Definitions by: Umar Bolatov <https://github.com/bolatovumar>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.8
// TypeScript Version: 3.1
/// <reference types="jasmine" />
/// <reference types="react" />

2
types/jenkins/index.d.ts vendored
View File

@ -15,7 +15,7 @@ declare namespace create {
log(name: string, n: number, start: number, callback: (err: Error, data: any) => void): void;
log(name: string, n: number, start: number, type: 'text' | 'html', callback: (err: Error, data: any) => void): void;
log(name: string, n: number, start: number, type: 'text' | 'html', meta: boolean, callback: (err: Error, data: any) => void): void;
logStream(name: string, n: number, type?: 'text' | 'html', delay?: number): NodeJS.ReadableStream;
logStream(name: string, n: number, options?: { type?: 'text' | 'html', delay?: number }): NodeJS.ReadableStream;
stop(name: string, n: number, callback: (err: Error) => void): void;
term(name: string, n: number, callback: (err: Error) => void): void;
};

14
types/jenkins/jenkins-tests.ts
View File

@ -34,6 +34,20 @@ log.on('end', () => {
console.log('end');
});
const log2 = jenkins.build.logStream('example', 1, { type: 'html', delay: 2 * 1000 });
log2.on('data', (text: string) => {
process.stdout.write(text);
});
log2.on('error', (err: Error) => {
console.log('error', err);
});
log2.on('end', () => {
console.log('end');
});
jenkins.build.stop('example', 1, (err) => {
if (err) throw err;
});

35
types/jest-environment-puppeteer/index.d.ts vendored
View File

@ -1,14 +1,43 @@
// Type definitions for jest-environment-puppeteer 2.2
// Type definitions for jest-environment-puppeteer 4.0
// Project: https://github.com/smooth-code/jest-puppeteer/tree/master/packages/jest-environment-puppeteer
// Definitions by: Josh Goldberg <https://github.com/joshuakgoldberg>
// Ifiok Jr. <https://github.com/ifiokjr>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.8
import { Browser, Page } from "puppeteer";
import { Browser, Page, BrowserContext } from 'puppeteer';
interface JestPuppeteer {
/**
* Reset global.page
*
* ```ts
* beforeEach(async () => {
* await jestPuppeteer.resetPage()
* })
* ```
*/
resetPage(): Promise<void>;
/**
* Suspends test execution and gives you opportunity to see what's going on in the browser
* - Jest is suspended (no timeout)
* - A debugger instruction to Chromium, if Puppeteer has been launched with { devtools: true } it will stop
*
* ```ts
* it('should put test in debug mode', async () => {
* await jestPuppeteer.debug()
* })
* ```
*/
debug(): Promise<void>;
}
declare global {
const browser: Browser;
const context: BrowserContext;
const page: Page;
const jestPuppeteer: JestPuppeteer;
}
export { };
export {};

4
types/jest-environment-puppeteer/jest-environment-puppeteer-tests.ts
View File

@ -2,3 +2,7 @@ import * as puppeteer from "puppeteer";
const myBrowser: puppeteer.Browser = browser;
const myPage: puppeteer.Page = page;
const myContext: puppeteer.BrowserContext = context;
jestPuppeteer.debug();
jestPuppeteer.resetPage();

2
types/jest-specific-snapshot/index.d.ts vendored
View File

@ -2,7 +2,7 @@
// Project: https://github.com/igor-dv/jest-specific-snapshot#readme
// Definitions by: Janeene Beeforth <https://github.com/dawnmist>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 3.0
// TypeScript Version: 3.1
/// <reference types="jest" />

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