diff --git a/types/clownface/clownface-tests.ts b/types/clownface/clownface-tests.ts
index fb54dd8def..82882d50ae 100644
--- a/types/clownface/clownface-tests.ts
+++ b/types/clownface/clownface-tests.ts
@@ -1,4 +1,4 @@
-import { Term, NamedNode, Dataset, Literal } from 'rdf-js';
+import { Term, NamedNode, Dataset, Literal, DatasetCore, BlankNode } from 'rdf-js';
 import Clownface = require('clownface/lib/Clownface');
 import clownface = require('clownface');
 
@@ -143,3 +143,18 @@ if (cf.value) {
 
 // .values
 const values: string[] = cf.values;
+
+const safeCf: clownface.SafeClownface = <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');
+
+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' ]);
+
+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' ]);
diff --git a/types/clownface/index.d.ts b/types/clownface/index.d.ts
index 53ec9d136f..f03fc076ff 100644
--- a/types/clownface/index.d.ts
+++ b/types/clownface/index.d.ts
@@ -12,6 +12,7 @@ declare namespace clownface {
 
     type AddCallback<D extends DatasetCore, X extends Term> = (added: SingleContextClownface<D, X>) => void;
     type SingleOrArray<T> = T | T[];
+    type SingleOrOneElementArray<T> = T | [T];
 
     type SingleOrArrayOfTerms = SingleOrArray<TermOrClownface>;
     type SingleOrArrayOfTermsOrLiterals = SingleOrArray<TermOrLiteral>;
@@ -73,6 +74,20 @@ 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[];