feat: Add Type#isUnknown()

docs/details/types.md

@@ -217,6 +217,7 @@ type.isTuple();
 type.isUnion();
 type.isIntersection();
 type.isUnionOrIntersection();
+type.isUnknown();
 type.isNull();
 type.isUndefined();
 ```

lib/ts-morph.d.ts

@@ -1842,7 +1842,7 @@ export declare class WriterFunctions {
      * Gets a writer function for writing the provided object as an object literal expression.
      * @param obj - Object to write.
      */
-    object(obj: {
+    static object(obj: {
         [key: string]: WriterFunctionOrValue | undefined;
     }): WriterFunction;
     /** Gets a writer function for writing an object type. */
@@ -9855,6 +9855,10 @@ export declare class Type<TType extends ts.Type = ts.Type> {
      * Gets if this is a union or intersection type.
      */
     isUnionOrIntersection(): boolean;
+    /**
+     * Gets if this is the unknown type.
+     */
+    isUnknown(): boolean;
     /**
      * Gets if this is the null type.
      */

src/compiler/types/Type.ts

@@ -424,6 +424,13 @@ export class Type<TType extends ts.Type = ts.Type> {
         return this.compilerType.isUnionOrIntersection();
     }
 
+    /**
+     * Gets if this is the unknown type.
+     */
+    isUnknown() {
+        return this._hasTypeFlag(TypeFlags.Unknown);
+    }
+
     /**
      * Gets if this is the null type.
      */

src/tests/compiler/type/typeTests.ts

@@ -56,6 +56,7 @@ let emptyObjectType: { };
 let stringWithUndefinedType: string | undefined;
 let stringWithNullType: string | null;
 let stringWithUndefinedAndNullType: string | undefined | null;
+let unknownType: unknown;
 `;
         const { sourceFile } = getInfoFromTextWithTypeChecking(text);
         const typesByName: { [name: string]: Type; } = {};
@@ -415,6 +416,20 @@ let stringWithUndefinedAndNullType: string | undefined | null;
             });
         });
 
+        describe(nameof<Type>(t => t.isUnknown), () => {
+            function doTest(typeName: string, expected: boolean) {
+                expect(typesByName[typeName].isUnknown()).to.equal(expected);
+            }
+
+            it("should get when it is", () => {
+                doTest("unknownType", true);
+            });
+
+            it("should get when it's not", () => {
+                doTest("anyType", false);
+            });
+        });
+
         describe(nameof<Type>(t => t.getFlags), () => {
             it("should get the type flags", () => {
                 expect(typesByName["numberType"].getFlags()).to.equal(TypeFlags.Number);