@types/clownface - npm Package Compare versions

Comparing version 0.12.8 to 0.12.9

clownface/index.d.ts

@@ -5,3 +5,3 @@ // Type definitions for clownface 0.12
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.3
+// TypeScript Version: 3.4
 
@@ -12,123 +12,96 @@ import { Term, DatasetCore, Quad_Graph, NamedNode, BlankNode, Literal } from 'rdf-js';
 declare namespace clownface {
-    type TermOrClownface = Clownface | Term;
-    type TermOrLiteral = TermOrClownface | string | number | boolean;
+  type AnyContext = Term | Term[] | undefined;
 
-    type AddCallback<D extends DatasetCore, X extends Term> = (added: SingleContextClownface<D, X>) => void;
-    type SingleOrArray<T> = T | T[];
-    type SingleOrOneElementArray<T> = T | [T];
+  type TermOrClownface<X extends Term = Term> = Clownface<X> | X;
+  type TermOrLiteral<X extends Term = Term> = TermOrClownface<X> | string | number | boolean;
 
-    type SingleOrArrayOfTerms = SingleOrArray<TermOrClownface>;
-    type SingleOrArrayOfTermsOrLiterals = SingleOrArray<TermOrLiteral>;
+  type AddCallback<D extends DatasetCore, X extends Term> = (added: Clownface<X, D>) => void;
+  type SingleOrArray<T> = T | readonly T[];
+  type SingleOrOneElementArray<T> = T | readonly [T];
 
-    interface NodeOptions {
-        type?: 'BlankNode' | 'Literal' | 'NamedNode';
-        datatype?: Term | { toString(): string };
-        language?: string;
-    }
+  type SingleOrArrayOfTerms<X extends Term> = SingleOrArray<X> | Clownface<X | X[]>;
+  type SingleOrArrayOfTermsOrLiterals<X extends Term> = SingleOrArray<TermOrLiteral<X>>;
 
-    type ClownfaceInit<D extends DatasetCore = DatasetCore, T extends Term = Term>
-        = Partial<Pick<Clownface<D, T>, 'dataset' | '_context'> & { graph: Quad_Graph }>;
+  interface NodeOptions {
+    type?: 'BlankNode' | 'Literal' | 'NamedNode';
+    datatype?: Term | { toString(): string };
+    language?: string;
+  }
 
-    interface WithSingleValue {
-        value: string;
-    }
+  type ClownfaceInit<D extends DatasetCore = DatasetCore>
+    = Partial<Pick<Clownface<AnyContext, D>, 'dataset' | '_context'> & { graph: Quad_Graph }>;
 
-    interface WithValues {
-        value: string[];
-    }
+  type Iteratee<T extends AnyContext = undefined, D extends DatasetCore = DatasetCore> =
+    T extends undefined
+      ? never
+      : T extends any[]
+      ? Clownface<T[0], D>
+      : Clownface<T, D>;
 
-    interface WithSingleTerm<T extends Term = Term> {
-        term: T;
-    }
+  interface Clownface<T extends AnyContext = AnyContext, D extends DatasetCore = DatasetCore> {
+    readonly term: T extends undefined ? undefined : T extends any[] ? undefined : T;
+    readonly terms: T extends undefined ? Term[] : T extends any[] ? T : [T];
+    readonly value: T extends undefined ? undefined : T extends any[] ? undefined : string;
+    readonly values: T extends undefined ? string[] : T extends any[] ? string[] : [string];
+    readonly dataset: D;
+    readonly datasets: D[];
+    readonly _context: Array<Context<D, Term>>;
+    list(): Iterable<Iteratee<T, D>>;
+    toArray(): Array<Clownface<T extends undefined ? never : T extends any[] ? T[0] : T, D>>;
+    filter(cb: (quad: Iteratee<T, D>) => boolean): Clownface<T, D>;
+    forEach(cb: (quad: Iteratee<T, D>) => void): void;
+    map<X>(cb: (quad: Iteratee<T, D>, index: number) => X): X[];
 
-    interface WithTerms<T extends Term = Term> {
-        term: T[];
-    }
+    node(value: SingleOrOneElementArray<boolean | string | number>, options?: NodeOptions): Clownface<Literal, D>;
+    node(values: Array<boolean | string | number>, options?: NodeOptions): Clownface<Literal[], D>;
 
-    interface Clownface<D extends DatasetCore = DatasetCore, T extends Term = Term> {
-        readonly term: T | undefined;
-        readonly terms: T[];
-        readonly value: string | undefined;
-        readonly values: string[];
-        readonly dataset: D;
-        readonly datasets: D[];
-        readonly _context: Array<Context<D, T>>;
-        list(): Iterable<SingleContextClownface<D>>;
-        toArray(): Array<Clownface<D, T>>;
-        filter(cb: (quad: Clownface<D, T>) => boolean): Clownface<D, T>;
-        forEach(cb: (quad: Clownface<D, T>) => void): void;
-        map<X>(cb: (quad: Clownface<D, T>, index: number) => X): X[];
+    node<X extends Term>(value: SingleOrOneElementArray<X>, options?: NodeOptions): Clownface<X, D>;
+    node<X extends Term[]>(values: X, options?: NodeOptions): Clownface<X, D>;
 
-        node(value: SingleOrOneElementArray<boolean | string | number>, options?: NodeOptions): SingleContextClownface<D, Literal>;
-        node(values: Array<boolean | string | number>, options?: NodeOptions): SafeClownface<D, Literal>;
+    node(value: null, options?: NodeOptions): Clownface<BlankNode, D>;
+    node(values: null[], options?: NodeOptions): Clownface<BlankNode[], D>;
 
-        node<X extends Term>(value: SingleOrOneElementArray<X>, options?: NodeOptions): SingleContextClownface<D, X>;
-        node<X extends Term>(values: X[], options?: NodeOptions): SafeClownface<D, X>;
+    node(values: Array<boolean | string | number | Term | null>, options?: NodeOptions): Clownface<Term[], D>;
 
-        node(value: null, options?: NodeOptions): SingleContextClownface<D, BlankNode>;
-        node(values: null[], options?: NodeOptions): SafeClownface<D, BlankNode>;
+    blankNode(value?: SingleOrOneElementArray<string>): Clownface<BlankNode, D>;
+    blankNode(values: string[]): Clownface<BlankNode[], D>;
 
-        node(values: SingleOrArray<boolean | string | number | Term | null>, options?: NodeOptions): SafeClownface<D>;
+    literal(value: SingleOrOneElementArray<boolean | string | number | Term | null>, languageOrDatatype?: string | NamedNode): Clownface<Literal, D>;
+    literal(values: Array<boolean | string | number | Term | null>, languageOrDatatype?: string | NamedNode): Clownface<Literal[], D>;
 
-        blankNode(value?: SingleOrOneElementArray<string>): SingleContextClownface<D, BlankNode>;
-        blankNode(values: string[]): SafeClownface<D, BlankNode>;
+    namedNode(value: SingleOrOneElementArray<string | NamedNode>): Clownface<NamedNode, D>;
+    namedNode(values: Array<string | NamedNode>): Clownface<NamedNode[], D>;
 
-        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>;
+    in(predicates?: SingleOrArrayOfTerms<Term>): Clownface<T extends undefined ? never : Term[], D>;
+    out(predicates?: SingleOrArrayOfTerms<Term>): Clownface<T extends undefined ? never : Term[], D>;
 
-        namedNode(value: SingleOrOneElementArray<string | NamedNode>): SingleContextClownface<D, NamedNode>;
-        namedNode(values: Array<string | NamedNode>): SafeClownface<D, NamedNode>;
+    has<X extends Term = Term>(predicates: SingleOrArrayOfTerms<Term>, objects?: SingleOrArrayOfTermsOrLiterals<X>): Clownface<X[], D>;
 
-        // 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>;
+    addIn(predicates: SingleOrArrayOfTerms<Term>, callback?: AddCallback<D, BlankNode>): Clownface<T, D>;
+    addIn<X extends Term = Term>(predicates: SingleOrArrayOfTerms<Term>, objects: SingleOrArrayOfTermsOrLiterals<X>, callback?: AddCallback<D, X>): Clownface<T, D>;
 
-        has<X extends Term = Term>(predicates: SingleOrArrayOfTerms, objects?: SingleOrArrayOfTermsOrLiterals): SafeClownface<D, X>;
+    addOut(predicates: SingleOrArrayOfTerms<Term>, callback?: AddCallback<D, BlankNode>): Clownface<T, D>;
+    addOut<X extends Term = Term>(predicates: SingleOrArrayOfTerms<Term>, objects: SingleOrArrayOfTermsOrLiterals<X>, callback?: AddCallback<D, X>): Clownface<T, D>;
 
-        addIn<X extends Term = Term>(predicate: SingleOrOneElementArray<Term>, objectOrCallback?: SingleOrOneElementArray<TermOrLiteral> | AddCallback<D, X>): SingleContextClownface<D, X>;
-        addIn<X extends Term = Term>(predicate: SingleOrOneElementArray<Term>, object: SingleOrOneElementArray<TermOrLiteral>, callback: AddCallback<D, X>): SingleContextClownface<D, X>;
-        addIn<X extends Term = Term>(predicates: SingleOrArrayOfTerms, objectsOrCallback?: SingleOrArrayOfTermsOrLiterals | AddCallback<D, X>): SafeClownface<D, X>;
-        addIn<X extends Term = Term>(predicates: SingleOrArrayOfTerms, objects: SingleOrArrayOfTermsOrLiterals, callback: AddCallback<D, X>): SafeClownface<D, X>;
+    addList<X extends Term = Term>(predicates: SingleOrArrayOfTerms<Term>, objects?: SingleOrArrayOfTermsOrLiterals<X>, callback?: AddCallback<D, X>): Clownface<T, D>;
 
-        addOut<X extends Term = Term>(predicate: SingleOrOneElementArray<Term>, objectOrCallback?: SingleOrOneElementArray<TermOrLiteral> | AddCallback<D, X>): SingleContextClownface<D, X>;
-        addOut<X extends Term = Term>(predicate: SingleOrOneElementArray<Term>, object: SingleOrOneElementArray<TermOrLiteral>, callback: AddCallback<D, X>): SingleContextClownface<D, X>;
-        addOut<X extends Term = Term>(predicates: SingleOrArrayOfTerms, objectsOrCallback?: SingleOrArrayOfTermsOrLiterals | AddCallback<D, X>): SafeClownface<D, X>;
-        addOut<X extends Term = Term>(predicates: SingleOrArrayOfTerms, objects: SingleOrArrayOfTermsOrLiterals, callback: AddCallback<D, X>): SafeClownface<D, X>;
+    deleteIn(predicates?: SingleOrArrayOfTerms<Term>): Clownface<T, D>;
+    deleteOut(predicates?: SingleOrArrayOfTerms<Term>): Clownface<T, D>;
+    deleteList(predicates: SingleOrArrayOfTerms<Term>): Clownface<T, D>;
+  }
 
-        addList<X extends Term = Term>(predicates: SingleOrArrayOfTerms, objects?: SingleOrArrayOfTermsOrLiterals, callback?: AddCallback<D, X>): SafeClownface<D, X>;
+  type SafeClownface<T extends Term = Term, D extends DatasetCore = DatasetCore> = Clownface<T | T[], D>;
+  type SingleContextClownface<T extends Term = Term, D extends DatasetCore = DatasetCore> = Clownface<T, D>;
 
-        deleteIn<X extends Term = Term>(predicates?: SingleOrArrayOfTerms): SafeClownface<D, X>;
-        deleteOut<X extends Term = Term>(predicates?: SingleOrArrayOfTerms): SafeClownface<D, X>;
-        deleteList<X extends Term = Term>(predicates: SingleOrArrayOfTerms): SafeClownface<D, X>;
-        // tslint:enable:no-unnecessary-generics
-    }
-
-    interface SafeClownface<D extends DatasetCore = DatasetCore, T extends Term = Term> extends Clownface<D, T> {
-        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[];
-        toArray(): Array<SingleContextClownface<D, T>>;
-    }
-
-    interface SingleContextClownface<D extends DatasetCore = DatasetCore, T extends Term = Term> extends SafeClownface<D, T> {
-        readonly term: T;
-        readonly terms: [T];
-        readonly value: string;
-        readonly values: [string];
-        readonly _context: [Context<D, T>];
-    }
+  type ClownfaceInitWithTerms<T extends Term | Term[], D extends DatasetCore> = ClownfaceInit<D> & { term: T };
+  type ClownfaceInitWithValue<D extends DatasetCore> = ClownfaceInit<D> & { value: string };
+  type ClownfaceInitWithValues<D extends DatasetCore> = ClownfaceInit<D> & { value: string[] };
 }
 
-type ClownfaceInitWithNodes<D extends DatasetCore, T extends Term> =
-    clownface.ClownfaceInit<D> & clownface.WithTerms<T> |
-    clownface.ClownfaceInit<D> & clownface.WithValues;
+declare function clownface<D extends DatasetCore, T extends clownface.AnyContext>(other: clownface.Clownface<T, D>): clownface.Clownface<T, D>;
+declare function clownface<D extends DatasetCore>(options: clownface.ClownfaceInitWithValue<D>): clownface.Clownface<Literal, D>;
+declare function clownface<D extends DatasetCore>(options: clownface.ClownfaceInitWithValues<D>): clownface.Clownface<Literal[], D>;
+declare function clownface<D extends DatasetCore, T extends Term | Term[]>(options: clownface.ClownfaceInitWithTerms<T, D>): clownface.Clownface<T, D>;
+declare function clownface<D extends DatasetCore>(options: clownface.ClownfaceInit<D>): clownface.Clownface<clownface.AnyContext, D>;
 
-type ClownfaceInitWithSingleNode<D extends DatasetCore, T extends Term> =
-    clownface.ClownfaceInit<D> & clownface.WithSingleTerm<T> |
-    clownface.ClownfaceInit<D> & clownface.WithSingleValue;
-
-declare function clownface<D extends DatasetCore, T extends Term = Term>(options: ClownfaceInitWithNodes<D, T>): clownface.SafeClownface<D, T>;
-declare function clownface<D extends DatasetCore, T extends Term = Term>(options: ClownfaceInitWithSingleNode<D, T>): clownface.SingleContextClownface<D, T>;
-declare function clownface<D extends DatasetCore, T extends Term = Term>(options: clownface.ClownfaceInit<D, T>): clownface.Clownface<D, T>;
-
 export = clownface;

clownface/lib/Clownface.d.ts

@@ -1,2 +0,2 @@
-import { BlankNode, DatasetCore, Literal, NamedNode, Quad_Graph, Term, Variable, DefaultGraph } from 'rdf-js';
+import { BlankNode, DatasetCore, Literal, NamedNode, Quad_Graph, Term, Variable, DefaultGraph, Quad } from 'rdf-js';
 import {
@@ -7,74 +7,67 @@ Clownface as ClownfaceContract,
     NodeOptions,
-    SafeClownface,
-    SingleOrArray,
     SingleOrArrayOfTerms,
     SingleOrArrayOfTermsOrLiterals,
-    WithValues,
-    WithSingleValue,
-    WithTerms,
-    WithSingleTerm,
-    SingleContextClownface,
+    ClownfaceInitWithTerms,
+    ClownfaceInitWithValue,
+    ClownfaceInitWithValues,
     SingleOrOneElementArray,
-    TermOrLiteral
+    Iteratee,
+    AnyContext
 } from '..';
 import { Context } from './Context';
 
-declare class Clownface<D extends DatasetCore = DatasetCore, T extends Term = Term> implements ClownfaceContract<D, T> {
-    constructor(options: ClownfaceInit & Partial<WithSingleTerm<T> | WithTerms<T>> & Partial<WithSingleValue | WithValues>);
-    readonly term: T | undefined;
-    readonly terms: T[];
-    readonly value: string | undefined;
-    readonly values: string[];
+declare class Clownface<T extends AnyContext = AnyContext, D extends DatasetCore = DatasetCore> implements ClownfaceContract<T, D> {
+    constructor(options: ClownfaceInit<D> | ClownfaceInitWithTerms<Term | Term[], D> | ClownfaceInitWithValue<D> | ClownfaceInitWithValues<D>);
+
+    readonly term: T extends undefined ? undefined : T extends any[] ? undefined : T;
+    readonly terms: T extends undefined ? Term[] : T extends any[] ? T : [T];
+    readonly value: T extends undefined ? undefined : T extends any[] ? undefined : string;
+    readonly values: T extends undefined ? string[] : T extends any[] ? string[] : [string];
     readonly dataset: D;
     readonly datasets: D[];
-    readonly _context: Array<Context<D, T>>;
-    list(): Iterable<SingleContextClownface<D>>;
-    toArray(): Array<Clownface<D, T>>;
-    filter(cb: (quad: Clownface<D, T>) => boolean): Clownface<D, T>;
-    forEach(cb: (quad: Clownface<D, T>) => void): void;
-    map<X>(cb: (quad: Clownface<D, T>, index: number) => X): X[];
+    readonly _context: Array<Context<D, Term>>;
+    list(): Iterable<Iteratee<T, D>>;
+    toArray(): Array<Clownface<T extends undefined ? never : T extends any[] ? T[0] : T, D>>;
+    filter(cb: (quad: Iteratee<T, D>) => boolean): Clownface<T, D>;
+    forEach(cb: (quad: Iteratee<T, D>) => void): void;
+    map<X>(cb: (quad: Iteratee<T, D>, index: number) => X): X[];
 
-    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>;
+    node(value: SingleOrOneElementArray<boolean | string | number>, options?: NodeOptions): Clownface<Literal, D>;
+    node(values: Array<boolean | string | number>, options?: NodeOptions): Clownface<Literal[], D>;
 
-    blankNode(value?: string | [string]): SingleContextClownface<D, BlankNode>;
-    blankNode(values: string[]): SafeClownface<D, BlankNode>;
+    node<X extends Term>(value: SingleOrOneElementArray<X>, options?: NodeOptions): Clownface<X, D>;
+    node<X extends Term[]>(values: X, options?: NodeOptions): Clownface<X, D>;
 
-    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>;
+    node(value: null, options?: NodeOptions): Clownface<BlankNode, D>;
+    node(values: null[], options?: NodeOptions): Clownface<BlankNode[], D>;
 
-    namedNode(value: SingleOrOneElementArray<string | NamedNode>): SingleContextClownface<D, NamedNode>;
-    namedNode(values: Array<string | NamedNode>): SafeClownface<D, NamedNode>;
+    node(values: Array<boolean | string | number | Term | null>, options?: NodeOptions): Clownface<Term[], D>;
 
-    // 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>;
+    blankNode(value?: SingleOrOneElementArray<string>): Clownface<BlankNode, D>;
+    blankNode(values: string[]): Clownface<BlankNode[], D>;
 
-    has<X extends Term = Term>(predicates: SingleOrArrayOfTerms, objects?: SingleOrArrayOfTermsOrLiterals): SafeClownface<D, X>;
+    literal(value: SingleOrOneElementArray<boolean | string | number | Term | null>, languageOrDatatype?: string | NamedNode): Clownface<Literal, D>;
+    literal(values: Array<boolean | string | number | Term | null>, languageOrDatatype?: string | NamedNode): Clownface<Literal[], D>;
 
-    addIn<X extends Term = Term>(predicate: SingleOrOneElementArray<Term>, objectOrCallback?: SingleOrOneElementArray<TermOrLiteral> | AddCallback<D, X>): SingleContextClownface<D, X>;
-    addIn<X extends Term = Term>(predicate: SingleOrOneElementArray<Term>, object: SingleOrOneElementArray<TermOrLiteral>, callback: AddCallback<D, X>): SingleContextClownface<D, X>;
-    addIn<X extends Term = Term>(predicates: SingleOrArrayOfTerms, objectsOrCallback?: SingleOrArrayOfTermsOrLiterals | AddCallback<D, X>): SafeClownface<D, X>;
-    addIn<X extends Term = Term>(predicates: SingleOrArrayOfTerms, objects: SingleOrArrayOfTermsOrLiterals, callback: AddCallback<D, X>): SafeClownface<D, X>;
+    namedNode(value: SingleOrOneElementArray<string | NamedNode>): Clownface<NamedNode, D>;
+    namedNode(values: Array<string | NamedNode>): Clownface<NamedNode[], D>;
 
-    addOut<X extends Term = Term>(predicate: SingleOrOneElementArray<Term>, objectOrCallback?: SingleOrOneElementArray<TermOrLiteral> | AddCallback<D, X>): SingleContextClownface<D, X>;
-    addOut<X extends Term = Term>(predicate: SingleOrOneElementArray<Term>, object: SingleOrOneElementArray<TermOrLiteral>, callback: AddCallback<D, X>): SingleContextClownface<D, X>;
-    addOut<X extends Term = Term>(predicates: SingleOrArrayOfTerms, objectsOrCallback?: SingleOrArrayOfTermsOrLiterals | AddCallback<D, X>): SafeClownface<D, X>;
-    addOut<X extends Term = Term>(predicates: SingleOrArrayOfTerms, objects: SingleOrArrayOfTermsOrLiterals, callback: AddCallback<D, X>): SafeClownface<D, X>;
+    in(predicates?: SingleOrArrayOfTerms<Term>): Clownface<T extends undefined ? never : Term[], D>;
+    out(predicates?: SingleOrArrayOfTerms<Term>): Clownface<T extends undefined ? never : Term[], D>;
 
-    addList<X extends Term = Term>(predicates: SingleOrArrayOfTerms, objects?: SingleOrArrayOfTerms, callback?: AddCallback<D, X>): SafeClownface<D, X>;
+    has<X extends Term = Term>(predicates: SingleOrArrayOfTerms<Term>, objects?: SingleOrArrayOfTermsOrLiterals<X>): Clownface<X[], D>;
 
-    deleteIn<X extends Term = Term>(predicates?: SingleOrArrayOfTerms): SafeClownface<D, X>;
-    deleteOut<X extends Term = Term>(predicates?: SingleOrArrayOfTerms): SafeClownface<D, X>;
-    deleteList<X extends Term = Term>(predicates: SingleOrArrayOfTerms): SafeClownface<D, X>;
-    // tslint:enable:no-unnecessary-generics
+    addIn(predicates: SingleOrArrayOfTerms<Term>, callback?: AddCallback<D, BlankNode>): Clownface<T, D>;
+    addIn<X extends Term = Term>(predicates: SingleOrArrayOfTerms<Term>, objects: SingleOrArrayOfTermsOrLiterals<X>, callback?: AddCallback<D, X>): Clownface<T, D>;
+
+    addOut(predicates: SingleOrArrayOfTerms<Term>, callback?: AddCallback<D, BlankNode>): Clownface<T, D>;
+    addOut<X extends Term = Term>(predicates: SingleOrArrayOfTerms<Term>, objects: SingleOrArrayOfTermsOrLiterals<X>, callback?: AddCallback<D, X>): Clownface<T, D>;
+
+    addList<X extends Term = Term>(predicates: SingleOrArrayOfTerms<Term>, objects?: SingleOrArrayOfTermsOrLiterals<X>, callback?: AddCallback<D, X>): Clownface<T, D>;
+
+    deleteIn(predicates?: SingleOrArrayOfTerms<Term>): Clownface<T, D>;
+    deleteOut(predicates?: SingleOrArrayOfTerms<Term>): Clownface<T, D>;
+    deleteList(predicates: SingleOrArrayOfTerms<Term>): Clownface<T, D>;
 }
 
 export = Clownface;

clownface/package.json

 {
     "name": "@types/clownface",
-    "version": "0.12.8",
+    "version": "0.12.9",
     "description": "TypeScript definitions for clownface",
@@ -24,4 +24,4 @@ "license": "MIT",
     },
-    "typesPublisherContentHash": "729aa5c7203b5d3902e2da08694993efbac6b706d1888f7071f20200dd4acdc4",
-    "typeScriptVersion": "2.8"
+    "typesPublisherContentHash": "88c58c6e8f637a21dec85184c44832a6e85e189f6f29e4c633e262a52ab7a311",
+    "typeScriptVersion": "3.4"
 }

clownface/README.md

@@ -11,3 +11,3 @@ # Installation
 ### Additional Details
- * Last updated: Sun, 22 Mar 2020 20:51:29 GMT
+ * Last updated: Mon, 30 Mar 2020 22:15:34 GMT
  * Dependencies: [@types/rdf-js](https://npmjs.com/package/@types/rdf-js)
@@ -14,0 +14,0 @@ * Global values: none

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Worsened metrics

Total package byte prevSize

13118

decreased by-14.31%

Lines of code

150

decreased by-18.48%

Number of medium supply chain risk alerts

1

increased byInfinity%

No dependency changes