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

Prepare for TS #33050 (#38555)

Browse Source
This commit is contained in:
Anders Hejlsberg 2019-09-25 10:30:30 -07:00 committed by GitHub
parent 05ce01bbe4
commit 805bb29adb
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
17 changed files with 505 additions and 503 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
types/byte-range/byte-range-tests.ts
View File

@ -1,10 +1,10 @@
import byteRange = require('byte-range');
byteRange(1); // $ExpectType [number, number]
byteRange(1, { signed: false }); // $ExpectType [number, number]
byteRange.uint8; // $ExpectType [number, number]
byteRange.uint16; // $ExpectType [number, number]
byteRange.uint32; // $ExpectType [number, number]
byteRange.int8; // $ExpectType [number, number]
byteRange.int16; // $ExpectType [number, number]
byteRange.int32; // $ExpectType [number, number]
byteRange(1); // $ExpectType [number, number] || ByteRange
byteRange(1, { signed: false }); // $ExpectType [number, number] || ByteRange
byteRange.uint8; // $ExpectType [number, number] || ByteRange
byteRange.uint16; // $ExpectType [number, number] || ByteRange
byteRange.uint32; // $ExpectType [number, number] || ByteRange
byteRange.int8; // $ExpectType [number, number] || ByteRange
byteRange.int16; // $ExpectType [number, number] || ByteRange
byteRange.int32; // $ExpectType [number, number] || ByteRange

2
types/frida-gum/frida-gum-tests.ts
View File

@ -39,7 +39,7 @@ result.errno;
Interceptor.attach(puts, {
onEnter(args) {
// $ExpectType NativePointer[]
// $ExpectType NativePointer[] || InvocationArguments
args;
},
onLeave(retval) {

2
types/geojson/geojson-tests.ts
View File

@ -79,7 +79,7 @@ const featureWithPolygon: Feature<Polygon> = {
featureWithPolygon.type; // $ExpectType "Feature"
featureWithPolygon.geometry; // $ExpectType Polygon
featureWithPolygon.geometry.type; // $ExpectType "Polygon"
featureWithPolygon.geometry.coordinates; // $ExpectType number[][][]
featureWithPolygon.geometry.coordinates; // $ExpectType number[][][] || Position[][]
const point: Point = {
type: "Point",

2
types/hogan.js/hogan.js-tests.ts
View File

@ -20,5 +20,5 @@ compiled.render({ value: "test" });
// $ExpectType Token[]
const scanned = Hogan.scan("{{#if}}{{value}}{{/if}}");
// $ExpectType Leaf[]
// $ExpectType Leaf[] || Tree
Hogan.parse(scanned);

22
types/idyll-ast/idyll-ast-tests.ts
View File

@ -30,19 +30,19 @@ const ast: AST = [
];
const prop: Property = ["className", ["value", "hello"]];
// $ExpectType Node[]
// $ExpectType Node[] || AST
appendNode(ast, "hello");
// $ExpectType Node[]
// $ExpectType Node[] || AST
appendNode(getNodesByName(ast, "div"), "test");
// $ExpectType Node[]
// $ExpectType Node[] || AST
appendNodes(ast, [["strong", [], ["div", ["pre", [], []]]], "test"]);
// $ExpectType Node[]
// $ExpectType Node[] || AST
prependNode(getNodesByName(ast, "div"), "test");
// $ExpectType Node[]
// $ExpectType Node[] || AST
prependNodes(ast, [["strong", [], ["div", ["pre", [], []]]], "test"]);
// $ExpectType TreeNode
@ -71,22 +71,22 @@ getNodesByName(ast, "h1");
// $ExpectType Node
filterChildren(ast[1], n => n === "world");
// $ExpectType Node[]
// $ExpectType Node[] || AST
filterNodes(ast, n => (n instanceof Object ? n[0] === "h1" : false));
// $ExpectType Node[]
// $ExpectType Node[] || AST
modifyNodesByName(ast, "h2", n => {
typeof n === "object" ? (n[1] = []) : undefined;
});
// $ExpectType [PropType, PropData] | null
// $ExpectType [PropType, PropData] | null || PropValue | null
getProperty(ast[1], "someProp");
// $ExpectType [string, [PropType, PropData]]
// $ExpectType [string, [PropType, PropData]] || Property
getProperties(ast[1])[0];
// $ExpectType [string, [PropType, PropData]][]
// $ExpectType [string, [PropType, PropData]][] || Property[]
getPropertiesByType(["h1", [], []], "variable");
// $ExpectType Node[]
// $ExpectType Node[] || AST
removeNodesByName(ast, "h1");
// $ExpectType Node

6
types/idyll-compiler/idyll-compiler-tests.ts
View File

@ -3,11 +3,11 @@ import compile = require("idyll-compiler");
// Dummy log
const log = (msg: string) => {};
// $ExpectType Node[] | Promise<Node[]>
// $ExpectType Node[] | Promise<Node[]> || AST | Promise<AST>
compile("*italics*", { async: false }, () => log("window"));
// $ExpectType Node[] | Promise<Node[]>
// $ExpectType Node[] | Promise<Node[]> || AST | Promise<AST>
compile("Simple **idyll**", { async: false });
// $ExpectType Node[] | Promise<Node[]>
// $ExpectType Node[] | Promise<Node[]> || AST | Promise<AST>
compile(`# Test`);

142
types/lodash/ts3.1/lodash-tests.ts
View File

@ -374,9 +374,9 @@ _.chain([1, 2, 3, 4]).unshift(5, 6); // $ExpectType CollectionChain<number>
_.fill(array, abcObject, 0); // $ExpectType AbcObject[]
_.fill(array, abcObject, 0, 10); // $ExpectType AbcObject[]
_.fill(list, abcObject); // $ExpectType ArrayLike<AbcObject>
_.fill(list, abcObject, 0); // $ExpectType ArrayLike<AbcObject>
_.fill(list, abcObject, 0, 10); // $ExpectType ArrayLike<AbcObject>
_.fill(list, abcObject); // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
_.fill(list, abcObject, 0); // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
_.fill(list, abcObject, 0, 10); // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
_(list).fill(abcObject); // $ExpectType Collection<AbcObject>
_(list).fill(abcObject, 0); // $ExpectType Collection<AbcObject>
@ -388,7 +388,7 @@ _.chain([1, 2, 3, 4]).unshift(5, 6); // $ExpectType CollectionChain<number>
fp.fill(0, 10, abcObject, array); // $ExpectType AbcObject[]
fp.fill(0)(10)(abcObject)(array); // $ExpectType AbcObject[]
fp.fill(0, 10, abcObject, list); // $ExpectType ArrayLike<AbcObject>
fp.fill(0, 10, abcObject, list); // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
}
// _.findIndex
@ -816,9 +816,9 @@ _.chain([1, 2, 3, 4]).unshift(5, 6); // $ExpectType CollectionChain<number>
_.pull(array); // $ExpectType AbcObject[]
_.pull(array, abcObject); // $ExpectType AbcObject[]
_.pull(array, abcObject, abcObject, abcObject); // $ExpectType AbcObject[]
_.pull(list); // $ExpectType ArrayLike<AbcObject>
_.pull(list, abcObject); // $ExpectType ArrayLike<AbcObject>
_.pull(list, abcObject, abcObject, abcObject); // $ExpectType ArrayLike<AbcObject>
_.pull(list); // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
_.pull(list, abcObject); // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
_.pull(list, abcObject, abcObject, abcObject); // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
_(array).pull(); // $ExpectType Collection<AbcObject>
_(array).pull(abcObject); // $ExpectType Collection<AbcObject>
@ -835,7 +835,7 @@ _.chain([1, 2, 3, 4]).unshift(5, 6); // $ExpectType CollectionChain<number>
_.chain(list).pull(abcObject, abcObject, abcObject); // $ExpectType CollectionChain<AbcObject>
fp.pull(abcObject, array); // $ExpectType AbcObject[]
fp.pull(abcObject)(list); // $ExpectType ArrayLike<AbcObject>
fp.pull(abcObject)(list); // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
}
// _.pullAt
@ -846,9 +846,9 @@ _.chain([1, 2, 3, 4]).unshift(5, 6); // $ExpectType CollectionChain<number>
_.pullAt(array); // $ExpectType AbcObject[]
_.pullAt(array, 1); // $ExpectType AbcObject[]
_.pullAt(array, [2, 3], 4); // $ExpectType AbcObject[]
_.pullAt(list); // $ExpectType ArrayLike<AbcObject>
_.pullAt(list, 1); // $ExpectType ArrayLike<AbcObject>
_.pullAt(list, [2, 3], 4); // $ExpectType ArrayLike<AbcObject>
_.pullAt(list); // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
_.pullAt(list, 1); // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
_.pullAt(list, [2, 3], 4); // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
_(array).pullAt(); // $ExpectType Collection<AbcObject>
_(array).pullAt(1); // $ExpectType Collection<AbcObject>
@ -866,9 +866,9 @@ _.chain([1, 2, 3, 4]).unshift(5, 6); // $ExpectType CollectionChain<number>
fp.pullAt(1, array); // $ExpectType AbcObject[]
fp.pullAt([2, 3], array); // $ExpectType AbcObject[]
fp.pullAt(1, list); // $ExpectType ArrayLike<AbcObject>
fp.pullAt([2, 3], list); // $ExpectType ArrayLike<AbcObject>
fp.pullAt(1)(list); // $ExpectType ArrayLike<AbcObject>
fp.pullAt(1, list); // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
fp.pullAt([2, 3], list); // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
fp.pullAt(1)(list); // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
}
// _.pullAll
@ -879,8 +879,8 @@ _.chain([1, 2, 3, 4]).unshift(5, 6); // $ExpectType CollectionChain<number>
_.pullAll(array); // $ExpectType AbcObject[]
_.pullAll(array, values); // $ExpectType AbcObject[]
_.pullAll(list); // $ExpectType ArrayLike<AbcObject>
_.pullAll(list, values); // $ExpectType ArrayLike<AbcObject>
_.pullAll(list); // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
_.pullAll(list, values); // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
_(array).pullAll(); // $ExpectType Collection<AbcObject>
_(array).pullAll(values); // $ExpectType Collection<AbcObject>
@ -893,8 +893,8 @@ _.chain([1, 2, 3, 4]).unshift(5, 6); // $ExpectType CollectionChain<number>
_.chain(list).pullAll(values); // $ExpectType CollectionChain<AbcObject>
fp.pullAll(values, array); // $ExpectType AbcObject[]
fp.pullAll(values, list); // $ExpectType ArrayLike<AbcObject>
fp.pullAll(values)(list); // $ExpectType ArrayLike<AbcObject>
fp.pullAll(values, list); // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
fp.pullAll(values)(list); // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
}
// _.pullAllBy
@ -912,12 +912,12 @@ _.chain([1, 2, 3, 4]).unshift(5, 6); // $ExpectType CollectionChain<number>
return [];
});
_.pullAllBy(list); // $ExpectType ArrayLike<AbcObject>
_.pullAllBy(list, values); // $ExpectType ArrayLike<AbcObject>
_.pullAllBy(list, values, "a"); // $ExpectType ArrayLike<AbcObject>
_.pullAllBy(list, values, { a: 42 }); // $ExpectType ArrayLike<AbcObject>
_.pullAllBy(list, values, ["a", 42]); // $ExpectType ArrayLike<AbcObject>
// $ExpectType ArrayLike<AbcObject>
_.pullAllBy(list); // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
_.pullAllBy(list, values); // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
_.pullAllBy(list, values, "a"); // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
_.pullAllBy(list, values, { a: 42 }); // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
_.pullAllBy(list, values, ["a", 42]); // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
// $ExpectType ArrayLike<AbcObject> || List<AbcObject>
_.pullAllBy(list, values, (value) => {
value; // $ExpectType AbcObject
return () => {};
@ -960,13 +960,13 @@ _.chain([1, 2, 3, 4]).unshift(5, 6); // $ExpectType CollectionChain<number>
fp.pullAllBy((value: AbcObject) => true)(values, array); // $ExpectType AbcObject[]
fp.pullAllBy((value: AbcObject) => true, values)(array); // $ExpectType AbcObject[]
fp.pullAllBy((value: AbcObject) => true)(values)(array); // $ExpectType AbcObject[]
fp.pullAllBy("a", values, list); // $ExpectType ArrayLike<AbcObject>
fp.pullAllBy({ a: 42 }, values, list); // $ExpectType ArrayLike<AbcObject>
fp.pullAllBy(["a", 42], values, list); // $ExpectType ArrayLike<AbcObject>
fp.pullAllBy((value: AbcObject) => true, values, list); // $ExpectType ArrayLike<AbcObject>
fp.pullAllBy((value: AbcObject) => true)(values, list); // $ExpectType ArrayLike<AbcObject>
fp.pullAllBy((value: AbcObject) => true, values)(list); // $ExpectType ArrayLike<AbcObject>
fp.pullAllBy((value: AbcObject) => true)(values)(list); // $ExpectType ArrayLike<AbcObject>
fp.pullAllBy("a", values, list); // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
fp.pullAllBy({ a: 42 }, values, list); // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
fp.pullAllBy(["a", 42], values, list); // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
fp.pullAllBy((value: AbcObject) => true, values, list); // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
fp.pullAllBy((value: AbcObject) => true)(values, list); // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
fp.pullAllBy((value: AbcObject) => true, values)(list); // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
fp.pullAllBy((value: AbcObject) => true)(values)(list); // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
interface T1 {
a: string;
@ -1005,8 +1005,8 @@ _.chain([1, 2, 3, 4]).unshift(5, 6); // $ExpectType CollectionChain<number>
b; // $ExpectType AbcObject
return true;
});
_.pullAllWith(list); // $ExpectType ArrayLike<AbcObject>
// $ExpectType ArrayLike<AbcObject>
_.pullAllWith(list); // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
// $ExpectType ArrayLike<AbcObject> || List<AbcObject>
_.pullAllWith(list, values, (a, b) => {
a; // $ExpectType AbcObject
b; // $ExpectType AbcObject
@ -1047,8 +1047,8 @@ _.chain([1, 2, 3, 4]).unshift(5, 6); // $ExpectType CollectionChain<number>
fp.pullAllWith((a, b) => true, values, array); // $ExpectType AbcObject[]
fp.pullAllWith((a: AbcObject, b: AbcObject) => true)(values, array); // $ExpectType AbcObject[]
fp.pullAllWith((a, b) => true, values, list); // $ExpectType ArrayLike<AbcObject>
fp.pullAllWith((a: AbcObject, b: AbcObject) => true)(values, list); // $ExpectType ArrayLike<AbcObject>
fp.pullAllWith((a, b) => true, values, list); // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
fp.pullAllWith((a: AbcObject, b: AbcObject) => true)(values, list); // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
// $ExpectType T1[]
_.pullAllWith([t1], [t2], (a, b) => {
@ -2164,18 +2164,18 @@ _.chain([1, 2, 3, 4]).unshift(5, 6); // $ExpectType CollectionChain<number>
collection; // $ExpectType AbcObject[]
});
// $ExpectType ArrayLike<AbcObject>
// $ExpectType ArrayLike<AbcObject> || List<AbcObject>
_.forEach(list, (value, index, collection) => {
value; // $ExpectType AbcObject
index; // $ExpectType number
collection; // $ExpectType ArrayLike<AbcObject>
collection; // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
});
// $ExpectType ArrayLike<AbcObject> | null | undefined
// $ExpectType ArrayLike<AbcObject> | null | undefined || List<AbcObject> | null | undefined
_.forEach(nilList, (value, index, collection) => {
value; // $ExpectType AbcObject
index; // $ExpectType number
collection; // $ExpectType ArrayLike<AbcObject>
collection; // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
});
// $ExpectType Dictionary<AbcObject>
@ -2238,28 +2238,28 @@ _.chain([1, 2, 3, 4]).unshift(5, 6); // $ExpectType CollectionChain<number>
_(array).forEach((value, index, collection) => {
value; // $ExpectType AbcObject
index; // $ExpectType number
collection; // $ExpectType ArrayLike<AbcObject>
collection; // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
});
// $ExpectType Collection<AbcObject>
_(nilArray).forEach((value, index, collection) => {
value; // $ExpectType AbcObject
index; // $ExpectType number
collection; // $ExpectType ArrayLike<AbcObject>
collection; // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
});
// $ExpectType Collection<AbcObject>
_(list).forEach((value, index, collection) => {
value; // $ExpectType AbcObject
index; // $ExpectType number
collection; // $ExpectType ArrayLike<AbcObject>
collection; // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
});
// $ExpectType Collection<AbcObject>
_(nilList).forEach((value, index, collection) => {
value; // $ExpectType AbcObject
index; // $ExpectType number
collection; // $ExpectType ArrayLike<AbcObject>
collection; // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
});
// $ExpectType Object<Dictionary<AbcObject>>
@ -2308,28 +2308,28 @@ _.chain([1, 2, 3, 4]).unshift(5, 6); // $ExpectType CollectionChain<number>
_.chain(array).forEach((value, index, collection) => {
value; // $ExpectType AbcObject
index; // $ExpectType number
collection; // $ExpectType ArrayLike<AbcObject>
collection; // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
});
// $ExpectType CollectionChain<AbcObject>
_.chain(nilArray).forEach((value, index, collection) => {
value; // $ExpectType AbcObject
index; // $ExpectType number
collection; // $ExpectType ArrayLike<AbcObject>
collection; // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
});
// $ExpectType CollectionChain<AbcObject>
_.chain(list).forEach((value, index, collection) => {
value; // $ExpectType AbcObject
index; // $ExpectType number
collection; // $ExpectType ArrayLike<AbcObject>
collection; // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
});
// $ExpectType CollectionChain<AbcObject>
_.chain(nilList).forEach((value, index, collection) => {
value; // $ExpectType AbcObject
index; // $ExpectType number
collection; // $ExpectType ArrayLike<AbcObject>
collection; // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
});
// $ExpectType ObjectChain<Dictionary<AbcObject>>
@ -2360,13 +2360,13 @@ _.chain([1, 2, 3, 4]).unshift(5, 6); // $ExpectType CollectionChain<number>
collection; // $ExpectType NumericDictionary<AbcObject>
});
fp.forEach(stringIterator, ""); // $ExpectType ArrayLike<string>
fp.forEach(stringIterator, ""); // $ExpectType ArrayLike<string> || List<string>
fp.forEach(valueIterator, array); // $ExpectType AbcObject[]
fp.forEach(valueIterator)(array); // $ExpectType AbcObject[]
fp.forEach(valueIterator, list); // $ExpectType ArrayLike<AbcObject>
fp.forEach(valueIterator, list); // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
fp.forEach(valueIterator, dictionary); // $ExpectType Dictionary<AbcObject>
fp.forEach(valueIterator, nilArray); // $ExpectType AbcObject[] | null | undefined
fp.forEach(valueIterator, nilList); // $ExpectType ArrayLike<AbcObject> | null | undefined
fp.forEach(valueIterator, nilList); // $ExpectType ArrayLike<AbcObject> | null | undefined || List<AbcObject> | null | undefined
fp.forEach(valueIterator, nilDictionary); // $ExpectType Dictionary<AbcObject> | null | undefined
// $ExpectType AbcObject[]
@ -2375,35 +2375,35 @@ _.chain([1, 2, 3, 4]).unshift(5, 6); // $ExpectType CollectionChain<number>
index; // $ExpectType number
collection; // $ExpectType AbcObject[]
});
// $ExpectType ArrayLike<AbcObject> | null | undefined
// $ExpectType ArrayLike<AbcObject> | null | undefined || List<AbcObject> | null | undefined
_.forEachRight(nilList, (value, index, collection) => {
value; // $ExpectType AbcObject
index; // $ExpectType number
collection; // $ExpectType ArrayLike<AbcObject>
collection; // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
});
// $ExpectType Collection<AbcObject>
_(array).forEachRight((value, index, collection) => {
value; // $ExpectType AbcObject
index; // $ExpectType number
collection; // $ExpectType ArrayLike<AbcObject>
collection; // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
});
// $ExpectType Collection<AbcObject>
_(nilList).forEachRight((value, index, collection) => {
value; // $ExpectType AbcObject
index; // $ExpectType number
collection; // $ExpectType ArrayLike<AbcObject>
collection; // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
});
// $ExpectType CollectionChain<AbcObject>
_.chain(array).forEachRight((value, index, collection) => {
value; // $ExpectType AbcObject
index; // $ExpectType number
collection; // $ExpectType ArrayLike<AbcObject>
collection; // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
});
// $ExpectType CollectionChain<AbcObject>
_.chain(nilList).forEachRight((value, index, collection) => {
value; // $ExpectType AbcObject
index; // $ExpectType number
collection; // $ExpectType ArrayLike<AbcObject>
collection; // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
});
fp.forEachRight(valueIterator, array); // $ExpectType AbcObject[]
fp.forEachRight(valueIterator)(array); // $ExpectType AbcObject[]
@ -2414,35 +2414,35 @@ _.chain([1, 2, 3, 4]).unshift(5, 6); // $ExpectType CollectionChain<number>
index; // $ExpectType number
collection; // $ExpectType AbcObject[]
});
// $ExpectType ArrayLike<AbcObject> | null | undefined
// $ExpectType ArrayLike<AbcObject> | null | undefined || List<AbcObject> | null | undefined
_.each(nilList, (value, index, collection) => {
value; // $ExpectType AbcObject
index; // $ExpectType number
collection; // $ExpectType ArrayLike<AbcObject>
collection; // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
});
// $ExpectType Collection<AbcObject>
_(array).each((value, index, collection) => {
value; // $ExpectType AbcObject
index; // $ExpectType number
collection; // $ExpectType ArrayLike<AbcObject>
collection; // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
});
// $ExpectType Collection<AbcObject>
_(nilList).each((value, index, collection) => {
value; // $ExpectType AbcObject
index; // $ExpectType number
collection; // $ExpectType ArrayLike<AbcObject>
collection; // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
});
// $ExpectType CollectionChain<AbcObject>
_.chain(array).each((value, index, collection) => {
value; // $ExpectType AbcObject
index; // $ExpectType number
collection; // $ExpectType ArrayLike<AbcObject>
collection; // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
});
// $ExpectType CollectionChain<AbcObject>
_.chain(nilList).each((value, index, collection) => {
value; // $ExpectType AbcObject
index; // $ExpectType number
collection; // $ExpectType ArrayLike<AbcObject>
collection; // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
});
fp.each(valueIterator, array); // $ExpectType AbcObject[]
fp.each(valueIterator)(array); // $ExpectType AbcObject[]
@ -2453,35 +2453,35 @@ _.chain([1, 2, 3, 4]).unshift(5, 6); // $ExpectType CollectionChain<number>
index; // $ExpectType number
collection; // $ExpectType AbcObject[]
});
// $ExpectType ArrayLike<AbcObject> | null | undefined
// $ExpectType ArrayLike<AbcObject> | null | undefined || List<AbcObject> | null | undefined
_.eachRight(nilList, (value, index, collection) => {
value; // $ExpectType AbcObject
index; // $ExpectType number
collection; // $ExpectType ArrayLike<AbcObject>
collection; // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
});
// $ExpectType Collection<AbcObject>
_(array).eachRight((value, index, collection) => {
value; // $ExpectType AbcObject
index; // $ExpectType number
collection; // $ExpectType ArrayLike<AbcObject>
collection; // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
});
// $ExpectType Collection<AbcObject>
_(nilList).eachRight((value, index, collection) => {
value; // $ExpectType AbcObject
index; // $ExpectType number
collection; // $ExpectType ArrayLike<AbcObject>
collection; // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
});
// $ExpectType CollectionChain<AbcObject>
_.chain(array).eachRight((value, index, collection) => {
value; // $ExpectType AbcObject
index; // $ExpectType number
collection; // $ExpectType ArrayLike<AbcObject>
collection; // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
});
// $ExpectType CollectionChain<AbcObject>
_.chain(nilList).eachRight((value, index, collection) => {
value; // $ExpectType AbcObject
index; // $ExpectType number
collection; // $ExpectType ArrayLike<AbcObject>
collection; // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
});
fp.eachRight(valueIterator, array); // $ExpectType AbcObject[]
fp.eachRight(valueIterator)(array); // $ExpectType AbcObject[]
@ -2712,7 +2712,7 @@ _.chain([1, 2, 3, 4]).unshift(5, 6); // $ExpectType CollectionChain<number>
_.map(list, (value, index, collection) => {
value; // $ExpectType AbcObject
index; // $ExpectType number
collection; // $ExpectType ArrayLike<AbcObject>
collection; // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
return 0;
});
_.map(dictionary); // $ExpectType AbcObject[]
@ -2746,7 +2746,7 @@ _.chain([1, 2, 3, 4]).unshift(5, 6); // $ExpectType CollectionChain<number>
_(list).map((value, index, collection) => {
value; // $ExpectType AbcObject
index; // $ExpectType number
collection; // $ExpectType ArrayLike<AbcObject>
collection; // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
return 0;
});
_(dictionary).map(); // $ExpectType Collection<AbcObject>
@ -2780,7 +2780,7 @@ _.chain([1, 2, 3, 4]).unshift(5, 6); // $ExpectType CollectionChain<number>
_.chain(list).map((value, index, collection) => {
value; // $ExpectType AbcObject
index; // $ExpectType number
collection; // $ExpectType ArrayLike<AbcObject>
collection; // $ExpectType ArrayLike<AbcObject> || List<AbcObject>
return 0;
});
_.chain(dictionary).map(); // $ExpectType CollectionChain<AbcObject>

2
types/mustache-express/mustache-express-tests.ts
View File

@ -6,5 +6,5 @@ app.engine('mustache', mustacheExpress());
app.engine('mustache', mustacheExpress('/partials'));
app.engine('mustache', mustacheExpress('/partials', '.mst'));
// $ExpectType Cache<string, { name: string; data: string; partials: string[]; }>
// $ExpectType Cache<string, { name: string; data: string; partials: string[]; }> || TemplateCache
mustacheExpress().cache;

708
types/numeric/numeric-tests.ts
View File

@ -16,408 +16,408 @@ numeric.toCSV([[25, 52, 62, 66], ["car", "bad", "bike", {}]]); // $ExpectType st
numeric.imageURL([[25, 50], [52, 52]]); // $ExpectType string
numeric.getURL('sdf'); // $ExpectType any
numeric.dim(matrix); // $ExpectType number[]
numeric.dim(matrix); // $ExpectType number[] || Vector
numeric.same(25, [25]); // $ExpectType boolean
numeric.rep([2, 5], true);
numeric.dotMMsmall(matrix, matrix); // $ExpectType number[][]
numeric.dotMMbig(matrix, matrix); // $ExpectType number[][]
numeric.dotMV(matrix, vector); // $ExpectType number[]
numeric.dotVM(vector, matrix); // $ExpectType number[]
numeric.dotMMsmall(matrix, matrix); // $ExpectType number[][] || Matrix
numeric.dotMMbig(matrix, matrix); // $ExpectType number[][] || Matrix
numeric.dotMV(matrix, vector); // $ExpectType number[] || Vector
numeric.dotVM(vector, matrix); // $ExpectType number[] || Vector
numeric.dotVV(vector, vector); // $ExpectType number
numeric.dot(vector, matrix); // $ExpectType number | number[] | number[][]
numeric.diag([25, 52]); // $ExpectType number[][]
numeric.getDiag(matrix); // $ExpectType number[]
numeric.identity(24); // $ExpectType number[][]
numeric.dot(vector, matrix); // $ExpectType number | number[] | number[][] || number | Vector | Matrix
numeric.diag([25, 52]); // $ExpectType number[][] || Matrix
numeric.getDiag(matrix); // $ExpectType number[] || Vector
numeric.identity(24); // $ExpectType number[][] || Matrix
numeric.abs(matrix); // $ExpectType number[][]
numeric.absV(vector); // $ExpectType number[]
numeric.abseqV(vector); // $ExpectType number[]
numeric.abseq(matrix); // $ExpectType number[][]
numeric.abs(matrix); // $ExpectType number[][] || Matrix
numeric.absV(vector); // $ExpectType number[] || Vector
numeric.abseqV(vector); // $ExpectType number[] || Vector
numeric.abseq(matrix); // $ExpectType number[][] || Matrix
numeric.acos(matrix); // $ExpectType number[][]
numeric.acosV(vector); // $ExpectType number[]
numeric.acoseqV(vector); // $ExpectType number[]
numeric.acoseq(matrix); // $ExpectType number[][]
numeric.acos(matrix); // $ExpectType number[][] || Matrix
numeric.acosV(vector); // $ExpectType number[] || Vector
numeric.acoseqV(vector); // $ExpectType number[] || Vector
numeric.acoseq(matrix); // $ExpectType number[][] || Matrix
numeric.asin(matrix); // $ExpectType number[][]
numeric.asinV(vector); // $ExpectType number[]
numeric.asineqV(vector); // $ExpectType number[]
numeric.asineq(matrix); // $ExpectType number[][]
numeric.asin(matrix); // $ExpectType number[][] || Matrix
numeric.asinV(vector); // $ExpectType number[] || Vector
numeric.asineqV(vector); // $ExpectType number[] || Vector
numeric.asineq(matrix); // $ExpectType number[][] || Matrix
numeric.atan(matrix); // $ExpectType number[][]
numeric.atanV(vector); // $ExpectType number[]
numeric.ataneqV(vector); // $ExpectType number[]
numeric.ataneq(matrix); // $ExpectType number[][]
numeric.atan(matrix); // $ExpectType number[][] || Matrix
numeric.atanV(vector); // $ExpectType number[] || Vector
numeric.ataneqV(vector); // $ExpectType number[] || Vector
numeric.ataneq(matrix); // $ExpectType number[][] || Matrix
numeric.ceil(matrix); // $ExpectType number[][]
numeric.ceilV(vector); // $ExpectType number[]
numeric.ceileqV(vector); // $ExpectType number[]
numeric.ceileq(matrix); // $ExpectType number[][]
numeric.ceil(matrix); // $ExpectType number[][] || Matrix
numeric.ceilV(vector); // $ExpectType number[] || Vector
numeric.ceileqV(vector); // $ExpectType number[] || Vector
numeric.ceileq(matrix); // $ExpectType number[][] || Matrix
numeric.cos(matrix); // $ExpectType number[][]
numeric.cosV(vector); // $ExpectType number[]
numeric.coseqV(vector); // $ExpectType number[]
numeric.coseq(matrix); // $ExpectType number[][]
numeric.cos(matrix); // $ExpectType number[][] || Matrix
numeric.cosV(vector); // $ExpectType number[] || Vector
numeric.coseqV(vector); // $ExpectType number[] || Vector
numeric.coseq(matrix); // $ExpectType number[][] || Matrix
numeric.exp(matrix); // $ExpectType number[][]
numeric.expV(vector); // $ExpectType number[]
numeric.expeqV(vector); // $ExpectType number[]
numeric.expeq(matrix); // $ExpectType number[][]
numeric.exp(matrix); // $ExpectType number[][] || Matrix
numeric.expV(vector); // $ExpectType number[] || Vector
numeric.expeqV(vector); // $ExpectType number[] || Vector
numeric.expeq(matrix); // $ExpectType number[][] || Matrix
numeric.floor(matrix); // $ExpectType number[][]
numeric.floorV(vector); // $ExpectType number[]
numeric.flooreqV(vector); // $ExpectType number[]
numeric.flooreq(matrix); // $ExpectType number[][]
numeric.floor(matrix); // $ExpectType number[][] || Matrix
numeric.floorV(vector); // $ExpectType number[] || Vector
numeric.flooreqV(vector); // $ExpectType number[] || Vector
numeric.flooreq(matrix); // $ExpectType number[][] || Matrix
numeric.log(matrix); // $ExpectType number[][]
numeric.logV(vector); // $ExpectType number[]
numeric.logeqV(vector); // $ExpectType number[]
numeric.logeq(matrix); // $ExpectType number[][]
numeric.log(matrix); // $ExpectType number[][] || Matrix
numeric.logV(vector); // $ExpectType number[] || Vector
numeric.logeqV(vector); // $ExpectType number[] || Vector
numeric.logeq(matrix); // $ExpectType number[][] || Matrix
numeric.round(matrix); // $ExpectType number[][]
numeric.roundV(vector); // $ExpectType number[]
numeric.roundeqV(vector); // $ExpectType number[]
numeric.roundeq(matrix); // $ExpectType number[][]
numeric.round(matrix); // $ExpectType number[][] || Matrix
numeric.roundV(vector); // $ExpectType number[] || Vector
numeric.roundeqV(vector); // $ExpectType number[] || Vector
numeric.roundeq(matrix); // $ExpectType number[][] || Matrix
numeric.sin(matrix); // $ExpectType number[][]
numeric.sinV(vector); // $ExpectType number[]
numeric.sineqV(vector); // $ExpectType number[]
numeric.sineq(matrix); // $ExpectType number[][]
numeric.sin(matrix); // $ExpectType number[][] || Matrix
numeric.sinV(vector); // $ExpectType number[] || Vector
numeric.sineqV(vector); // $ExpectType number[] || Vector
numeric.sineq(matrix); // $ExpectType number[][] || Matrix
numeric.sqrt(matrix); // $ExpectType number[][]
numeric.sqrtV(vector); // $ExpectType number[]
numeric.sqrteqV(vector); // $ExpectType number[]
numeric.sqrteq(matrix); // $ExpectType number[][]
numeric.sqrt(matrix); // $ExpectType number[][] || Matrix
numeric.sqrtV(vector); // $ExpectType number[] || Vector
numeric.sqrteqV(vector); // $ExpectType number[] || Vector
numeric.sqrteq(matrix); // $ExpectType number[][] || Matrix
numeric.tan(matrix); // $ExpectType number[][]
numeric.tanV(vector); // $ExpectType number[]
numeric.taneqV(vector); // $ExpectType number[]
numeric.taneq(matrix); // $ExpectType number[][]
numeric.tan(matrix); // $ExpectType number[][] || Matrix
numeric.tanV(vector); // $ExpectType number[] || Vector
numeric.taneqV(vector); // $ExpectType number[] || Vector
numeric.taneq(matrix); // $ExpectType number[][] || Matrix
numeric.isNaN(vector); // $ExpectType boolean[]
numeric.isNaN(vector); // $ExpectType boolean[] || VectorBoolean
numeric.isNaN(threeDimensionalMatrix); // $ExpectType MultidimensionalArray<boolean>
numeric.isNaNV(vector); // $ExpectType boolean[]
numeric.isNaNeqV(vector); // $ExpectType boolean[]
numeric.isNaNeq(vector); // $ExpectType boolean[]
numeric.isNaNV(vector); // $ExpectType boolean[] || VectorBoolean
numeric.isNaNeqV(vector); // $ExpectType boolean[] || VectorBoolean
numeric.isNaNeq(vector); // $ExpectType boolean[] || VectorBoolean
numeric.isNaNeq(threeDimensionalMatrix); // $ExpectType MultidimensionalArray<boolean>
numeric.isFinite(vector); // $ExpectType boolean[]
numeric.isFinite(vector); // $ExpectType boolean[] || VectorBoolean
numeric.isFinite(threeDimensionalMatrix); // $ExpectType MultidimensionalArray<boolean>
numeric.isFiniteV(vector); // $ExpectType boolean[]
numeric.isFiniteeqV(vector); // $ExpectType boolean[]
numeric.isFiniteeq(vector); // $ExpectType boolean[]
numeric.isFiniteV(vector); // $ExpectType boolean[] || VectorBoolean
numeric.isFiniteeqV(vector); // $ExpectType boolean[] || VectorBoolean
numeric.isFiniteeq(vector); // $ExpectType boolean[] || VectorBoolean
numeric.isFiniteeq(threeDimensionalMatrix); // $ExpectType MultidimensionalArray<boolean>
numeric.neg(matrix); // $ExpectType number[][]
numeric.negV(vector); // $ExpectType number[]
numeric.negeqV(vector); // $ExpectType number[]
numeric.negeq(matrix); // $ExpectType number[][]
numeric.neg(matrix); // $ExpectType number[][] || Matrix
numeric.negV(vector); // $ExpectType number[] || Vector
numeric.negeqV(vector); // $ExpectType number[] || Vector
numeric.negeq(matrix); // $ExpectType number[][] || Matrix
numeric.bnot(matrix); // $ExpectType number[][]
numeric.bnotV(vector); // $ExpectType number[]
numeric.bnoteqV(vector); // $ExpectType number[]
numeric.bnoteq(matrix); // $ExpectType number[][]
numeric.bnot(matrix); // $ExpectType number[][] || Matrix
numeric.bnotV(vector); // $ExpectType number[] || Vector
numeric.bnoteqV(vector); // $ExpectType number[] || Vector
numeric.bnoteq(matrix); // $ExpectType number[][] || Matrix
numeric.not(2); // $ExpectType boolean
numeric.not(vector); // $ExpectType boolean[]
numeric.not(vector); // $ExpectType boolean[] || VectorBoolean
numeric.not(threeDimensionalMatrix); // $ExpectType MultidimensionalArray<boolean>
numeric.notV(vector); // $ExpectType boolean[]
numeric.notV(vector); // $ExpectType boolean[] || VectorBoolean
numeric.noteq(2); // $ExpectType boolean
numeric.noteq(vector); // $ExpectType boolean[]
numeric.noteq(vector); // $ExpectType boolean[] || VectorBoolean
numeric.noteq(threeDimensionalMatrix); // $ExpectType MultidimensionalArray<boolean>
numeric.noteqV(vector); // $ExpectType boolean[]
numeric.noteqV(vector); // $ExpectType boolean[] || VectorBoolean
numeric.clone(vector); // $ExpectType number[]
numeric.clone(vector); // $ExpectType number[] || Vector
numeric.cloneV(vector); // $ExpectType NonNullPrimitive[]
numeric.cloneeq(vector); // $ExpectType NonNullPrimitive[]
numeric.cloneeqV(vector); // $ExpectType NonNullPrimitive[]
numeric.add(2, 5, 6); // $ExpectType number
numeric.add(2, 3, vector); // $ExpectType number[]
numeric.add(2, 3, vector); // $ExpectType number[] || Vector
numeric.add(threeDimensionalMatrix, 2, threeDimensionalMatrix); // $ExpectType number[][][]
numeric["+"](2, 5, 6); // $ExpectType number
numeric["+"](2, 3, vector); // $ExpectType number[]
numeric["+"](2, 3, vector); // $ExpectType number[] || Vector
numeric["+"](threeDimensionalMatrix, 2, 4); // $ExpectType number[][][]
numeric.addVV(vector, vector); // $ExpectType number[]
numeric.addSV(2, vector); // $ExpectType number[]
numeric.addVS(vector, 2); // $ExpectType number[]
numeric.addeq(vector, 3); // $ExpectType number[]
numeric.addeqV(vector, vector); // $ExpectType number[]
numeric.addeqS(vector, 3); // $ExpectType number[]
numeric.addVV(vector, vector); // $ExpectType number[] || Vector
numeric.addSV(2, vector); // $ExpectType number[] || Vector
numeric.addVS(vector, 2); // $ExpectType number[] || Vector
numeric.addeq(vector, 3); // $ExpectType number[] || Vector
numeric.addeqV(vector, vector); // $ExpectType number[] || Vector
numeric.addeqS(vector, 3); // $ExpectType number[] || Vector
numeric.sub(2, 5, 6); // $ExpectType number
numeric.sub(2, 3, vector); // $ExpectType number[]
numeric.sub(2, 3, vector); // $ExpectType number[] || Vector
numeric.sub(threeDimensionalMatrix, 2, threeDimensionalMatrix); // $ExpectType number[][][]
numeric["-"](2, 5, 6); // $ExpectType number
numeric["-"](2, 3, vector); // $ExpectType number[]
numeric["-"](2, 3, vector); // $ExpectType number[] || Vector
numeric["-"](threeDimensionalMatrix, 2, 4); // $ExpectType number[][][]
numeric.subVV(vector, vector); // $ExpectType number[]
numeric.subSV(2, vector); // $ExpectType number[]
numeric.subVS(vector, 2); // $ExpectType number[]
numeric.subeq(vector, 3); // $ExpectType number[]
numeric.subeqV(vector, vector); // $ExpectType number[]
numeric.subeqS(vector, 3); // $ExpectType number[]
numeric.subVV(vector, vector); // $ExpectType number[] || Vector
numeric.subSV(2, vector); // $ExpectType number[] || Vector
numeric.subVS(vector, 2); // $ExpectType number[] || Vector
numeric.subeq(vector, 3); // $ExpectType number[] || Vector
numeric.subeqV(vector, vector); // $ExpectType number[] || Vector
numeric.subeqS(vector, 3); // $ExpectType number[] || Vector
numeric.mul(2, 5, 6); // $ExpectType number
numeric.mul(2, 3, vector); // $ExpectType number[]
numeric.mul(2, 3, vector); // $ExpectType number[] || Vector
numeric.mul(threeDimensionalMatrix, 2, threeDimensionalMatrix); // $ExpectType number[][][]
numeric["*"](2, 5, 6); // $ExpectType number
numeric["*"](2, 3, vector); // $ExpectType number[]
numeric["*"](2, 3, vector); // $ExpectType number[] || Vector
numeric["*"](threeDimensionalMatrix, 2, 4); // $ExpectType number[][][]
numeric.mulVV(vector, vector); // $ExpectType number[]
numeric.mulSV(2, vector); // $ExpectType number[]
numeric.mulVS(vector, 2); // $ExpectType number[]
numeric.muleq(vector, 3); // $ExpectType number[]
numeric.muleqV(vector, vector); // $ExpectType number[]
numeric.muleqS(vector, 3); // $ExpectType number[]
numeric.mulVV(vector, vector); // $ExpectType number[] || Vector
numeric.mulSV(2, vector); // $ExpectType number[] || Vector
numeric.mulVS(vector, 2); // $ExpectType number[] || Vector
numeric.muleq(vector, 3); // $ExpectType number[] || Vector
numeric.muleqV(vector, vector); // $ExpectType number[] || Vector
numeric.muleqS(vector, 3); // $ExpectType number[] || Vector
numeric.div(2, 5, 6); // $ExpectType number
numeric.div(2, 3, vector); // $ExpectType number[]
numeric.div(2, 3, vector); // $ExpectType number[] || Vector
numeric.div(threeDimensionalMatrix, 2, threeDimensionalMatrix); // $ExpectType number[][][]
numeric["/"](2, 5, 6); // $ExpectType number
numeric["/"](2, 3, vector); // $ExpectType number[]
numeric["/"](2, 3, vector); // $ExpectType number[] || Vector
numeric["/"](threeDimensionalMatrix, 2, 4); // $ExpectType number[][][]
numeric.divVV(vector, vector); // $ExpectType number[]
numeric.divSV(2, vector); // $ExpectType number[]
numeric.divVS(vector, 2); // $ExpectType number[]
numeric.diveq(vector, 3); // $ExpectType number[]
numeric.diveqV(vector, vector); // $ExpectType number[]
numeric.diveqS(vector, 3); // $ExpectType number[]
numeric.divVV(vector, vector); // $ExpectType number[] || Vector
numeric.divSV(2, vector); // $ExpectType number[] || Vector
numeric.divVS(vector, 2); // $ExpectType number[] || Vector
numeric.diveq(vector, 3); // $ExpectType number[] || Vector
numeric.diveqV(vector, vector); // $ExpectType number[] || Vector
numeric.diveqS(vector, 3); // $ExpectType number[] || Vector
numeric.mod(2, 5, 6); // $ExpectType number
numeric.mod(2, 3, vector); // $ExpectType number[]
numeric.mod(2, 3, vector); // $ExpectType number[] || Vector
numeric.mod(threeDimensionalMatrix, 2, threeDimensionalMatrix); // $ExpectType number[][][]
numeric["%"](2, 5, 6); // $ExpectType number
numeric["%"](2, 3, vector); // $ExpectType number[]
numeric["%"](2, 3, vector); // $ExpectType number[] || Vector
numeric["%"](threeDimensionalMatrix, 2, 4); // $ExpectType number[][][]
numeric.modVV(vector, vector); // $ExpectType number[]
numeric.modSV(2, vector); // $ExpectType number[]
numeric.modVS(vector, 2); // $ExpectType number[]
numeric.modeq(vector, 3); // $ExpectType number[]
numeric.modeqV(vector, vector); // $ExpectType number[]
numeric.modeqS(vector, 3); // $ExpectType number[]
numeric.modVV(vector, vector); // $ExpectType number[] || Vector
numeric.modSV(2, vector); // $ExpectType number[] || Vector
numeric.modVS(vector, 2); // $ExpectType number[] || Vector
numeric.modeq(vector, 3); // $ExpectType number[] || Vector
numeric.modeqV(vector, vector); // $ExpectType number[] || Vector
numeric.modeqS(vector, 3); // $ExpectType number[] || Vector
numeric.and(2, 5, 6); // $ExpectType number
numeric.and(2, 3, vector); // $ExpectType number[]
numeric.and(2, 3, vector); // $ExpectType number[] || Vector
numeric.and(threeDimensionalMatrix, 2, threeDimensionalMatrix); // $ExpectType number[][][]
numeric["&&"](2, 5, 6); // $ExpectType number
numeric["&&"](2, 3, vector); // $ExpectType number[]
numeric["&&"](2, 3, vector); // $ExpectType number[] || Vector
numeric["&&"](threeDimensionalMatrix, 2, 4); // $ExpectType number[][][]
numeric.andVV(vector, vector); // $ExpectType number[]
numeric.andSV(2, vector); // $ExpectType number[]
numeric.andVS(vector, 2); // $ExpectType number[]
numeric.andeq(vector, 3); // $ExpectType number[]
numeric.andeqV(vector, vector); // $ExpectType number[]
numeric.andeqS(vector, 3); // $ExpectType number[]
numeric.andVV(vector, vector); // $ExpectType number[] || Vector
numeric.andSV(2, vector); // $ExpectType number[] || Vector
numeric.andVS(vector, 2); // $ExpectType number[] || Vector
numeric.andeq(vector, 3); // $ExpectType number[] || Vector
numeric.andeqV(vector, vector); // $ExpectType number[] || Vector
numeric.andeqS(vector, 3); // $ExpectType number[] || Vector
numeric.or(2, 5, 6); // $ExpectType number
numeric.or(2, 3, vector); // $ExpectType number[]
numeric.or(2, 3, vector); // $ExpectType number[] || Vector
numeric.or(threeDimensionalMatrix, 2, threeDimensionalMatrix); // $ExpectType number[][][]
numeric["||"](2, 5, 6); // $ExpectType number
numeric["||"](2, 3, vector); // $ExpectType number[]
numeric["||"](2, 3, vector); // $ExpectType number[] || Vector
numeric["||"](threeDimensionalMatrix, 2, 4); // $ExpectType number[][][]
numeric.orVV(vector, vector); // $ExpectType number[]
numeric.orSV(2, vector); // $ExpectType number[]
numeric.orVS(vector, 2); // $ExpectType number[]
numeric.oreq(vector, 3); // $ExpectType number[]
numeric.oreqV(vector, vector); // $ExpectType number[]
numeric.oreqS(vector, 3); // $ExpectType number[]
numeric.orVV(vector, vector); // $ExpectType number[] || Vector
numeric.orSV(2, vector); // $ExpectType number[] || Vector
numeric.orVS(vector, 2); // $ExpectType number[] || Vector
numeric.oreq(vector, 3); // $ExpectType number[] || Vector
numeric.oreqV(vector, vector); // $ExpectType number[] || Vector
numeric.oreqS(vector, 3); // $ExpectType number[] || Vector
numeric.eq(2, 5); // $ExpectType boolean
numeric.eq(2, vector); // $ExpectType boolean[]
numeric.eq(2, vector); // $ExpectType boolean[] || VectorBoolean
numeric.eq(threeDimensionalMatrix, threeDimensionalMatrix); // $ExpectType MultidimensionalArray<boolean>
numeric["==="](2, 5); // $ExpectType boolean
numeric["==="](2, vector); // $ExpectType boolean[]
numeric["==="](2, vector); // $ExpectType boolean[] || VectorBoolean
numeric["==="](threeDimensionalMatrix, threeDimensionalMatrix); // $ExpectType MultidimensionalArray<boolean>
numeric.eqVV(vector, vector); // $ExpectType boolean[]
numeric.eqSV(2, vector); // $ExpectType boolean[]
numeric.eqVS(vector, 2); // $ExpectType boolean[]
numeric.eqeq(vector, 3); // $ExpectType boolean[]
numeric.eqeqV(vector, vector); // $ExpectType boolean[]
numeric.eqeqS(vector, 3); // $ExpectType boolean[]
numeric.eqVV(vector, vector); // $ExpectType boolean[] || VectorBoolean
numeric.eqSV(2, vector); // $ExpectType boolean[] || VectorBoolean
numeric.eqVS(vector, 2); // $ExpectType boolean[] || VectorBoolean
numeric.eqeq(vector, 3); // $ExpectType boolean[] || VectorBoolean
numeric.eqeqV(vector, vector); // $ExpectType boolean[] || VectorBoolean
numeric.eqeqS(vector, 3); // $ExpectType boolean[] || VectorBoolean
numeric.neq(2, 5); // $ExpectType boolean
numeric.neq(2, vector); // $ExpectType boolean[]
numeric.neq(2, vector); // $ExpectType boolean[] || VectorBoolean
numeric.neq(threeDimensionalMatrix, threeDimensionalMatrix); // $ExpectType MultidimensionalArray<boolean>
numeric["==="](2, 5); // $ExpectType boolean
numeric["==="](2, vector); // $ExpectType boolean[]
numeric["==="](2, vector); // $ExpectType boolean[] || VectorBoolean
numeric["==="](threeDimensionalMatrix, threeDimensionalMatrix); // $ExpectType MultidimensionalArray<boolean>
numeric.neqVV(vector, vector); // $ExpectType boolean[]
numeric.neqSV(2, vector); // $ExpectType boolean[]
numeric.neqVS(vector, 2); // $ExpectType boolean[]
numeric.neqeq(vector, 3); // $ExpectType boolean[]
numeric.neqeqV(vector, vector); // $ExpectType boolean[]
numeric.neqeqS(vector, 3); // $ExpectType boolean[]
numeric.neqVV(vector, vector); // $ExpectType boolean[] || VectorBoolean
numeric.neqSV(2, vector); // $ExpectType boolean[] || VectorBoolean
numeric.neqVS(vector, 2); // $ExpectType boolean[] || VectorBoolean
numeric.neqeq(vector, 3); // $ExpectType boolean[] || VectorBoolean
numeric.neqeqV(vector, vector); // $ExpectType boolean[] || VectorBoolean
numeric.neqeqS(vector, 3); // $ExpectType boolean[] || VectorBoolean
numeric.lt(2, 5); // $ExpectType boolean
numeric.lt(2, vector); // $ExpectType boolean[]
numeric.lt(2, vector); // $ExpectType boolean[] || VectorBoolean
numeric.lt(threeDimensionalMatrix, threeDimensionalMatrix); // $ExpectType MultidimensionalArray<boolean>
numeric["==="](2, 5); // $ExpectType boolean
numeric["==="](2, vector); // $ExpectType boolean[]
numeric["==="](2, vector); // $ExpectType boolean[] || VectorBoolean
numeric["==="](threeDimensionalMatrix, threeDimensionalMatrix); // $ExpectType MultidimensionalArray<boolean>
numeric.ltVV(vector, vector); // $ExpectType boolean[]
numeric.ltSV(2, vector); // $ExpectType boolean[]
numeric.ltVS(vector, 2); // $ExpectType boolean[]
numeric.lteq(vector, 3); // $ExpectType boolean[]
numeric.lteqV(vector, vector); // $ExpectType boolean[]
numeric.lteqS(vector, 3); // $ExpectType boolean[]
numeric.ltVV(vector, vector); // $ExpectType boolean[] || VectorBoolean
numeric.ltSV(2, vector); // $ExpectType boolean[] || VectorBoolean
numeric.ltVS(vector, 2); // $ExpectType boolean[] || VectorBoolean
numeric.lteq(vector, 3); // $ExpectType boolean[] || VectorBoolean
numeric.lteqV(vector, vector); // $ExpectType boolean[] || VectorBoolean
numeric.lteqS(vector, 3); // $ExpectType boolean[] || VectorBoolean
numeric.gt(2, 5); // $ExpectType boolean
numeric.gt(2, vector); // $ExpectType boolean[]
numeric.gt(2, vector); // $ExpectType boolean[] || VectorBoolean
numeric.gt(threeDimensionalMatrix, threeDimensionalMatrix); // $ExpectType MultidimensionalArray<boolean>
numeric["==="](2, 5); // $ExpectType boolean
numeric["==="](2, vector); // $ExpectType boolean[]
numeric["==="](2, vector); // $ExpectType boolean[] || VectorBoolean
numeric["==="](threeDimensionalMatrix, threeDimensionalMatrix); // $ExpectType MultidimensionalArray<boolean>
numeric.gtVV(vector, vector); // $ExpectType boolean[]
numeric.gtSV(2, vector); // $ExpectType boolean[]
numeric.gtVS(vector, 2); // $ExpectType boolean[]
numeric.gteq(vector, 3); // $ExpectType boolean[]
numeric.gteqV(vector, vector); // $ExpectType boolean[]
numeric.gteqS(vector, 3); // $ExpectType boolean[]
numeric.gtVV(vector, vector); // $ExpectType boolean[] || VectorBoolean
numeric.gtSV(2, vector); // $ExpectType boolean[] || VectorBoolean
numeric.gtVS(vector, 2); // $ExpectType boolean[] || VectorBoolean
numeric.gteq(vector, 3); // $ExpectType boolean[] || VectorBoolean
numeric.gteqV(vector, vector); // $ExpectType boolean[] || VectorBoolean
numeric.gteqS(vector, 3); // $ExpectType boolean[] || VectorBoolean
numeric.leq(2, 5); // $ExpectType boolean
numeric.leq(2, vector); // $ExpectType boolean[]
numeric.leq(2, vector); // $ExpectType boolean[] || VectorBoolean
numeric.leq(threeDimensionalMatrix, threeDimensionalMatrix); // $ExpectType MultidimensionalArray<boolean>
numeric["==="](2, 5); // $ExpectType boolean
numeric["==="](2, vector); // $ExpectType boolean[]
numeric["==="](2, vector); // $ExpectType boolean[] || VectorBoolean
numeric["==="](threeDimensionalMatrix, threeDimensionalMatrix); // $ExpectType MultidimensionalArray<boolean>
numeric.leqVV(vector, vector); // $ExpectType boolean[]
numeric.leqSV(2, vector); // $ExpectType boolean[]
numeric.leqVS(vector, 2); // $ExpectType boolean[]
numeric.leqeq(vector, 3); // $ExpectType boolean[]
numeric.leqeqV(vector, vector); // $ExpectType boolean[]
numeric.leqeqS(vector, 3); // $ExpectType boolean[]
numeric.leqVV(vector, vector); // $ExpectType boolean[] || VectorBoolean
numeric.leqSV(2, vector); // $ExpectType boolean[] || VectorBoolean
numeric.leqVS(vector, 2); // $ExpectType boolean[] || VectorBoolean
numeric.leqeq(vector, 3); // $ExpectType boolean[] || VectorBoolean
numeric.leqeqV(vector, vector); // $ExpectType boolean[] || VectorBoolean
numeric.leqeqS(vector, 3); // $ExpectType boolean[] || VectorBoolean
numeric.geq(2, 5); // $ExpectType boolean
numeric.geq(2, vector); // $ExpectType boolean[]
numeric.geq(2, vector); // $ExpectType boolean[] || VectorBoolean
numeric.geq(threeDimensionalMatrix, threeDimensionalMatrix); // $ExpectType MultidimensionalArray<boolean>
numeric["==="](2, 5); // $ExpectType boolean
numeric["==="](2, vector); // $ExpectType boolean[]
numeric["==="](2, vector); // $ExpectType boolean[] || VectorBoolean
numeric["==="](threeDimensionalMatrix, threeDimensionalMatrix); // $ExpectType MultidimensionalArray<boolean>
numeric.geqVV(vector, vector); // $ExpectType boolean[]
numeric.geqSV(2, vector); // $ExpectType boolean[]
numeric.geqVS(vector, 2); // $ExpectType boolean[]
numeric.geqeq(vector, 3); // $ExpectType boolean[]
numeric.geqeqV(vector, vector); // $ExpectType boolean[]
numeric.geqeqS(vector, 3); // $ExpectType boolean[]
numeric.geqVV(vector, vector); // $ExpectType boolean[] || VectorBoolean
numeric.geqSV(2, vector); // $ExpectType boolean[] || VectorBoolean
numeric.geqVS(vector, 2); // $ExpectType boolean[] || VectorBoolean
numeric.geqeq(vector, 3); // $ExpectType boolean[] || VectorBoolean
numeric.geqeqV(vector, vector); // $ExpectType boolean[] || VectorBoolean
numeric.geqeqS(vector, 3); // $ExpectType boolean[] || VectorBoolean
numeric.band(2, 5, 6); // $ExpectType number
numeric.band(2, 3, vector); // $ExpectType number[]
numeric.band(2, 3, vector); // $ExpectType number[] || Vector
numeric.band(threeDimensionalMatrix, 2, threeDimensionalMatrix); // $ExpectType number[][][]
numeric["&"](2, 5, 6); // $ExpectType number
numeric["&"](2, 3, vector); // $ExpectType number[]
numeric["&"](2, 3, vector); // $ExpectType number[] || Vector
numeric["&"](threeDimensionalMatrix, 2, 4); // $ExpectType number[][][]
numeric.bandVV(vector, vector); // $ExpectType number[]
numeric.bandSV(2, vector); // $ExpectType number[]
numeric.bandVS(vector, 2); // $ExpectType number[]
numeric.bandeq(vector, 3); // $ExpectType number[]
numeric.bandeqV(vector, vector); // $ExpectType number[]
numeric.bandeqS(vector, 3); // $ExpectType number[]
numeric.bandVV(vector, vector); // $ExpectType number[] || Vector
numeric.bandSV(2, vector); // $ExpectType number[] || Vector
numeric.bandVS(vector, 2); // $ExpectType number[] || Vector
numeric.bandeq(vector, 3); // $ExpectType number[] || Vector
numeric.bandeqV(vector, vector); // $ExpectType number[] || Vector
numeric.bandeqS(vector, 3); // $ExpectType number[] || Vector
numeric.bor(2, 5, 6); // $ExpectType number
numeric.bor(2, 3, vector); // $ExpectType number[]
numeric.bor(2, 3, vector); // $ExpectType number[] || Vector
numeric.bor(threeDimensionalMatrix, 2, threeDimensionalMatrix); // $ExpectType number[][][]
numeric["|"](2, 5, 6); // $ExpectType number
numeric["|"](2, 3, vector); // $ExpectType number[]
numeric["|"](2, 3, vector); // $ExpectType number[] || Vector
numeric["|"](threeDimensionalMatrix, 2, 4); // $ExpectType number[][][]
numeric.borVV(vector, vector); // $ExpectType number[]
numeric.borSV(2, vector); // $ExpectType number[]
numeric.borVS(vector, 2); // $ExpectType number[]
numeric.boreq(vector, 3); // $ExpectType number[]
numeric.boreqV(vector, vector); // $ExpectType number[]
numeric.boreqS(vector, 3); // $ExpectType number[]
numeric.borVV(vector, vector); // $ExpectType number[] || Vector
numeric.borSV(2, vector); // $ExpectType number[] || Vector
numeric.borVS(vector, 2); // $ExpectType number[] || Vector
numeric.boreq(vector, 3); // $ExpectType number[] || Vector
numeric.boreqV(vector, vector); // $ExpectType number[] || Vector
numeric.boreqS(vector, 3); // $ExpectType number[] || Vector
numeric.bxor(2, 5, 6); // $ExpectType number
numeric.bxor(2, 3, vector); // $ExpectType number[]
numeric.bxor(2, 3, vector); // $ExpectType number[] || Vector
numeric.bxor(threeDimensionalMatrix, 2, threeDimensionalMatrix); // $ExpectType number[][][]
numeric["^"](2, 5, 6); // $ExpectType number
numeric["^"](2, 3, vector); // $ExpectType number[]
numeric["^"](2, 3, vector); // $ExpectType number[] || Vector
numeric["^"](threeDimensionalMatrix, 2, 4); // $ExpectType number[][][]
numeric.bxorVV(vector, vector); // $ExpectType number[]
numeric.bxorSV(2, vector); // $ExpectType number[]
numeric.bxorVS(vector, 2); // $ExpectType number[]
numeric.bxoreq(vector, 3); // $ExpectType number[]
numeric.bxoreqV(vector, vector); // $ExpectType number[]
numeric.bxoreqS(vector, 3); // $ExpectType number[]
numeric.bxorVV(vector, vector); // $ExpectType number[] || Vector
numeric.bxorSV(2, vector); // $ExpectType number[] || Vector
numeric.bxorVS(vector, 2); // $ExpectType number[] || Vector
numeric.bxoreq(vector, 3); // $ExpectType number[] || Vector
numeric.bxoreqV(vector, vector); // $ExpectType number[] || Vector
numeric.bxoreqS(vector, 3); // $ExpectType number[] || Vector
numeric.lshift(2, 5, 6); // $ExpectType number
numeric.lshift(2, 3, vector); // $ExpectType number[]
numeric.lshift(2, 3, vector); // $ExpectType number[] || Vector
numeric.lshift(threeDimensionalMatrix, 2, threeDimensionalMatrix); // $ExpectType number[][][]
numeric["<<"](2, 5, 6); // $ExpectType number
numeric["<<"](2, 3, vector); // $ExpectType number[]
numeric["<<"](2, 3, vector); // $ExpectType number[] || Vector
numeric["<<"](threeDimensionalMatrix, 2, 4); // $ExpectType number[][][]
numeric.lshiftVV(vector, vector); // $ExpectType number[]
numeric.lshiftSV(2, vector); // $ExpectType number[]
numeric.lshiftVS(vector, 2); // $ExpectType number[]
numeric.lshifteq(vector, 3); // $ExpectType number[]
numeric.lshifteqV(vector, vector); // $ExpectType number[]
numeric.lshifteqS(vector, 3); // $ExpectType number[]
numeric.lshiftVV(vector, vector); // $ExpectType number[] || Vector
numeric.lshiftSV(2, vector); // $ExpectType number[] || Vector
numeric.lshiftVS(vector, 2); // $ExpectType number[] || Vector
numeric.lshifteq(vector, 3); // $ExpectType number[] || Vector
numeric.lshifteqV(vector, vector); // $ExpectType number[] || Vector
numeric.lshifteqS(vector, 3); // $ExpectType number[] || Vector
numeric.rshift(2, 5, 6); // $ExpectType number
numeric.rshift(2, 3, vector); // $ExpectType number[]
numeric.rshift(2, 3, vector); // $ExpectType number[] || Vector
numeric.rshift(threeDimensionalMatrix, 2, threeDimensionalMatrix); // $ExpectType number[][][]
numeric[">>"](2, 5, 6); // $ExpectType number
numeric[">>"](2, 3, vector); // $ExpectType number[]
numeric[">>"](2, 3, vector); // $ExpectType number[] || Vector
numeric[">>"](threeDimensionalMatrix, 2, 4); // $ExpectType number[][][]
numeric.rshiftVV(vector, vector); // $ExpectType number[]
numeric.rshiftSV(2, vector); // $ExpectType number[]
numeric.rshiftVS(vector, 2); // $ExpectType number[]
numeric.rshifteq(vector, 3); // $ExpectType number[]
numeric.rshifteqV(vector, vector); // $ExpectType number[]
numeric.rshifteqS(vector, 3); // $ExpectType number[]
numeric.rshiftVV(vector, vector); // $ExpectType number[] || Vector
numeric.rshiftSV(2, vector); // $ExpectType number[] || Vector
numeric.rshiftVS(vector, 2); // $ExpectType number[] || Vector
numeric.rshifteq(vector, 3); // $ExpectType number[] || Vector
numeric.rshifteqV(vector, vector); // $ExpectType number[] || Vector
numeric.rshifteqS(vector, 3); // $ExpectType number[] || Vector
numeric.rrshift(2, 5, 6); // $ExpectType number
numeric.rrshift(2, 3, vector); // $ExpectType number[]
numeric.rrshift(2, 3, vector); // $ExpectType number[] || Vector
numeric.rrshift(threeDimensionalMatrix, 2, threeDimensionalMatrix); // $ExpectType number[][][]
numeric[">>>"](2, 5, 6); // $ExpectType number
numeric[">>>"](2, 3, vector); // $ExpectType number[]
numeric[">>>"](2, 3, vector); // $ExpectType number[] || Vector
numeric[">>>"](threeDimensionalMatrix, 2, 4); // $ExpectType number[][][]
numeric.rrshiftVV(vector, vector); // $ExpectType number[]
numeric.rrshiftSV(2, vector); // $ExpectType number[]
numeric.rrshiftVS(vector, 2); // $ExpectType number[]
numeric.rrshifteq(vector, 3); // $ExpectType number[]
numeric.rrshifteqV(vector, vector); // $ExpectType number[]
numeric.rrshifteqS(vector, 3); // $ExpectType number[]
numeric.rrshiftVV(vector, vector); // $ExpectType number[] || Vector
numeric.rrshiftSV(2, vector); // $ExpectType number[] || Vector
numeric.rrshiftVS(vector, 2); // $ExpectType number[] || Vector
numeric.rrshifteq(vector, 3); // $ExpectType number[] || Vector
numeric.rrshifteqV(vector, vector); // $ExpectType number[] || Vector
numeric.rrshifteqS(vector, 3); // $ExpectType number[] || Vector
numeric.atan2(2, 5, 6); // $ExpectType number
numeric.atan2(2, 3, vector); // $ExpectType number[]
numeric.atan2(2, 3, vector); // $ExpectType number[] || Vector
numeric.atan2(threeDimensionalMatrix, 2, threeDimensionalMatrix); // $ExpectType number[][][]
numeric.atan2VV(vector, vector); // $ExpectType number[]
numeric.atan2SV(2, vector); // $ExpectType number[]
numeric.atan2VS(vector, 2); // $ExpectType number[]
numeric.atan2eq(vector, 3); // $ExpectType number[]
numeric.atan2eqV(vector, vector); // $ExpectType number[]
numeric.atan2eqS(vector, 3); // $ExpectType number[]
numeric.atan2VV(vector, vector); // $ExpectType number[] || Vector
numeric.atan2SV(2, vector); // $ExpectType number[] || Vector
numeric.atan2VS(vector, 2); // $ExpectType number[] || Vector
numeric.atan2eq(vector, 3); // $ExpectType number[] || Vector
numeric.atan2eqV(vector, vector); // $ExpectType number[] || Vector
numeric.atan2eqS(vector, 3); // $ExpectType number[] || Vector
numeric.pow(2, 5, 6); // $ExpectType number
numeric.pow(2, 3, vector); // $ExpectType number[]
numeric.pow(2, 3, vector); // $ExpectType number[] || Vector
numeric.pow(threeDimensionalMatrix, 2, threeDimensionalMatrix); // $ExpectType number[][][]
numeric.powVV(vector, vector); // $ExpectType number[]
numeric.powSV(2, vector); // $ExpectType number[]
numeric.powVS(vector, 2); // $ExpectType number[]
numeric.poweq(vector, 3); // $ExpectType number[]
numeric.poweqV(vector, vector); // $ExpectType number[]
numeric.poweqS(vector, 3); // $ExpectType number[]
numeric.powVV(vector, vector); // $ExpectType number[] || Vector
numeric.powSV(2, vector); // $ExpectType number[] || Vector
numeric.powVS(vector, 2); // $ExpectType number[] || Vector
numeric.poweq(vector, 3); // $ExpectType number[] || Vector
numeric.poweqV(vector, vector); // $ExpectType number[] || Vector
numeric.poweqS(vector, 3); // $ExpectType number[] || Vector
numeric.max(2, 5, 6); // $ExpectType number
numeric.max(2, 3, vector); // $ExpectType number[]
numeric.max(2, 3, vector); // $ExpectType number[] || Vector
numeric.max(threeDimensionalMatrix, 2, threeDimensionalMatrix); // $ExpectType number[][][]
numeric.maxVV(vector, vector); // $ExpectType number[]
numeric.maxSV(2, vector); // $ExpectType number[]
numeric.maxVS(vector, 2); // $ExpectType number[]
numeric.maxeq(vector, 3); // $ExpectType number[]
numeric.maxeqV(vector, vector); // $ExpectType number[]
numeric.maxeqS(vector, 3); // $ExpectType number[]
numeric.maxVV(vector, vector); // $ExpectType number[] || Vector
numeric.maxSV(2, vector); // $ExpectType number[] || Vector
numeric.maxVS(vector, 2); // $ExpectType number[] || Vector
numeric.maxeq(vector, 3); // $ExpectType number[] || Vector
numeric.maxeqV(vector, vector); // $ExpectType number[] || Vector
numeric.maxeqS(vector, 3); // $ExpectType number[] || Vector
numeric.min(2, 5, 6); // $ExpectType number
numeric.min(2, 3, vector); // $ExpectType number[]
numeric.min(2, 3, vector); // $ExpectType number[] || Vector
numeric.min(threeDimensionalMatrix, 2, threeDimensionalMatrix); // $ExpectType number[][][]
numeric.minVV(vector, vector); // $ExpectType number[]
numeric.minSV(2, vector); // $ExpectType number[]
numeric.minVS(vector, 2); // $ExpectType number[]
numeric.mineq(vector, 3); // $ExpectType number[]
numeric.mineqV(vector, vector); // $ExpectType number[]
numeric.mineqS(vector, 3); // $ExpectType number[]
numeric.minVV(vector, vector); // $ExpectType number[] || Vector
numeric.minSV(2, vector); // $ExpectType number[] || Vector
numeric.minVS(vector, 2); // $ExpectType number[] || Vector
numeric.mineq(vector, 3); // $ExpectType number[] || Vector
numeric.mineqV(vector, vector); // $ExpectType number[] || Vector
numeric.mineqS(vector, 3); // $ExpectType number[] || Vector
numeric.any(23); // $ExpectType boolean
numeric.anyV(vector); // $ExpectType boolean
@ -446,18 +446,18 @@ numeric.supV(vector); // $ExceptType number
numeric.inf(threeDimensionalMatrix); // $ExpectType number
numeric.infV(vector); // $ExceptType number
numeric.trunc(vector, 3); // $ExpectType number[]
numeric.truncVV(vector, vector); // $ExpectType number[]
numeric.truncVS(vector, 4); // $ExpectType number[]
numeric.truncSV(3, vector); // $ExpectType number[]
numeric.trunc(vector, 3); // $ExpectType number[] || Vector
numeric.truncVV(vector, vector); // $ExpectType number[] || Vector
numeric.truncVS(vector, 4); // $ExpectType number[] || Vector
numeric.truncSV(3, vector); // $ExpectType number[] || Vector
numeric.inv(matrix); // $ExpectType number[][]
numeric.inv(matrix); // $ExpectType number[][] || Matrix
numeric.det(matrix); // $ExpectType number
numeric.transpose(matrix); // $ExpectType number[][]
numeric.negtranspose(matrix); // $ExpectType number[][]
numeric.transpose(matrix); // $ExpectType number[][] || Matrix
numeric.negtranspose(matrix); // $ExpectType number[][] || Matrix
numeric.random(vector); // $ExpectType NonScalar
numeric.norm2(threeDimensionalMatrix); // $ExpectType number
numeric.linspace(1, 3, 5); // $ExpectType number[]
numeric.linspace(1, 3, 5); // $ExpectType number[] || Vector
numeric.getBlock(threeDimensionalMatrix, vector, vector); // $ExpectType number[][][]
const block: number[][][] = numeric.setBlock(
threeDimensionalMatrix,
@ -465,9 +465,9 @@ const block: number[][][] = numeric.setBlock(
vector,
threeDimensionalMatrix
);
numeric.blockMatrix(matrix); // $ExpectType number[][]
numeric.blockMatrix(matrix); // $ExpectType number[][] || Matrix
numeric.tensor(3, 5); // $ExpectType number
numeric.tensor(vector, vector); // $ExpectType number[][]
numeric.tensor(vector, vector); // $ExpectType number[][] || Matrix
const tensor = numeric.t(vector, vector);
tensor
@ -504,112 +504,112 @@ tensor
.ifft()
.eig();
numeric.house(vector); // $ExpectType number[]
numeric.toUpperHessenberg(matrix); // $ExpectType { H: number[][]; Q: number[][]; }
numeric.QRFrancis(matrix, 25); // $ExpectType { Q: number[][]; B: number[][]; }
numeric.house(vector); // $ExpectType number[] || Vector
numeric.toUpperHessenberg(matrix); // $ExpectType { H: number[][]; Q: number[][]; } || { H: Matrix; Q: Matrix; }
numeric.QRFrancis(matrix, 25); // $ExpectType { Q: number[][]; B: number[][]; } || { Q: Matrix; B: Matrix; }
numeric.eig(matrix); // $ExpectType { lambda: Tensor; E: Tensor; }
numeric.ccsSparse(matrix); // $ExpectType [number[], number[], number[]]
numeric.ccsFull(sparseMatrix); // $ExpectType number[][]
numeric.ccsTSolve(sparseMatrix, vector, vector, vector, vector); // $ExpectType number[]
numeric.ccsDot(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccsSparse(matrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccsFull(sparseMatrix); // $ExpectType number[][] || Matrix
numeric.ccsTSolve(sparseMatrix, vector, vector, vector, vector); // $ExpectType number[] || Vector
numeric.ccsDot(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
const lup = numeric.ccsLUP(sparseMatrix, 4);
numeric.ccsDim(sparseMatrix); // $ExpectType number[]
numeric.ccsGetBlock(sparseMatrix, vector, 3); // $ExpectType [number[], number[], number[]]
numeric.ccsLUPSolve(lup, sparseMatrix); // $ExpectType number[]
numeric.ccsScatter(sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccsGather(sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccsDim(sparseMatrix); // $ExpectType number[] || Vector
numeric.ccsGetBlock(sparseMatrix, vector, 3); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccsLUPSolve(lup, sparseMatrix); // $ExpectType number[] || Vector
numeric.ccsScatter(sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccsGather(sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccsadd(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccsadd(2, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccsaddMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccsadd(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccsadd(2, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccsaddMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccssub(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccssub(2, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccssubMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccssub(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccssub(2, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccssubMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccsmul(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccsmul(2, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccsmulMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccsmul(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccsmul(2, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccsmulMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccsdiv(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccsdiv(2, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccsdivMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccsdiv(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccsdiv(2, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccsdivMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccsmod(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccsmod(2, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccsmodMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccsmod(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccsmod(2, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccsmodMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccsand(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccsand(2, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccsandMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccsand(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccsand(2, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccsandMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccsor(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccsor(2, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccsorMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccsor(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccsor(2, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccsorMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccseq(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], boolean[]]
numeric.ccseq(2, sparseMatrix); // $ExpectType [number[], number[], boolean[]]
numeric.ccseqMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], boolean[]]
numeric.ccseq(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], boolean[]] || CCSComparisonResult
numeric.ccseq(2, sparseMatrix); // $ExpectType [number[], number[], boolean[]] || CCSComparisonResult
numeric.ccseqMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], boolean[]] || CCSComparisonResult
numeric.ccsneq(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], boolean[]]
numeric.ccsneq(2, sparseMatrix); // $ExpectType [number[], number[], boolean[]]
numeric.ccsneqMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], boolean[]]
numeric.ccsneq(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], boolean[]] || CCSComparisonResult
numeric.ccsneq(2, sparseMatrix); // $ExpectType [number[], number[], boolean[]] || CCSComparisonResult
numeric.ccsneqMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], boolean[]] || CCSComparisonResult
numeric.ccslt(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], boolean[]]
numeric.ccslt(2, sparseMatrix); // $ExpectType [number[], number[], boolean[]]
numeric.ccsltMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], boolean[]]
numeric.ccslt(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], boolean[]] || CCSComparisonResult
numeric.ccslt(2, sparseMatrix); // $ExpectType [number[], number[], boolean[]] || CCSComparisonResult
numeric.ccsltMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], boolean[]] || CCSComparisonResult
numeric.ccsgt(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], boolean[]]
numeric.ccsgt(2, sparseMatrix); // $ExpectType [number[], number[], boolean[]]
numeric.ccsgtMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], boolean[]]
numeric.ccsgt(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], boolean[]] || CCSComparisonResult
numeric.ccsgt(2, sparseMatrix); // $ExpectType [number[], number[], boolean[]] || CCSComparisonResult
numeric.ccsgtMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], boolean[]] || CCSComparisonResult
numeric.ccsleq(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], boolean[]]
numeric.ccsleq(2, sparseMatrix); // $ExpectType [number[], number[], boolean[]]
numeric.ccsleqMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], boolean[]]
numeric.ccsleq(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], boolean[]] || CCSComparisonResult
numeric.ccsleq(2, sparseMatrix); // $ExpectType [number[], number[], boolean[]] || CCSComparisonResult
numeric.ccsleqMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], boolean[]] || CCSComparisonResult
numeric.ccsgeq(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], boolean[]]
numeric.ccsgeq(2, sparseMatrix); // $ExpectType [number[], number[], boolean[]]
numeric.ccsgeqMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], boolean[]]
numeric.ccsgeq(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], boolean[]] || CCSComparisonResult
numeric.ccsgeq(2, sparseMatrix); // $ExpectType [number[], number[], boolean[]] || CCSComparisonResult
numeric.ccsgeqMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], boolean[]] || CCSComparisonResult
numeric.ccsband(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccsband(2, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccsbandMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccsband(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccsband(2, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccsbandMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccsbor(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccsbor(2, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccsborMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccsbor(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccsbor(2, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccsborMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccsbxor(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccsbxor(2, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccsbxorMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccsbxor(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccsbxor(2, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccsbxorMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccslshift(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccslshift(2, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccslshiftMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccslshift(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccslshift(2, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccslshiftMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccsrshift(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccsrshift(2, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccsrshiftMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccsrshift(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccsrshift(2, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccsrshiftMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccsrrshift(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccsrrshift(2, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccsrrshiftMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]]
numeric.ccsrrshift(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccsrrshift(2, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
numeric.ccsrrshiftMM(sparseMatrix, sparseMatrix); // $ExpectType [number[], number[], number[]] || SparseMatrix
const lu = numeric.cLU(matrix);
numeric.cLUSolve(lu, vector); // $ExpectType number[]
numeric.cgrid(2, "L"); // $ExpectType number[][]
numeric.cdelsq(matrix); // $ExpectType number[][]
numeric.cdotmv(matrix, vector); // $ExpectType number[]
numeric.cLUSolve(lu, vector); // $ExpectType number[] || Vector
numeric.cgrid(2, "L"); // $ExpectType number[][] || Matrix
numeric.cdelsq(matrix); // $ExpectType number[][] || Matrix
numeric.cdotmv(matrix, vector); // $ExpectType number[] || Vector
const spline = numeric.spline(vector, matrix, "periodic", 3);
spline.diff().roots(); // $ExpectType number[]
spline.at(vector); // $ExpectType number | number[]
spline.diff().roots(); // $ExpectType number[] || Vector
spline.at(vector); // $ExpectType number | number[] || number | Vector
numeric.uncmin((x: number[]) => 23, vector, 2, null, 3, () => undefined, {
Hinv: matrix
});
numeric.gradient((x: number[]) => 44, vector); // $ExpectType number[]
numeric.gradient((x: number[]) => 44, vector); // $ExpectType number[] || Vector
const dopri = numeric.dopri(
1,
@ -620,11 +620,13 @@ const dopri = numeric.dopri(
3,
(x = 23, y = 44) => 44
);
dopri.at(vector); // $ExpectType number[] | number[][]
dopri.at(vector); // $ExpectType number[] | number[][] || Vector | Matrix
numeric.echelonize(matrix); // $ExpectType { I: number[][]; A: number[][]; P: number[]; }
numeric.solveLP(vector, matrix, vector, matrix, matrix, 3, 4); // $ExpectType { solution: number | number[]; message: string; iterations: number; }
numeric.echelonize(matrix); // $ExpectType { I: number[][]; A: number[][]; P: number[]; } || { I: Matrix; A: Matrix; P: Vector; }
const temp1: { solution: number | number[]; message: string; iterations: number; } =
numeric.solveLP(vector, matrix, vector, matrix, matrix, 3, 4);
numeric.solveQP(matrix, vector, matrix, vector, 3, 44); // $ExpectType { solution: number[]; value: number[]; unconstrained_solution: number[]; iterations: number[]; iact: number[]; message: string; }
const temp2: { solution: number[]; value: number[]; unconstrained_solution: number[]; iterations: number[]; iact: number[]; message: string; } =
numeric.solveQP(matrix, vector, matrix, vector, 3, 44);
numeric.svd(matrix); // $ExpectType { U: number[][]; S: number[]; V: number[][]; }
numeric.svd(matrix); // $ExpectType { U: number[][]; S: number[]; V: number[][]; } || { U: Matrix; S: Vector; V: Matrix; }

12
types/onionoo/onionoo-tests.ts
View File

@ -11,7 +11,7 @@ const query = {
};
onionoo.summary(query).then(response => {
response.body; // $ExpectType Response<RelaySummary, BridgeSummary>
response.body; // $ExpectType Response<RelaySummary, BridgeSummary> || Summary
const body = response.body;
@ -21,11 +21,11 @@ onionoo.summary(query).then(response => {
body.bridges_published; // $ExpectType string
body.bridges; // $ExpectType BridgeSummary[]
});
onionoo.details(query); // $ExpectType GotPromise<Response<Relay, Bridge>>
onionoo.bandwidth(query); // $ExpectType GotPromise<Response<NodeBandwidth, NodeBandwidth>>
onionoo.weights(query); // $ExpectType GotPromise<Response<RelayWeights, undefined>>
onionoo.clients(query); // $ExpectType GotPromise<Response<undefined, BridgeClients>>
onionoo.uptime(query); // $ExpectType GotPromise<Response<RelayUptime, BridgeUptime>>
onionoo.details(query); // $ExpectType GotPromise<Response<Relay, Bridge>> || GotPromise<Details>
onionoo.bandwidth(query); // $ExpectType GotPromise<Response<NodeBandwidth, NodeBandwidth>> || GotPromise<Bandwidth>
onionoo.weights(query); // $ExpectType GotPromise<Response<RelayWeights, undefined>> || GotPromise<Weights>
onionoo.clients(query); // $ExpectType GotPromise<Response<undefined, BridgeClients>> || GotPromise<Clients>
onionoo.uptime(query); // $ExpectType GotPromise<Response<RelayUptime, BridgeUptime>> || GotPromise<Uptime>
// $ExpectType Instance & Partial<Endpoints>
new Onionoo({

2
types/react-dev-utils/test/webpack-utils.ts
View File

@ -41,7 +41,7 @@ const urls = WebpackDevServerUtils.prepareUrls('http', 'localhost', 3000);
// $ExpectType Compiler
WebpackDevServerUtils.createCompiler({ webpack, config: {}, appName: 'app', urls, useYarn: true });
// $ExpectType ProxyConfigArrayItem[]
// $ExpectType ProxyConfigArrayItem[] || ProxyConfigArray
WebpackDevServerUtils.prepareProxy(undefined, 'build');
const loaderContext: webpack.loader.LoaderContext = null!;

46
types/react-share/react-share-tests.ts
View File

@ -1,26 +1,26 @@
import {
FacebookShareCount, // $ExpectType FunctionComponent<ShareCountComponentProps>
GooglePlusShareCount, // $ExpectType FunctionComponent<ShareCountComponentProps>
LinkedinShareCount, // $ExpectType FunctionComponent<ShareCountComponentProps>
PinterestShareCount, // $ExpectType FunctionComponent<ShareCountComponentProps>
VKShareCount, // $ExpectType FunctionComponent<ShareCountComponentProps>
OKShareCount, // $ExpectType FunctionComponent<ShareCountComponentProps>
RedditShareCount, // $ExpectType FunctionComponent<ShareCountComponentProps>
TumblrShareCount, // $ExpectType FunctionComponent<ShareCountComponentProps>
FacebookShareCount, // $ExpectType FunctionComponent<ShareCountComponentProps> || StatelessComponent<ShareCountComponentProps>
GooglePlusShareCount, // $ExpectType FunctionComponent<ShareCountComponentProps> || StatelessComponent<ShareCountComponentProps>
LinkedinShareCount, // $ExpectType FunctionComponent<ShareCountComponentProps> || StatelessComponent<ShareCountComponentProps>
PinterestShareCount, // $ExpectType FunctionComponent<ShareCountComponentProps> || StatelessComponent<ShareCountComponentProps>
VKShareCount, // $ExpectType FunctionComponent<ShareCountComponentProps> || StatelessComponent<ShareCountComponentProps>
OKShareCount, // $ExpectType FunctionComponent<ShareCountComponentProps> || StatelessComponent<ShareCountComponentProps>
RedditShareCount, // $ExpectType FunctionComponent<ShareCountComponentProps> || StatelessComponent<ShareCountComponentProps>
TumblrShareCount, // $ExpectType FunctionComponent<ShareCountComponentProps> || StatelessComponent<ShareCountComponentProps>
FacebookIcon, // $ExpectType FunctionComponent<IconComponentProps>
TwitterIcon, // $ExpectType FunctionComponent<IconComponentProps>
TelegramIcon, // $ExpectType FunctionComponent<IconComponentProps>
WhatsappIcon, // $ExpectType FunctionComponent<IconComponentProps>
GooglePlusIcon, // $ExpectType FunctionComponent<IconComponentProps>
LinkedinIcon, // $ExpectType FunctionComponent<IconComponentProps>
PinterestIcon, // $ExpectType FunctionComponent<IconComponentProps>
VKIcon, // $ExpectType FunctionComponent<IconComponentProps>
OKIcon, // $ExpectType FunctionComponent<IconComponentProps>
RedditIcon, // $ExpectType FunctionComponent<IconComponentProps>
TumblrIcon, // $ExpectType FunctionComponent<IconComponentProps>
LivejournalIcon, // $ExpectType FunctionComponent<IconComponentProps>
MailruIcon, // $ExpectType FunctionComponent<IconComponentProps>
EmailIcon, // $ExpectType FunctionComponent<IconComponentProps>
LineIcon, // $ExpectType FunctionComponent<IconComponentProps>
FacebookIcon, // $ExpectType FunctionComponent<IconComponentProps> || StatelessComponent<IconComponentProps>
TwitterIcon, // $ExpectType FunctionComponent<IconComponentProps> || StatelessComponent<IconComponentProps>
TelegramIcon, // $ExpectType FunctionComponent<IconComponentProps> || StatelessComponent<IconComponentProps>
WhatsappIcon, // $ExpectType FunctionComponent<IconComponentProps> || StatelessComponent<IconComponentProps>
GooglePlusIcon, // $ExpectType FunctionComponent<IconComponentProps> || StatelessComponent<IconComponentProps>
LinkedinIcon, // $ExpectType FunctionComponent<IconComponentProps> || StatelessComponent<IconComponentProps>
PinterestIcon, // $ExpectType FunctionComponent<IconComponentProps> || StatelessComponent<IconComponentProps>
VKIcon, // $ExpectType FunctionComponent<IconComponentProps> || StatelessComponent<IconComponentProps>
OKIcon, // $ExpectType FunctionComponent<IconComponentProps> || StatelessComponent<IconComponentProps>
RedditIcon, // $ExpectType FunctionComponent<IconComponentProps> || StatelessComponent<IconComponentProps>
TumblrIcon, // $ExpectType FunctionComponent<IconComponentProps> || StatelessComponent<IconComponentProps>
LivejournalIcon, // $ExpectType FunctionComponent<IconComponentProps> || StatelessComponent<IconComponentProps>
MailruIcon, // $ExpectType FunctionComponent<IconComponentProps> || StatelessComponent<IconComponentProps>
EmailIcon, // $ExpectType FunctionComponent<IconComponentProps> || StatelessComponent<IconComponentProps>
LineIcon, // $ExpectType FunctionComponent<IconComponentProps> || StatelessComponent<IconComponentProps>
} from 'react-share';

8
types/redux-orm/redux-orm-tests.ts
View File

@ -261,10 +261,10 @@ const sessionFixture = () => {
(() => {
type ExtractId<M extends Model> = [IdKey<M>, IdType<M>];
type ImplicitDefault = ExtractId<Authorship>; // $ExpectType ["id", number]
type CustomKey = ExtractId<Publisher>; // $ExpectType ["index", number]
type CustomType = ExtractId<Person>; // $ExpectType ["id", string]
type CustomKeyAndType = ExtractId<Book>; // $ExpectType ["title", string]
type ImplicitDefault = ExtractId<Authorship>; // $ExpectType ["id", number] || ExtractId<Authorship>
type CustomKey = ExtractId<Publisher>; // $ExpectType ["index", number] || ExtractId<Publisher>
type CustomType = ExtractId<Person>; // $ExpectType ["id", string] || ExtractId<Person>
type CustomKeyAndType = ExtractId<Book>; // $ExpectType ["title", string] || ExtractId<Book>
})();
// Model#create result retains custom properties supplied during call

26
types/schema-registry/schema-registry-tests.ts
View File

@ -8,7 +8,7 @@ const livingAvroSchema = new LivingAvroSchema("subject", "version", {
host: "host", port: 2,
});
// $ExpectType Promise<AvroSchemaResponseInterface>
// $ExpectType Promise<AvroSchemaResponseInterface> || RegistryRequest
registryClient.request({}, 2);
// $ExpectError
registryClient.request();
@ -21,48 +21,48 @@ registryClient.request({}, 'a');
// $ExpectError
registryClient.request({}, {});
// $ExpectType Promise<AvroSchemaResponseInterface>
// $ExpectType Promise<AvroSchemaResponseInterface> || RegistryRequest
registryClient.isAlive();
// $ExpectType Promise<AvroSchemaResponseInterface>
// $ExpectType Promise<AvroSchemaResponseInterface> || RegistryRequest
registryClient.registerSubjectVersion("string", {});
// $ExpectError
registryClient.registerSubjectVersion();
// $ExpectError
registryClient.registerSubjectVersion("string");
// $ExpectType Promise<AvroSchemaResponseInterface>
// $ExpectType Promise<AvroSchemaResponseInterface> || RegistryRequest
registryClient.getVersionsForSubject("string");
// $ExpectError
registryClient.getVersionsForSubject();
// $ExpectError
registryClient.getVersionsForSubject({});
// $ExpectType Promise<AvroSchemaResponseInterface>
// $ExpectType Promise<AvroSchemaResponseInterface> || RegistryRequest
registryClient.getConfig();
// $ExpectType Promise<AvroSchemaResponseInterface>
// $ExpectType Promise<AvroSchemaResponseInterface> || RegistryRequest
registryClient.setConfig({});
// $ExpectError
registryClient.setConfig();
// $ExpectError
registryClient.setConfig("string");
// $ExpectType Promise<AvroSchemaResponseInterface>
// $ExpectType Promise<AvroSchemaResponseInterface> || RegistryRequest
registryClient.setSubjectConfig("string", {});
// $ExpectError
registryClient.setSubjectConfig();
// $ExpectError
registryClient.setSubjectConfig("string");
// $ExpectType Promise<AvroSchemaResponseInterface>
// $ExpectType Promise<AvroSchemaResponseInterface> || RegistryRequest
registryClient.getSubjectConfig("string");
// $ExpectError
registryClient.getSubjectConfig();
// $ExpectError
registryClient.getSubjectConfig({});
// $ExpectType Promise<AvroSchemaResponseInterface>
// $ExpectType Promise<AvroSchemaResponseInterface> || RegistryRequest
registryClient.getSchemaById(2);
// $ExpectError
registryClient.getSchemaById();
@ -71,10 +71,10 @@ registryClient.getSchemaById('a');
// $ExpectError
registryClient.getSchemaById({});
// $ExpectType Promise<AvroSchemaResponseInterface>
// $ExpectType Promise<AvroSchemaResponseInterface> || RegistryRequest
registryClient.getSubjects();
// $ExpectType Promise<AvroSchemaResponseInterface>
// $ExpectType Promise<AvroSchemaResponseInterface> || RegistryRequest
registryClient.getSubjectSchemaForVersion("string", 2);
// $ExpectError
registryClient.getSubjectSchemaForVersion("string", {});
@ -83,7 +83,7 @@ registryClient.getSubjectSchemaForVersion("string");
// $ExpectError
registryClient.getSubjectSchemaForVersion({});
// $ExpectType Promise<AvroSchemaResponseInterface>
// $ExpectType Promise<AvroSchemaResponseInterface> || RegistryRequest
registryClient.getLatestSubjectSchema("string");
// $ExpectError
registryClient.getLatestSubjectSchema({});
@ -92,7 +92,7 @@ registryClient.getLatestSubjectSchema(2);
// $ExpectError
registryClient.getLatestSubjectSchema();
// $ExpectType Promise<AvroSchemaResponseInterface>
// $ExpectType Promise<AvroSchemaResponseInterface> || RegistryRequest
registryClient.checkSubjectRegistration("string", {});
// $ExpectError
registryClient.checkSubjectRegistration("string");

4
types/test-console/test-console-tests.ts
View File

@ -9,7 +9,7 @@ stdout.inspect({isTTY: true});
stdout.inspectSync();
// $ExpectError
stdout.inspectSync({});
// $ExpectType ReadonlyArray<string>
// $ExpectType ReadonlyArray<string> || Output
stdout.inspectSync({isTTY: false}, (output) => output);
// $ExpectType Restore
@ -35,7 +35,7 @@ stderr.inspect({isTTY: true});
stderr.inspectSync();
// $ExpectError
stderr.inspectSync({});
// $ExpectType ReadonlyArray<string>
// $ExpectType ReadonlyArray<string> || Output
stderr.inspectSync({isTTY: false}, (output) => output);
// $ExpectType Restore

4
types/yargs/v12/yargs-tests.ts
View File

@ -987,10 +987,10 @@ function Argv$inferArrayOptionTypes() {
// $ExpectType string[] | undefined
yargs.option("a", { normalize: true, type: "array" }).argv.a;
// $ExpectType string[] | undefined
// $ExpectType string[] | undefined || ToArray<string | undefined>
yargs.string("a").array("a").argv.a;
// $ExpectType string[] | undefined
// $ExpectType string[] | undefined || ToString<(string | number)[] | undefined>
yargs.array("a").string("a").argv.a;
// $ExpectType string[]

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

@ -1069,10 +1069,10 @@ function Argv$inferArrayOptionTypes() {
// $ExpectType string[] | undefined
yargs.option("a", { normalize: true, type: "array" }).argv.a;
// $ExpectType string[] | undefined
// $ExpectType string[] | undefined || ToArray<string | undefined>
yargs.string("a").array("a").argv.a;
// $ExpectType string[] | undefined
// $ExpectType string[] | undefined || ToString<(string | number)[] | undefined>
yargs.array("a").string("a").argv.a;
// $ExpectType string[]