diff --git a/types/clownface/clownface-tests.ts b/types/clownface/clownface-tests.ts
index 82882d50ae..e74f780833 100644
--- a/types/clownface/clownface-tests.ts
+++ b/types/clownface/clownface-tests.ts
@@ -144,17 +144,32 @@ if (cf.value) {
 // .values
 const values: string[] = cf.values;
 
-const safeCf: clownface.SafeClownface = <any> {};
+const safeCf: clownface.SafeClownface<Dataset> = <any> {};
 
-const singleBlankAuto: clownface.SingleContextClownface<DatasetCore, BlankNode> = safeCf.blankNode();
-const SingleBlank: clownface.SingleContextClownface<DatasetCore, BlankNode> = safeCf.blankNode('blank');
-const singleNamed: clownface.SingleContextClownface<DatasetCore, NamedNode> = safeCf.namedNode('http://example.com/a');
-const singleLiteral: clownface.SingleContextClownface<DatasetCore, Literal> = safeCf.literal('a');
+let singleBlank: clownface.SingleContextClownface<Dataset, BlankNode> = safeCf.blankNode();
+singleBlank = clownface({ dataset }).blankNode();
+singleBlank = safeCf.blankNode('blank');
+singleBlank = clownface({ dataset }).node(null);
 
-const fromSingleArrayBLank: clownface.SingleContextClownface<DatasetCore, BlankNode> = safeCf.blankNode([ 'b1' ]);
-const fromSingleArrayNamed: clownface.SingleContextClownface<DatasetCore, NamedNode> = safeCf.namedNode([ 'http://example.com/a' ]);
-const fromSingleArrayLiteral: clownface.SingleContextClownface<DatasetCore, Literal> = safeCf.literal([ 'a' ]);
+let singleNamed: clownface.SingleContextClownface<Dataset, NamedNode> = clownface({ dataset }).namedNode('urn:foo:bar');
+singleNamed = safeCf.namedNode('http://example.com/a');
+singleNamed = clownface({ dataset }).node(node);
 
-const multipleBlanks: clownface.SafeClownface<DatasetCore, BlankNode> = safeCf.blankNode([ 'b1', 'b2' ]);
-const multipleNamed: clownface.SafeClownface<DatasetCore, NamedNode> = safeCf.namedNode([ 'http://example.com/a', 'http://example.com/b' ]);
-const multipleLiterals: clownface.SafeClownface<DatasetCore, Literal> = safeCf.literal([ 'a', 'b' ]);
+let singleLiteral: clownface.SingleContextClownface<Dataset, Literal> = clownface({ dataset }).literal('foo');
+singleLiteral = safeCf.literal('a');
+singleLiteral = clownface({ dataset }).node('b');
+
+const fromSingleArrayBLank: clownface.SingleContextClownface<Dataset, BlankNode> = safeCf.blankNode([ 'b1' ]);
+const fromSingleArrayNamed: clownface.SingleContextClownface<Dataset, NamedNode> = safeCf.namedNode([ 'http://example.com/a' ]);
+const fromSingleArrayLiteral: clownface.SingleContextClownface<Dataset, Literal> = safeCf.literal([ 'a' ]);
+
+let multipleBlanks: clownface.SafeClownface<Dataset, BlankNode> = safeCf.blankNode([ 'b1', 'b2' ]);
+multipleBlanks = clownface({ dataset }).node([ null, null ]);
+
+let multipleNamed: clownface.SafeClownface<Dataset, NamedNode> = safeCf.namedNode([ 'http://example.com/a', 'http://example.com/b' ]);
+multipleNamed = clownface({ dataset }).node([ node, node ]);
+
+let multipleLiterals: clownface.SafeClownface<Dataset, Literal> = safeCf.literal([ 'a', 'b' ]);
+multipleLiterals = clownface({ dataset }).node([ 'a', 10, false ]);
+
+const multipleMixedTerms: clownface.SafeClownface<Dataset> = clownface({ dataset }).node([ 'a', node, null ]);
diff --git a/types/clownface/index.d.ts b/types/clownface/index.d.ts
index f03fc076ff..c57614c978 100644
--- a/types/clownface/index.d.ts
+++ b/types/clownface/index.d.ts
@@ -48,12 +48,27 @@ declare namespace clownface {
         forEach(cb: (quad: Clownface<D, T>) => void): void;
         map<X>(cb: (quad: Clownface<D, T>, index: number) => X): X[];
 
-        // tslint:disable:no-unnecessary-generics
-        node<X extends Term = Term>(values: SingleOrArray<boolean | string | number | Term | null>, options?: NodeOptions): SafeClownface<D, X>;
-        blankNode(values?: SingleOrArray<string>): SafeClownface<D, BlankNode>;
-        literal(values: SingleOrArray<boolean | string | number | Term | null>, languageOrDatatype?: string | NamedNode): SafeClownface<D, Literal>;
-        namedNode(values: SingleOrArray<string | NamedNode>): SafeClownface<D, NamedNode>;
+        node(value: SingleOrOneElementArray<boolean | string | number>, options?: NodeOptions): SingleContextClownface<D, Literal>;
+        node(values: Array<boolean | string | number>, options?: NodeOptions): SafeClownface<D, Literal>;
 
+        node<X extends Term>(value: SingleOrOneElementArray<X>, options?: NodeOptions): SingleContextClownface<D, X>;
+        node<X extends Term>(values: X[], options?: NodeOptions): SafeClownface<D, X>;
+
+        node(value: null, options?: NodeOptions): SingleContextClownface<D, BlankNode>;
+        node(values: null[], options?: NodeOptions): SafeClownface<D, BlankNode>;
+
+        node(values: SingleOrArray<boolean | string | number | Term | null>, options?: NodeOptions): SafeClownface<D>;
+
+        blankNode(value?: SingleOrOneElementArray<string>): SingleContextClownface<D, BlankNode>;
+        blankNode(values: string[]): SafeClownface<D, BlankNode>;
+
+        literal(value: SingleOrOneElementArray<boolean | string | number | Term | null>, languageOrDatatype?: string | NamedNode): SingleContextClownface<D, Literal>;
+        literal(values: Array<boolean | string | number | Term | null>, languageOrDatatype?: string | NamedNode): SafeClownface<D, Literal>;
+
+        namedNode(value: SingleOrOneElementArray<string | NamedNode>): SingleContextClownface<D, NamedNode>;
+        namedNode(values: Array<string | NamedNode>): SafeClownface<D, NamedNode>;
+
+        // tslint:disable:no-unnecessary-generics
         in<X extends Term = Term>(predicates: SingleOrArrayOfTerms): SafeClownface<D, X>;
         out<X extends Term = Term>(predicates: SingleOrArrayOfTerms): SafeClownface<D, X>;
 
@@ -74,20 +89,6 @@ declare namespace clownface {
     }
 
     interface SafeClownface<D extends DatasetCore = DatasetCore, T extends Term = Term> extends Clownface<D, T> {
-        // tslint:disable:no-unnecessary-generics
-        node<X extends Term = Term>(value: SingleOrOneElementArray<boolean | string | number | Term | null>, options?: NodeOptions): SingleContextClownface<D, X>;
-        node<X extends Term = Term>(values: Array<boolean | string | number | Term | null>, options?: NodeOptions): SafeClownface<D, X>;
-        // tslint:enable:no-unnecessary-generics
-
-        blankNode(value?: SingleOrOneElementArray<string>): SingleContextClownface<D, BlankNode>;
-        blankNode(values: string[]): SafeClownface<D, BlankNode>;
-
-        literal(value: SingleOrOneElementArray<boolean | string | number | Term | null>, languageOrDatatype?: string | NamedNode): SingleContextClownface<D, Literal>;
-        literal(values: Array<boolean | string | number | Term | null>, languageOrDatatype?: string | NamedNode): SafeClownface<D, Literal>;
-
-        namedNode(value: SingleOrOneElementArray<string | NamedNode>): SingleContextClownface<D, NamedNode>;
-        namedNode(values: Array<string | NamedNode>): SafeClownface<D, NamedNode>;
-
         filter(cb: (quad: SingleContextClownface<D, T>) => boolean): SafeClownface<D, T>;
         forEach(cb: (quad: SingleContextClownface<D, T>) => void): void;
         map<X>(cb: (quad: SingleContextClownface<D, T>, index: number) => X): X[];
diff --git a/types/clownface/lib/Clownface.d.ts b/types/clownface/lib/Clownface.d.ts
index f2e10b7c52..1b2236b372 100644
--- a/types/clownface/lib/Clownface.d.ts
+++ b/types/clownface/lib/Clownface.d.ts
@@ -1,4 +1,4 @@
-import { BlankNode, DatasetCore, Literal, NamedNode, Quad_Graph, Term } from 'rdf-js';
+import { BlankNode, DatasetCore, Literal, NamedNode, Quad_Graph, Term, Variable, DefaultGraph } from 'rdf-js';
 import {
     Clownface as ClownfaceContract,
     ClownfaceInit,
@@ -9,7 +9,9 @@ import {
     SingleOrArrayOfTerms,
     SingleOrArrayOfTermsOrLiterals,
     WithValue,
-    WithTerm
+    WithTerm,
+    SingleContextClownface,
+    SingleOrOneElementArray
 } from '..';
 
 declare class Clownface<D extends DatasetCore = DatasetCore, T extends Term = Term> implements ClownfaceContract<D, T> {
@@ -27,12 +29,26 @@ declare class Clownface<D extends DatasetCore = DatasetCore, T extends Term = Te
     forEach(cb: (quad: Clownface<D, T>) => void): void;
     map<X>(cb: (quad: Clownface<D, T>, index: number) => X): X[];
 
-    // tslint:disable:no-unnecessary-generics
-    node<X extends Term = Term>(values: SingleOrArray<boolean | string | number | Term | null>, options?: NodeOptions): SafeClownface<D, X>;
-    blankNode(values?: SingleOrArray<string>): SafeClownface<D, BlankNode>;
-    literal(values: SingleOrArray<boolean | string | number | Term | null>, languageOrDatatype?: string | NamedNode): SafeClownface<D, Literal>;
-    namedNode(values: SingleOrArray<string | NamedNode>): SafeClownface<D, NamedNode>;
+    node(value: SingleOrOneElementArray<string | number | boolean>, options?: NodeOptions): SingleContextClownface<D, Literal>;
+    node(values: Array<string | number | boolean>, options?: NodeOptions): SafeClownface<D, Literal>;
+    node<X extends Term>(value: SingleOrOneElementArray<X>, options?: NodeOptions): SingleContextClownface<D, X>;
+    node<X extends Term>(values: X[], options?: NodeOptions): SafeClownface<D, X>;
+    node(value: null, options?: NodeOptions): SingleContextClownface<D, BlankNode>;
+    node(values: null[], options?: NodeOptions): SafeClownface<D, BlankNode>;
+    node(values: SingleOrArray<string | number | boolean | NamedNode | BlankNode | Literal | Variable | DefaultGraph | null>, options?: NodeOptions): SafeClownface<D>;
 
+    blankNode(value?: string | [string]): SingleContextClownface<D, BlankNode>;
+    blankNode(values: string[]): SafeClownface<D, BlankNode>;
+
+    literal(
+        value: SingleOrOneElementArray<string | number | boolean | NamedNode | BlankNode | Literal | Variable | DefaultGraph | null>,
+        languageOrDatatype?: string | NamedNode): SingleContextClownface<D, Literal>;
+    literal(values: Array<string | number | boolean | NamedNode | BlankNode | Literal | Variable | DefaultGraph | null>, languageOrDatatype?: string | NamedNode): SafeClownface<D, Literal>;
+
+    namedNode(value: SingleOrOneElementArray<string | NamedNode>): SingleContextClownface<D, NamedNode>;
+    namedNode(values: Array<string | NamedNode>): SafeClownface<D, NamedNode>;
+
+    // tslint:disable:no-unnecessary-generics
     in<X extends Term = Term>(predicates: SingleOrArrayOfTerms): SafeClownface<D, X>;
     out<X extends Term = Term>(predicates: SingleOrArrayOfTerms): SafeClownface<D, X>;