diff --git a/src/jsutils/devAssert.d.ts b/src/jsutils/devAssert.d.ts
new file mode 100644
index 0000000000..451b6ef3e0
--- /dev/null
+++ b/src/jsutils/devAssert.d.ts
@@ -0,0 +1 @@
+export function devAssert(condition: unknown, message: string): void;
diff --git a/src/jsutils/didYouMean.d.ts b/src/jsutils/didYouMean.d.ts
new file mode 100644
index 0000000000..a4b8a5bb7d
--- /dev/null
+++ b/src/jsutils/didYouMean.d.ts
@@ -0,0 +1,8 @@
+/**
+ * Given [ A, B, C ] return ' Did you mean A, B, or C?'.
+ */
+export function didYouMean(suggestions: ReadonlyArray<string>): string;
+export function didYouMean(
+  subMessage: string,
+  suggestions: ReadonlyArray<string>,
+): string;
diff --git a/src/jsutils/identityFunc.d.ts b/src/jsutils/identityFunc.d.ts
new file mode 100644
index 0000000000..55854eb493
--- /dev/null
+++ b/src/jsutils/identityFunc.d.ts
@@ -0,0 +1,4 @@
+/**
+ * Returns the first argument it receives.
+ */
+export function identityFunc<T>(x: T): T;
diff --git a/src/jsutils/inspect.d.ts b/src/jsutils/inspect.d.ts
new file mode 100644
index 0000000000..29c96a1542
--- /dev/null
+++ b/src/jsutils/inspect.d.ts
@@ -0,0 +1,4 @@
+/**
+ * Used to print values in error messages.
+ */
+export function inspect(value: unknown): string;
diff --git a/src/jsutils/instanceOf.d.ts b/src/jsutils/instanceOf.d.ts
new file mode 100644
index 0000000000..f95e88ff59
--- /dev/null
+++ b/src/jsutils/instanceOf.d.ts
@@ -0,0 +1 @@
+export const instanceOf: (value: unknown, constructor: unknown) => boolean;
diff --git a/src/jsutils/invariant.d.ts b/src/jsutils/invariant.d.ts
new file mode 100644
index 0000000000..f6ab910bd4
--- /dev/null
+++ b/src/jsutils/invariant.d.ts
@@ -0,0 +1,4 @@
+export function invariant(
+  condition: unknown,
+  message?: string,
+): asserts condition;
diff --git a/src/jsutils/isAsyncIterable.d.ts b/src/jsutils/isAsyncIterable.d.ts
new file mode 100644
index 0000000000..c9995aa867
--- /dev/null
+++ b/src/jsutils/isAsyncIterable.d.ts
@@ -0,0 +1,7 @@
+/**
+ * Returns true if the provided object implements the AsyncIterator protocol via
+ * either implementing a `Symbol.asyncIterator` or `"@@asyncIterator"` method.
+ */
+export function isAsyncIterable(
+  maybeAsyncIterable: unknown,
+): maybeAsyncIterable is AsyncIterable<unknown>;
diff --git a/src/jsutils/isIteratableObject.d.ts b/src/jsutils/isIteratableObject.d.ts
new file mode 100644
index 0000000000..92125e218b
--- /dev/null
+++ b/src/jsutils/isIteratableObject.d.ts
@@ -0,0 +1,19 @@
+/**
+ * Returns true if the provided object is an Object (i.e. not a string literal)
+ * and implements the Iterator protocol.
+ *
+ * This may be used in place of [Array.isArray()][isArray] to determine if
+ * an object should be iterated-over e.g. Array, Map, Set, Int8Array,
+ * TypedArray, etc. but excludes string literals.
+ *
+ * @example
+ *
+ * isIteratableObject([ 1, 2, 3 ]) // true
+ * isIteratableObject(new Map()) // true
+ * isIteratableObject('ABC') // false
+ * isIteratableObject({ key: 'value' }) // false
+ * isIteratableObject({ length: 1, 0: 'Alpha' }) // false
+ */
+export function isIteratableObject(
+  maybeIteratable: unknown,
+): maybeIteratable is Iterable<unknown>;
diff --git a/src/jsutils/isObjectLike.d.ts b/src/jsutils/isObjectLike.d.ts
new file mode 100644
index 0000000000..54c36fe228
--- /dev/null
+++ b/src/jsutils/isObjectLike.d.ts
@@ -0,0 +1,5 @@
+/**
+ * Return true if `value` is object-like. A value is object-like if it's not
+ * `null` and has a `typeof` result of "object".
+ */
+export function isObjectLike(value: unknown): value is Record<string, unknown>;
diff --git a/src/jsutils/isPromise.d.ts b/src/jsutils/isPromise.d.ts
new file mode 100644
index 0000000000..884f39afb1
--- /dev/null
+++ b/src/jsutils/isPromise.d.ts
@@ -0,0 +1,5 @@
+/**
+ * Returns true if the value acts like a Promise, i.e. has a "then" function,
+ * otherwise returns false.
+ */
+export function isPromise(value: unknown): value is Promise<unknown>;
diff --git a/src/jsutils/keyMap.d.ts b/src/jsutils/keyMap.d.ts
new file mode 100644
index 0000000000..60faa82e71
--- /dev/null
+++ b/src/jsutils/keyMap.d.ts
@@ -0,0 +1,28 @@
+import type { ObjMap } from './ObjMap';
+/**
+ * Creates a keyed JS object from an array, given a function to produce the keys
+ * for each value in the array.
+ *
+ * This provides a convenient lookup for the array items if the key function
+ * produces unique results.
+ *
+ *     const phoneBook = [
+ *       { name: 'Jon', num: '555-1234' },
+ *       { name: 'Jenny', num: '867-5309' }
+ *     ]
+ *
+ *     // { Jon: { name: 'Jon', num: '555-1234' },
+ *     //   Jenny: { name: 'Jenny', num: '867-5309' } }
+ *     const entriesByName = keyMap(
+ *       phoneBook,
+ *       entry => entry.name
+ *     )
+ *
+ *     // { name: 'Jenny', num: '857-6309' }
+ *     const jennyEntry = entriesByName['Jenny']
+ *
+ */
+export function keyMap<T>(
+  list: ReadonlyArray<T>,
+  keyFn: (item: T) => string,
+): ObjMap<T>;
diff --git a/src/jsutils/keyValMap.d.ts b/src/jsutils/keyValMap.d.ts
new file mode 100644
index 0000000000..634d099be1
--- /dev/null
+++ b/src/jsutils/keyValMap.d.ts
@@ -0,0 +1,23 @@
+import type { ObjMap } from './ObjMap';
+/**
+ * Creates a keyed JS object from an array, given a function to produce the keys
+ * and a function to produce the values from each item in the array.
+ *
+ *     const phoneBook = [
+ *       { name: 'Jon', num: '555-1234' },
+ *       { name: 'Jenny', num: '867-5309' }
+ *     ]
+ *
+ *     // { Jon: '555-1234', Jenny: '867-5309' }
+ *     const phonesByName = keyValMap(
+ *       phoneBook,
+ *       entry => entry.name,
+ *       entry => entry.num
+ *     )
+ *
+ */
+export function keyValMap<T, V>(
+  list: ReadonlyArray<T>,
+  keyFn: (item: T) => string,
+  valFn: (item: T) => V,
+): ObjMap<V>;
diff --git a/src/jsutils/mapValue.d.ts b/src/jsutils/mapValue.d.ts
new file mode 100644
index 0000000000..b82ffedce9
--- /dev/null
+++ b/src/jsutils/mapValue.d.ts
@@ -0,0 +1,9 @@
+import type { ObjMap } from './ObjMap';
+/**
+ * Creates an object map with the same keys as `map` and values generated by
+ * running each value of `map` thru `fn`.
+ */
+export function mapValue<T, V>(
+  map: ObjMap<T>,
+  fn: (value: T, key: string) => V,
+): ObjMap<V>;
diff --git a/src/jsutils/memoize3.d.ts b/src/jsutils/memoize3.d.ts
new file mode 100644
index 0000000000..e3752c6311
--- /dev/null
+++ b/src/jsutils/memoize3.d.ts
@@ -0,0 +1,10 @@
+/* eslint-disable @typescript-eslint/ban-types */
+/**
+ * Memoizes the provided three-argument function.
+ */
+export function memoize3<
+  A1 extends object,
+  A2 extends object,
+  A3 extends object,
+  R
+>(fn: (a1: A1, a2: A2, a3: A3) => R): (a1: A1, a2: A2, a3: A3) => R;
diff --git a/src/jsutils/naturalCompare.d.ts b/src/jsutils/naturalCompare.d.ts
new file mode 100644
index 0000000000..a5fe31be1e
--- /dev/null
+++ b/src/jsutils/naturalCompare.d.ts
@@ -0,0 +1,8 @@
+/**
+ * Returns a number indicating whether a reference string comes before, or after,
+ * or is the same as the given string in natural sort order.
+ *
+ * See: https://en.wikipedia.org/wiki/Natural_sort_order
+ *
+ */
+export function naturalCompare(aStr: string, bStr: string): number;
diff --git a/src/jsutils/printPathArray.d.ts b/src/jsutils/printPathArray.d.ts
new file mode 100644
index 0000000000..69bc1606e1
--- /dev/null
+++ b/src/jsutils/printPathArray.d.ts
@@ -0,0 +1,4 @@
+/**
+ * Build a string describing the path.
+ */
+export function printPathArray(path: ReadonlyArray<string | number>): string;
diff --git a/src/jsutils/promiseForObject.d.ts b/src/jsutils/promiseForObject.d.ts
new file mode 100644
index 0000000000..4f67802622
--- /dev/null
+++ b/src/jsutils/promiseForObject.d.ts
@@ -0,0 +1,11 @@
+import type { ObjMap } from './ObjMap';
+/**
+ * This function transforms a JS object `ObjMap<Promise<T>>` into
+ * a `Promise<ObjMap<T>>`
+ *
+ * This is akin to bluebird's `Promise.props`, but implemented only using
+ * `Promise.all` so it will work with any implementation of ES6 promises.
+ */
+export function promiseForObject<T>(
+  object: ObjMap<Promise<T>>,
+): Promise<ObjMap<T>>;
diff --git a/src/jsutils/promiseReduce.d.ts b/src/jsutils/promiseReduce.d.ts
new file mode 100644
index 0000000000..6f4865f4d0
--- /dev/null
+++ b/src/jsutils/promiseReduce.d.ts
@@ -0,0 +1,13 @@
+import type { PromiseOrValue } from './PromiseOrValue';
+/**
+ * Similar to Array.prototype.reduce(), however the reducing callback may return
+ * a Promise, in which case reduction will continue after each promise resolves.
+ *
+ * If the callback does not return a Promise, then this function will also not
+ * return a Promise.
+ */
+export function promiseReduce<T, U>(
+  values: ReadonlyArray<T>,
+  callback: (U: any, T: any) => PromiseOrValue<U>,
+  initialValue: PromiseOrValue<U>,
+): PromiseOrValue<U>;
diff --git a/src/jsutils/suggestionList.d.ts b/src/jsutils/suggestionList.d.ts
new file mode 100644
index 0000000000..6b255c244f
--- /dev/null
+++ b/src/jsutils/suggestionList.d.ts
@@ -0,0 +1,8 @@
+/**
+ * Given an invalid input string and a list of valid options, returns a filtered
+ * list of valid options sorted based on their similarity with the input.
+ */
+export function suggestionList(
+  input: string,
+  options: ReadonlyArray<string>,
+): Array<string>;
diff --git a/src/jsutils/toObjMap.d.ts b/src/jsutils/toObjMap.d.ts
new file mode 100644
index 0000000000..3d2c00f4aa
--- /dev/null
+++ b/src/jsutils/toObjMap.d.ts
@@ -0,0 +1,9 @@
+import type {
+  ObjMap,
+  ObjMapLike,
+  ReadOnlyObjMap,
+  ReadOnlyObjMapLike,
+} from './ObjMap';
+
+export function toObjMap<T>(obj: ObjMapLike<T>): ObjMap<T>;
+export function toObjMap<T>(obj: ReadOnlyObjMapLike<T>): ReadOnlyObjMap<T>;