Merge pull request #34029 from 7th-ndn-hackathon/ndn-js

ndn-js: new typings

types/ndn-js/blob.d.ts

@@ -0,0 +1,20 @@
+export class Blob {
+    constructor(value?: Blob);
+    constructor(value: Buffer, copy?: boolean);
+    constructor(value: ReadonlyArray<number>|string);
+
+    buf(): Buffer;
+    equals(other: Blob): boolean;
+    isNull(): boolean;
+    size(): number;
+}
+
+export class SignedBlob extends Blob {
+    constructor();
+    constructor(value: Blob|Buffer|ReadonlyArray<number>, signedPortionBeginOffset: number, signedPortionEndOffset: number);
+
+    getSignedPortionBeginOffset(): number;
+    getSignedPortionEndOffset(): number;
+    signedBuf(): Buffer;
+    signedSize(): number;
+}

types/ndn-js/data.d.ts

@@ -0,0 +1,46 @@
+import { Blob } from "./blob";
+import { Name } from "./name";
+import { Signature } from "./signature";
+
+export class Data {
+    constructor(name?: Name|string);
+    constructor(data: Data);
+
+    getName(): Name;
+    getFullName(): Name;
+    getMetaInfo(): MetaInfo;
+    getContent(): Blob;
+    getSignature(): Signature;
+    getCongestionMark(): number;
+    getIncomingFaceId(): number;
+
+    setName(name: Name): Data;
+    setMetaInfo(meta: MetaInfo): Data;
+    setContent(content: Blob|Buffer): Data;
+    setSignature(sig: Signature): Data;
+
+    wireDecode(input: Blob|Buffer): void;
+    wireEncode(): Blob;
+}
+
+export enum ContentType {
+    BLOB = 0,
+    LINK = 1,
+    KEY  = 2,
+    NACK = 3,
+    OTHER_CODE = 0x7fff,
+}
+
+export class MetaInfo {
+    constructor(meta?: MetaInfo);
+
+    getType(): ContentType;
+    getOtherTypeCode(): number;
+    getFreshnessPeriod(): number;
+    getFinalBlockId(): Name.Component;
+
+    setType(type: ContentType): void;
+    setOtherTypeCode(otherTypeCode: number): void;
+    setFreshnessPeriod(freshness: number): void;
+    setFinalBlockId(comp: Name.Component): void;
+}

types/ndn-js/face.d.ts

@@ -0,0 +1,62 @@
+import { Blob } from "./blob";
+import { Data } from "./data";
+import { Interest } from "./interest";
+import { KeyChain } from "./key-chain";
+import { Name } from "./name";
+import { NetworkNack } from "./network-nack";
+import { Transport, TransportConnectionInfo } from "./transport";
+
+export interface FaceCtorOptions {
+    getTransport?: () => Transport;
+    getConnectionInfo?: () => TransportConnectionInfo;
+    connectionInfo?: TransportConnectionInfo|null;
+    host?: string|null;
+    port?: number|null;
+}
+
+export type OnInterestCallback = (prefix: Name, interest: Interest, face: Face, filterId: number, filter: InterestFilter) => any;
+
+export class Face {
+    constructor(transport: Transport, connectionInfo: TransportConnectionInfo);
+    constructor(settings?: FaceCtorOptions);
+
+    expressInterest(interest: Interest|Name,
+                    onData: (interest: Interest, data: Data) => any,
+                    onTimeout?: (interest: Interest) => any,
+                    onNetworkNack?: (interest: Interest, nack: NetworkNack) => any): number;
+    expressInterest(name: Name,
+                    interestTemplate: Interest,
+                    onData: (interest: Interest, data: Data) => any,
+                    onTimeout?: (interest: Interest) => any,
+                    onNetworkNack?: (interest: Interest, nack: NetworkNack) => any): number;
+
+    static getMaxNdnPacketSize(): number;
+    putData(data: Data): void;
+
+    registerPrefix(prefix: Name,
+                   onInterest: OnInterestCallback,
+                   onRegisterFailed: (prefix: Name) => any,
+                   onRegisterSuccess?: (prefix: Name, registeredPrefixId: number) => any,
+                   flags?: ForwardingFlags): number;
+
+    removePendingInterest(id: number): void;
+    removeRegisteredPrefix(id: number): void;
+    send(encoding: Blob|Buffer): void;
+    setCommandCertificateName(certificateName: Name): void;
+    setCommandSigningInfo(keyChain: KeyChain, certificateName: Name): void;
+    setInterestFilter(filter: InterestFilter|Name, onInterest: OnInterestCallback): number;
+    unsetInterestFilter(id: number): void;
+}
+
+// no declaration because this type is rarely used
+export class ForwardingFlags {}
+
+export class InterestFilter {
+    constructor(filter: InterestFilter);
+    constructor(prefix: Name|string, regexFilter?: string);
+
+    doesMatch(name: Name): boolean;
+    getPrefix(): Name;
+    getRegexFilter(): string;
+    hasRegexFilter(): boolean;
+}

types/ndn-js/index.d.ts

@@ -0,0 +1,16 @@
+// Type definitions for ndn-js 0.18
+// Project: https://github.com/named-data/ndn-js
+// Definitions by: Junxiao <https://github.com/yoursunny>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+export as namespace ndn;
+export * from "./blob";
+export * from "./data";
+export * from "./face";
+export * from "./interest";
+export * from "./key-chain";
+export * from "./memory-content-cache";
+export * from "./name";
+export * from "./network-nack";
+export * from "./signature";
+export * from "./transport";

types/ndn-js/interest.d.ts

@@ -0,0 +1,49 @@
+import { Blob } from "./blob";
+import { Data } from "./data";
+import { Name } from "./name";
+
+export class Interest {
+    constructor(name?: Name|string);
+    constructor(interest: Interest);
+
+    getName(): Name;
+    getCanBePrefix(): boolean;
+    getMustBeFresh(): boolean;
+    getForwardingHint(): DelegationSet;
+    getNonce(): Blob;
+    getInterestLifetimeMilliseconds(): number;
+    getApplicationParameters(): Blob;
+    getIncomingFaceId(): number;
+
+    setName(name: Name): Interest;
+    setCanBePrefix(canBePrefix: boolean): Interest;
+    setMustBeFresh(mustBeFresh: boolean): Interest;
+    setForwardingHint(fh: DelegationSet): Interest;
+    setInterestLifetimeMilliseconds(lifetime: number): Interest;
+    setApplicationParameters(parameters: Blob|Buffer): Interest;
+
+    appendParametersDigestToName(): Interest;
+    matchesData(data: Data): boolean;
+    matchesName(name: Name): boolean;
+    refreshNonce(): void;
+    toUri(): string;
+    wireDecode(input: Blob|Buffer): void;
+    wireEncode(): Blob;
+}
+
+export class DelegationSet {
+    size(): number;
+    get(i: number): DelegationSet.Delegation;
+    find(name: Name): number;
+
+    add(preference: number, name: Name): void;
+    remove(name: Name): boolean;
+    clear(): void;
+}
+
+export namespace DelegationSet {
+    class Delegation {
+        getPreference(): number;
+        getName(): Name;
+    }
+}

types/ndn-js/key-chain.d.ts

@@ -0,0 +1,58 @@
+import { Data } from "./data";
+import { Interest } from "./interest";
+import { Name } from "./name";
+
+export class KeyChain {
+    constructor();
+    constructor(pibLocator: string, tpmLocator: string, allowReset?: boolean);
+
+    static getDefaultKeyParams(): KeyParams;
+    getPib(): Pib;
+    getTpm(): Tpm;
+
+    createIdentityV2(identityName: Name, params?: KeyParams): PibIdentity;
+    createIdentityV2(identityName: Name, onComplete: (identity: PibIdentity) => any, onError?: (err: any) => any): void;
+    createIdentityV2(identityName: Name, params: KeyParams, onComplete: (identity: PibIdentity) => any, onError?: (err: any) => any): void;
+    deleteIdentity(identity: PibIdentity, onComplete?: () => any, onError?: (err: any) => any): void;
+    setDefaultIdentity(identity: PibIdentity, onComplete?: () => any, onError?: (err: any) => any): void;
+
+    createKey(identity: PibIdentity, params?: KeyParams): PibKey;
+    createKey(identity: PibIdentity, onComplete: (key: PibKey) => any, onError?: (err: any) => any): void;
+    createKey(identity: PibIdentity, params: KeyParams, onComplete: (key: PibKey) => any, onError?: (err: any) => any): void;
+    deleteKey(identity: PibIdentity, key: PibKey, onComplete?: () => any, onError?: (err: any) => any): void;
+    setDefaultKey(identity: PibIdentity, key: PibKey, onComplete?: () => any, onError?: (err: any) => any): void;
+
+    addCertificate(key: PibKey, certificate: CertificateV2, onComplete?: () => any, onError?: (err: any) => any): void;
+    deleteCertificate(key: PibKey, certificateName: Name, onComplete?: () => any, onError?: (err: any) => any): void;
+    setDefaultCertificate(key: PibKey, certificate: CertificateV2, onComplete?: () => any, onError?: (err: any) => any): void;
+
+    sign(interest: Interest, params: SigningInfo, onComplete?: (interest: Interest) => any, onError?: (err: any) => any): void;
+    sign(data: Data, params: SigningInfo, onComplete?: (data: Data) => any, onError?: (err: any) => any): void;
+    signWithSha256(packet: Data|Interest): void;
+}
+
+// no declaration because these types are rarely used
+export class Pib {}
+export class PibIdentity {}
+export class PibKey {}
+export class KeyParams {}
+export class CertificateV2 {}
+export class Tpm {}
+
+export class SigningInfo {
+    constructor(signerType: SigningInfo.SignerType, signerName: Name);
+    constructor(arg?: SigningInfo|PibIdentity|PibKey|string);
+
+    getSignerType(): SigningInfo.SignerType;
+    getSignerName(): Name;
+}
+
+export namespace SigningInfo {
+    enum SignerType {
+        NULL   = 0,
+        ID     = 1,
+        KEY    = 2,
+        CERT   = 3,
+        SHA256 = 4,
+    }
+}

types/ndn-js/memory-content-cache.d.ts

@@ -0,0 +1,19 @@
+import { Data } from "./data";
+import { Face, ForwardingFlags, InterestFilter, OnInterestCallback } from "./face";
+import { Interest } from "./interest";
+import { Name } from "./name";
+
+export class MemoryContentCache {
+    constructor(face: Face, cleanupIntervalMilliseconds?: number);
+
+    add(data: Data): void;
+    getMinimumCacheLifetime(): number;
+    getStorePendingInterest(): OnInterestCallback;
+    registerPrefix(name: Name, onRegisterFailed: (prefix: Name) => any,
+                   onRegisterSuccess?: (prefix: Name, registeredPrefixId: number) => any,
+                   onDataNotFound?: OnInterestCallback, flags?: ForwardingFlags): void;
+    setInterestFilter(filter: InterestFilter|Name, onDataNotFound?: OnInterestCallback): void;
+    setMinimumCacheLifetime(minimumCacheLifetime: number): void;
+    storePendingInterest(interest: Interest, face: Face): void;
+    unregisterAll(): void;
+}

types/ndn-js/name.d.ts

@@ -0,0 +1,87 @@
+import { Blob } from "./blob";
+
+export enum ComponentType {
+    IMPLICIT_SHA256_DIGEST = 1,
+    PARAMETERS_SHA256_DIGEST = 2,
+    GENERIC = 8,
+    OTHER_CODE = 0x7fff,
+}
+
+export type CompareResult = -1|0|1;
+
+export namespace Name {
+    class Component {
+        constructor(value?: ReadonlyArray<number>|ArrayBuffer|Uint8Array|string|Blob, type?: ComponentType, otherTypeCode?: number);
+        constructor(component: Component);
+
+        compare(other: Component): CompareResult;
+        equals(other: Component): boolean;
+        static fromImplicitSha256Digest(digest: Blob): Component;
+        static fromParametersSha256Digest(digest: Blob): Component;
+        getOtherTypeCode(): number;
+        getSuccessor(): Component;
+        getType(): ComponentType;
+        getValue(): Blob;
+        isGeneric(): boolean;
+        isImplicitSha256Digest(): boolean;
+        isParametersSha256Digest(): boolean;
+        toEscapedString(): string;
+
+        static fromNumber(number: number, type?: ComponentType, otherTypeCode?: number): Component;
+        static fromNumberWithMarker(number: number, marker: number): Component;
+        static fromSegment(segment: number): Component;
+        static fromSegmentOffset(segmentOffset: number): Component;
+        static fromSequenceNumber(sequenceNumber: number): Component;
+        static fromTimestamp(timestamp: number): Component;
+        static fromVersion(version: number): Component;
+
+        isSegment(): boolean;
+        isSegmentOffset(): boolean;
+        isSequenceNumber(): boolean;
+        isTimestamp(): boolean;
+        isVersion(): boolean;
+
+        toNumber(): number;
+        toNumberWithMarker(marker: number): number;
+        toSegment(): number;
+        toSegmentOffset(): number;
+        toSequenceNumber(): number;
+        toTimestamp(): number;
+        toVersion(): number;
+    }
+}
+
+export class Name {
+    constructor(components?: ReadonlyArray<Name.Component|Uint8Array>);
+    constructor(name: Name|string);
+
+    append(value: ReadonlyArray<number>|ArrayBuffer|Uint8Array|string|Blob, type?: ComponentType, otherTypeCode?: number): Name;
+    append(components: Name.Component|Name): Name;
+    appendImplicitSha256Digest(digest: Blob): Name;
+    appendParametersSha256Digest(digest: Blob): Name;
+    appendSegment(segment: number): Name;
+    appendSegmentOffset(segmentOffset: number): Name;
+    appendSequenceNumber(sequenceNumber: number): Name;
+    appendTimestamp(timestamp: number): Name;
+    appendVersion(version: number): Name;
+
+    clear(): void;
+
+    compare(other: Name): CompareResult;
+    compare(iStartComponent: number, nComponents: number, other: Name,
+            iOtherStartComponent?: number, nOtherComponents?: number): CompareResult;
+
+    equals(other: Name): boolean;
+    static fromEscapedString(uri: string): Name;
+    get(i: number): Name.Component;
+    getPrefix(nComponents: number): Name;
+    getSubName(iStartComponent: number, nComponents?: number): Name;
+    getSuccessor(): Name;
+    match(name: Name): boolean;
+    set(uri: string): void;
+    size(): number;
+    toUri(includeScheme?: boolean): string;
+
+    wireDecode(input: Blob|Buffer): void;
+    wireEncode(): Blob;
+}

types/ndn-js/network-nack.d.ts

@@ -0,0 +1,14 @@
+export namespace NetworkNack {
+    enum Reason {
+        NONE       = 0,
+        CONGESTION = 50,
+        DUPLICATE  = 100,
+        NO_ROUTE   = 150,
+        OTHER_CODE = 0x7fff,
+    }
+}
+
+export class NetworkNack {
+    getOtherReasonCode(): number;
+    getReason(): NetworkNack.Reason;
+}

types/ndn-js/signature.d.ts

@@ -0,0 +1,74 @@
+import { Blob } from "./blob";
+import { Name } from "./name";
+
+export enum KeyLocatorType {
+    KEYNAME = 1,
+    KEY_LOCATOR_DIGEST = 2,
+}
+
+export class KeyLocator {
+    constructor(kl?: KeyLocator);
+
+    getType(): KeyLocatorType;
+    getKeyName(): Name;
+    getKeyData(): Blob;
+
+    setType(type: KeyLocatorType): void;
+    setKeyName(name: Name): void;
+    setKeyData(keyData: Blob): void;
+
+    clear(): void;
+}
+
+export class ValidityPeriod {
+    constructor(validity?: ValidityPeriod);
+    constructor(notBefore: number, notAfter: number);
+
+    hasPeriod(): boolean;
+    getNotBefore(): number;
+    getNotAfter(): number;
+    isValid(time?: number): boolean;
+
+    equals(other: ValidityPeriod): boolean;
+    clear(): void;
+}
+
+export abstract class Signature {
+    clone(): Signature;
+}
+
+export class SignatureBase<T extends Signature> extends Signature {
+    constructor();
+    getSignature(): Blob;
+    setSignature(sigValue: Blob): void;
+    clone(): T;
+}
+
+export class SignatureBaseKl<T extends Signature> extends SignatureBase<T> {
+    getKeyLocator(): KeyLocator;
+    setKeyLocator(kl?: KeyLocator): void;
+}
+
+export class SignatureBaseKlVp<T extends Signature> extends SignatureBaseKl<T> {
+    getValidityPeriod(): ValidityPeriod;
+    setValidityPeriod(validity?: ValidityPeriod): void;
+}
+
+export class GenericSignature extends SignatureBase<GenericSignature> {
+    constructor();
+    getTypeCode(): number;
+    getSignatureInfoEncoding(): Blob;
+    setSignatureInfoEncoding(encoding: Blob, typeCode?: number): void;
+}
+
+export class DigestSha256Signature extends SignatureBase<DigestSha256Signature> {
+}
+
+export class Sha256WithRsaSignature extends SignatureBaseKlVp<Sha256WithRsaSignature> {
+}
+
+export class Sha256WithEcdsaSignature extends SignatureBaseKlVp<Sha256WithEcdsaSignature> {
+}
+
+export class HmacWithSha25Signature extends SignatureBaseKl<HmacWithSha25Signature> {
+}

types/ndn-js/test/blob.ts

@@ -0,0 +1,20 @@
+/// <reference types="node"/>
+import ndn = require("ndn-js");
+
+let blob = new ndn.Blob();
+blob = new ndn.Blob(blob);
+blob = new ndn.Blob(Buffer.alloc(4));
+blob = new ndn.Blob([0x08, 0x01, 0x41]);
+blob = new ndn.Blob("str");
+
+let buf: Buffer = blob.buf();
+let b: boolean = blob.equals(blob);
+b = blob.isNull();
+let n: number = blob.size();
+
+let sb = new ndn.SignedBlob();
+sb = new ndn.SignedBlob(blob, 20, 40);
+n = sb.getSignedPortionBeginOffset();
+n = sb.getSignedPortionEndOffset();
+buf = sb.signedBuf();
+n = sb.signedSize();

types/ndn-js/test/data.ts

@@ -0,0 +1,37 @@
+/// <reference types="node"/>
+import ndn = require("ndn-js");
+
+let meta = new ndn.MetaInfo();
+meta = new ndn.MetaInfo(meta);
+const ct: ndn.ContentType = meta.getType();
+let n: number = meta.getOtherTypeCode();
+n = meta.getFreshnessPeriod();
+const comp: ndn.Name.Component = meta.getFinalBlockId();
+
+meta.setType(ndn.ContentType.OTHER_CODE);
+meta.setOtherTypeCode(1000);
+meta.setFreshnessPeriod(5000);
+meta.setFinalBlockId(comp);
+
+let data = new ndn.Data();
+data = new ndn.Data(new ndn.Name("/A"));
+data = new ndn.Data("/A");
+data = new ndn.Data(data);
+
+let name: ndn.Name = data.getName();
+name = data.getFullName();
+meta = data.getMetaInfo();
+let blob: ndn.Blob = data.getContent();
+const sig: ndn.Signature = data.getSignature();
+n = data.getCongestionMark();
+n = data.getIncomingFaceId();
+
+data = data.setName(name)
+           .setMetaInfo(meta)
+           .setContent(blob)
+           .setContent(Buffer.alloc(4))
+           .setSignature(sig);
+
+data.wireDecode(blob);
+data.wireDecode(Buffer.alloc(4));
+blob = data.wireEncode();

types/ndn-js/test/face.ts

@@ -0,0 +1,47 @@
+import ndn = require("ndn-js");
+
+let filter = new ndn.InterestFilter("/A");
+filter = new ndn.InterestFilter(new ndn.Name("/A"), "<>{2}");
+filter = new ndn.InterestFilter(filter);
+
+let b: boolean = filter.doesMatch(new ndn.Name("/B"));
+const name: ndn.Name = filter.getPrefix();
+const s: string = filter.getRegexFilter();
+b = filter.hasRegexFilter();
+
+const face = new ndn.Face();
+
+let n: number = face.expressInterest(new ndn.Interest(),
+    (interest: ndn.Interest, data: ndn.Data) => {});
+face.expressInterest(new ndn.Name("/A"),
+    (interest: ndn.Interest, data: ndn.Data) => {},
+    (interest: ndn.Interest) => {});
+face.expressInterest(new ndn.Name("/A"),
+    new ndn.Interest().setCanBePrefix(true),
+    (interest: ndn.Interest, data: ndn.Data) => {},
+    (interest: ndn.Interest) => {},
+    (interest: ndn.Interest, nack: ndn.NetworkNack) => {});
+
+n = ndn.Face.getMaxNdnPacketSize();
+face.putData(new ndn.Data());
+
+n = face.registerPrefix(new ndn.Name("/A"),
+    (prefix: ndn.Name, interest: ndn.Interest) => {},
+    (prefix: ndn.Name) => {});
+face.registerPrefix(new ndn.Name("/A"),
+    (prefix: ndn.Name, interest: ndn.Interest) => {},
+    (prefix: ndn.Name) => {},
+    (prefix: ndn.Name, id: number) => {});
+
+face.removePendingInterest(n);
+face.removeRegisteredPrefix(n);
+face.send(new ndn.Blob());
+face.setCommandCertificateName(name);
+face.setCommandSigningInfo(new ndn.KeyChain(), name);
+
+n = face.setInterestFilter(filter,
+    (prefix: ndn.Name, interest: ndn.Interest, face: ndn.Face, filterId: number, filter: ndn.InterestFilter) => {});
+face.setInterestFilter(name,
+    (prefix: ndn.Name, interest: ndn.Interest) => {});
+
+face.unsetInterestFilter(n);

types/ndn-js/test/interest.ts

@@ -0,0 +1,40 @@
+/// <reference types="node"/>
+import ndn = require("ndn-js");
+
+let interest = new ndn.Interest();
+interest = new ndn.Interest(new ndn.Name("/A"));
+interest = new ndn.Interest("/A");
+interest = new ndn.Interest(interest);
+
+let name: ndn.Name = interest.getName();
+let b: boolean = interest.getCanBePrefix();
+b = interest.getMustBeFresh();
+const fh: ndn.DelegationSet = interest.getForwardingHint();
+let blob: ndn.Blob = interest.getNonce();
+let n: number = interest.getInterestLifetimeMilliseconds();
+blob = interest.getApplicationParameters();
+n = interest.getIncomingFaceId();
+
+interest = interest.setName(name)
+                   .setCanBePrefix(true)
+                   .setMustBeFresh(true)
+                   .setForwardingHint(fh)
+                   .setInterestLifetimeMilliseconds(2000)
+                   .setApplicationParameters(blob)
+                   .setApplicationParameters(Buffer.alloc(4))
+                   .appendParametersDigestToName();
+
+b = interest.matchesData(new ndn.Data());
+b = interest.matchesName(name);
+interest.refreshNonce();
+const s: string = interest.toUri();
+interest.wireDecode(blob);
+interest.wireDecode(Buffer.alloc(4));
+blob = interest.wireEncode();
+
+fh.add(10, name);
+n = fh.size();
+const del: ndn.DelegationSet.Delegation = fh.get(0);
+n = del.getPreference();
+name = del.getName();
+b = fh.remove(name);

types/ndn-js/test/key-chain.ts

@@ -0,0 +1,48 @@
+/// <reference types="node"/>
+import ndn = require("ndn-js");
+
+let kc = new ndn.KeyChain();
+kc = new ndn.KeyChain("pib-memory:", "tpm-memory:");
+
+const kp: ndn.KeyParams = ndn.KeyChain.getDefaultKeyParams();
+const pib: ndn.Pib = kc.getPib();
+const tpm: ndn.Tpm = kc.getTpm();
+
+let name = new ndn.Name("/key-name");
+
+let id: ndn.PibIdentity = kc.createIdentityV2(name);
+id = kc.createIdentityV2(name, kp);
+kc.createIdentityV2(name, (id: ndn.PibIdentity) => {});
+kc.createIdentityV2(name, (id: ndn.PibIdentity) => {}, (err) => {});
+kc.createIdentityV2(name, kp, (id: ndn.PibIdentity) => {});
+kc.createIdentityV2(name, kp, (id: ndn.PibIdentity) => {}, (err) => {});
+kc.deleteIdentity(id);
+kc.setDefaultIdentity(id);
+
+let key: ndn.PibKey = kc.createKey(id);
+key = kc.createKey(id, kp);
+kc.createKey(id, (key: ndn.PibKey) => {});
+kc.createKey(id, (key: ndn.PibKey) => {}, (err) => {});
+kc.createKey(id, kp, (key: ndn.PibKey) => {});
+kc.createKey(id, kp, (key: ndn.PibKey) => {}, (err) => {});
+kc.deleteKey(id, key);
+kc.setDefaultKey(id, key);
+
+const cert: ndn.CertificateV2 = {};
+kc.addCertificate(key, cert);
+kc.deleteCertificate(key, name);
+kc.setDefaultCertificate(key, cert);
+
+let si: ndn.SigningInfo = new ndn.SigningInfo();
+si = new ndn.SigningInfo(ndn.SigningInfo.SignerType.ID, name);
+si = new ndn.SigningInfo(si);
+si = new ndn.SigningInfo(id);
+si = new ndn.SigningInfo(key);
+si = new ndn.SigningInfo("id:/my-identity");
+const signerType: ndn.SigningInfo.SignerType = si.getSignerType();
+name = si.getSignerName();
+
+kc.sign(new ndn.Data(), si, (data: ndn.Data) => {});
+kc.sign(new ndn.Interest(), si, (interest: ndn.Interest) => {});
+kc.signWithSha256(new ndn.Data());
+kc.signWithSha256(new ndn.Interest());

types/ndn-js/test/memory-content-cache.ts

@@ -0,0 +1,15 @@
+import ndn = require("ndn-js");
+
+const face = new ndn.Face();
+let cache = new ndn.MemoryContentCache(face);
+cache = new ndn.MemoryContentCache(face, 8000);
+
+cache.add(new ndn.Data());
+const n: number = cache.getMinimumCacheLifetime();
+cache.registerPrefix(new ndn.Name("/A"),
+    () => {},
+    () => {},
+    cache.getStorePendingInterest());
+cache.setInterestFilter(new ndn.Name("/A"), cache.getStorePendingInterest());
+cache.setMinimumCacheLifetime(5000);
+cache.storePendingInterest(new ndn.Interest(), face);

types/ndn-js/test/name.ts

@@ -0,0 +1,82 @@
+/// <reference types="node"/>
+import ndn = require("ndn-js");
+
+const DIGEST = new ndn.Blob(Buffer.alloc(32));
+
+let comp = new ndn.Name.Component();
+comp = new ndn.Name.Component([0x41]);
+comp = new ndn.Name.Component(new ArrayBuffer(4), ndn.ComponentType.GENERIC);
+comp = new ndn.Name.Component(Buffer.alloc(4), ndn.ComponentType.OTHER_CODE, 1000);
+comp = new ndn.Name.Component(new Uint8Array(4));
+comp = new ndn.Name.Component("A");
+comp = new ndn.Name.Component(new ndn.Blob());
+comp = new ndn.Name.Component(comp);
+
+let n: number = comp.compare(comp);
+let b: boolean = comp.equals(comp);
+comp = ndn.Name.Component.fromImplicitSha256Digest(DIGEST);
+comp = ndn.Name.Component.fromParametersSha256Digest(DIGEST);
+n = comp.getOtherTypeCode();
+comp = comp.getSuccessor();
+const ct: ndn.ComponentType = comp.getType();
+let blob: ndn.Blob = comp.getValue();
+b = comp.isGeneric();
+b = comp.isImplicitSha256Digest();
+b = comp.isParametersSha256Digest();
+let s: string = comp.toEscapedString();
+
+comp = ndn.Name.Component.fromNumber(200);
+comp = ndn.Name.Component.fromNumber(200, ndn.ComponentType.OTHER_CODE, 1000);
+comp = ndn.Name.Component.fromNumberWithMarker(200, 0xFD);
+comp = ndn.Name.Component.fromSegment(0);
+comp = ndn.Name.Component.fromSegmentOffset(0);
+comp = ndn.Name.Component.fromSequenceNumber(1);
+comp = ndn.Name.Component.fromTimestamp(123456789);
+comp = ndn.Name.Component.fromVersion(4);
+
+b = comp.isSegment();
+b = comp.isSegmentOffset();
+b = comp.isSequenceNumber();
+b = comp.isTimestamp();
+b = comp.isVersion();
+
+n = comp.toNumber();
+n = comp.toNumberWithMarker(0xFD);
+n = comp.toSegment();
+n = comp.toSegmentOffset();
+n = comp.toSequenceNumber();
+n = comp.toTimestamp();
+n = comp.toVersion();
+
+let name = new ndn.Name();
+name = new ndn.Name([new ndn.Name.Component("A"), new Uint8Array(2)]);
+name = new ndn.Name("/A");
+name = new ndn.Name(name);
+
+name = name.append(ndn.Name.Component.fromSegment(4))
+           .append("A", ndn.ComponentType.OTHER_CODE, 1000)
+           .appendImplicitSha256Digest(DIGEST)
+           .appendParametersSha256Digest(DIGEST)
+           .appendSegment(0)
+           .appendSegmentOffset(1)
+           .appendSequenceNumber(4)
+           .appendTimestamp(3)
+           .appendVersion(2);
+
+name.clear();
+n = name.compare(name);
+n = name.compare(0, 2, name, 1, 3);
+b = name.equals(name);
+name = ndn.Name.fromEscapedString(s);
+comp = name.get(2);
+name = name.getPrefix(3);
+name = name.getSubName(1).getSubName(1, 4);
+name = name.getSuccessor();
+b = name.match(name);
+name.set("/B");
+n = name.size();
+s = name.toUri();
+s = name.toUri(true);
+name.wireDecode(blob);
+name.wireDecode(Buffer.alloc(4));
+blob = name.wireEncode();

types/ndn-js/test/network-nack.ts

@@ -0,0 +1,6 @@
+import ndn = require("ndn-js");
+
+(nack: ndn.NetworkNack) => {
+    const n: number = nack.getOtherReasonCode();
+    const reason: ndn.NetworkNack.Reason = nack.getReason();
+};

types/ndn-js/test/signature.ts

@@ -0,0 +1,66 @@
+import ndn = require("ndn-js");
+
+let kl: ndn.KeyLocator = new ndn.KeyLocator();
+kl = new ndn.KeyLocator(kl);
+const klt: ndn.KeyLocatorType = kl.getType();
+const name: ndn.Name = kl.getKeyName();
+let blob: ndn.Blob = kl.getKeyData();
+kl.setType(ndn.KeyLocatorType.KEY_LOCATOR_DIGEST);
+kl.setKeyName(name);
+kl.setKeyData(blob);
+kl.clear();
+
+let validity: ndn.ValidityPeriod = new ndn.ValidityPeriod();
+validity = new ndn.ValidityPeriod(validity);
+validity = new ndn.ValidityPeriod(540109800000, 664156800000);
+let b: boolean = validity.hasPeriod();
+let n: number = validity.getNotBefore();
+n = validity.getNotAfter();
+b = validity.isValid();
+b = validity.isValid(594172800000);
+validity.equals(new ndn.ValidityPeriod());
+validity.clear();
+
+let sigG = new ndn.GenericSignature();
+blob = sigG.getSignature();
+blob = sigG.getSignatureInfoEncoding();
+n = sigG.getTypeCode();
+sigG.setSignature(blob);
+sigG.setSignatureInfoEncoding(blob);
+sigG.setSignatureInfoEncoding(blob, 1000);
+sigG = sigG.clone();
+let sig: ndn.Signature = sigG;
+
+let sig0 = new ndn.DigestSha256Signature();
+blob = sig0.getSignature();
+sig0.setSignature(blob);
+sig0 = sig0.clone();
+sig = sig0;
+
+let sig1 = new ndn.Sha256WithRsaSignature();
+kl = sig1.getKeyLocator();
+blob = sig1.getSignature();
+validity = sig1.getValidityPeriod();
+sig1.setKeyLocator(kl);
+sig1.setSignature(blob);
+sig1.setValidityPeriod(validity);
+sig1 = sig1.clone();
+sig = sig1;
+
+let sig3 = new ndn.Sha256WithEcdsaSignature();
+kl = sig3.getKeyLocator();
+blob = sig3.getSignature();
+validity = sig3.getValidityPeriod();
+sig3.setKeyLocator(kl);
+sig3.setSignature(blob);
+sig3.setValidityPeriod(validity);
+sig3 = sig3.clone();
+sig = sig3;
+
+let sig4 = new ndn.HmacWithSha25Signature();
+kl = sig4.getKeyLocator();
+blob = sig4.getSignature();
+sig4.setKeyLocator(kl);
+sig4.setSignature(blob);
+sig4 = sig4.clone();
+sig = sig4;

types/ndn-js/test/transport.ts

@@ -0,0 +1,14 @@
+import ndn = require("ndn-js");
+
+const transport = new ndn.TcpTransport();
+const b: boolean = transport.isLocal();
+
+let face = new ndn.Face(transport, new ndn.TcpTransport.ConnectionInfo("hobo.cs.arizona.edu", 9696));
+face = new ndn.Face(new ndn.UnixTransport(), new ndn.UnixTransport.ConnectionInfo("/run/nfd.sock"));
+face = new ndn.Face(new ndn.WebSocketTransport(), new ndn.WebSocketTransport.ConnectionInfo("hobo.cs.arizona.edu", 9696));
+
+face = new ndn.Face({host: 'hobo.cs.arizona.edu', port: 6363});
+face = new ndn.Face({getTransport: () => new ndn.UnixTransport(),
+                     getConnectionInfo: () => new ndn.UnixTransport.ConnectionInfo("/run/nfd.sock")});
+face = new ndn.Face({getTransport: () => new ndn.UnixTransport(),
+                     connectionInfo: new ndn.UnixTransport.ConnectionInfo("/run/nfd.sock")});

types/ndn-js/transport.d.ts

@@ -0,0 +1,40 @@
+export abstract class TransportConnectionInfo {
+}
+
+export abstract class Transport {
+    static ConnectionInfo: TransportConnectionInfo;
+    isLocal(): boolean;
+}
+
+export class TcpTransport extends Transport {
+}
+
+export namespace TcpTransport {
+    class ConnectionInfo extends TransportConnectionInfo {
+        constructor(host: string, port: number);
+        equals(other: ConnectionInfo): boolean;
+        toString(): string;
+    }
+}
+
+export class UnixTransport extends Transport {
+}
+
+export namespace UnixTransport {
+    class ConnectionInfo extends TransportConnectionInfo {
+        constructor(filePath: string);
+        equals(other: ConnectionInfo): boolean;
+        toString(): string;
+    }
+}
+
+export class WebSocketTransport extends Transport {
+}
+
+export namespace WebSocketTransport {
+    class ConnectionInfo extends TransportConnectionInfo {
+        constructor(hostOrUri: string, port?: number);
+        equals(other: ConnectionInfo): boolean;
+        toString(): string;
+    }
+}

types/ndn-js/tsconfig.json

@@ -0,0 +1,32 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictFunctionTypes": true,
+        "strictNullChecks": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "test/blob.ts",
+        "test/data.ts",
+        "test/face.ts",
+        "test/interest.ts",
+        "test/key-chain.ts",
+        "test/memory-content-cache.ts",
+        "test/name.ts",
+        "test/network-nack.ts",
+        "test/signature.ts",
+        "test/transport.ts"
+    ]
+}

types/ndn-js/tslint.json

@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }