Started Adding Type Definitions

Covered All Externals I think. First time writing Type Definitions so
anyone else feel free to take over and do a better job.

Author: TimothyMischief

package.json

@@ -65,6 +65,7 @@
     "vinyl-source-stream": "^1.1.0"
   },
   "dependencies": {
+    "@types/node": "^6.0.54",
     "babel-runtime": "^6.18.0"
   }
 }

src/index.d.ts

@@ -0,0 +1,3 @@
+import * as v1 from "./v1/index";
+export { v1 }
+export default v1;

src/v1/driver.d.ts

@@ -0,0 +1,61 @@
+import { Promise } from "core-js";
+
+import Session from "./session";
+import Pool from "./internal/pool";
+import Integer from "./integer";
+import { connect, Connection } from "./internal/connector";
+import StreamObserver from "./internal/stream-observer";
+import { newError, SERVICE_UNAVAILABLE } from "./error";
+
+interface AuthCredentials {
+  scheme: string;
+  principal: string;
+  credentials: string;
+  realm?: string;
+  parameters?: {[key: string]: any};
+}
+
+interface ConfigurationOptions {
+  encrypted?: string;
+  trust?: string;
+  trustedCertificates?: any[];
+  knownHosts?: string;
+}
+
+declare type READ = "READ";
+declare type WRITE = "WRITE";
+
+declare class Driver {
+  constructor(url: string,
+    userAgent: string,
+    token: AuthCredentials,
+    config: ConfigurationOptions)
+
+  _createConnection( url: string,
+    release: ( url: string, conn: Connection ) => void
+  ): Connection;
+
+  static _validateConnection( conn: Connection ): Boolean
+
+  _destroyConnection( conn: Connection ): void;
+
+  session( mode: string ): Session;
+
+  _acquireConnection( mode: string ): Promise<Connection>;
+
+  _createSession(connectionPromise: Promise<Connection>, cb: Function): Session;
+
+  close(): void;
+}
+
+declare class _ConnectionStreamObserver extends StreamObserver {
+  constructor( driver: Driver, conn: Connection )
+
+  onError( error: Error ): void;
+
+  onCompleted( message: any ): void;
+}
+
+export { Driver, READ, WRITE, AuthCredentials, ConfigurationOptions }
+
+export default Driver;

src/v1/error.d.ts

@@ -0,0 +1,15 @@
+type SERVICE_UNAVAILABLE = "ServiceUnavailable";
+type SESSION_EXPIRED = "SessionExpired";
+
+declare function newError( message: any, code: string ): Neo4jError;
+
+declare class Neo4jError extends Error {
+  constructor( message: any, code: string )
+}
+
+export {
+  newError,
+  Neo4jError,
+  SERVICE_UNAVAILABLE,
+  SESSION_EXPIRED,
+}

src/v1/graph-types.d.ts

@@ -0,0 +1,62 @@
+declare class Node {
+  constructor(identity: string,
+    labels: string[],
+    properties: Object
+  )
+
+  toString(): string;
+}
+
+declare class Relationship {
+  identity: string;
+  start: string;
+  end: string;
+  type: string;
+  properties: Object;
+
+  constructor(identity: string,
+    start: string,
+    end: string,
+    type: string,
+    properties: Object)
+
+  toString(): string;
+}
+
+declare class UnboundRelationship {
+  identity: string;
+  type: string;
+  properties: Object;
+
+  constructor(identity: string,
+    type: string,
+    properties: Object)
+
+  bind( start: string, end: string ): Relationship;
+
+  toString(): string;
+}
+
+declare class PathSegment {
+  start: string;
+  rel: Relationship;
+  end: string;
+
+  constructor(start: string,
+    rel: Relationship,
+    end: string)
+}
+
+declare class Path {
+  start: Node;
+  end: Node;
+  segments: PathSegment[];
+}
+
+export {
+  Node,
+  Relationship,
+  UnboundRelationship,
+  Path,
+  PathSegment
+}

src/v1/index.d.ts

@@ -0,0 +1,83 @@
+import {int, isInt, inSafeRange, toNumber, toString} from "./integer";
+import {Node, Relationship, UnboundRelationship, PathSegment, Path} from "./graph-types";
+import {Neo4jError, SERVICE_UNAVAILABLE, SESSION_EXPIRED} from "./error";
+import Result from "./result";
+import ResultSummary from "./result-summary";
+import Record from "./record";
+import {Driver, READ, WRITE, AuthCredentials, ConfigurationOptions} from "./driver";
+import RoutingDriver from "./routing-driver";
+import VERSION from "../version";
+import {parseScheme, parseUrl} from "./internal/connector";
+
+declare type auth = {
+  basic: (username: string,
+    password: string,
+    realm?: string ) => AuthCredentials,
+  custom: ( principal: string,
+    credentials: string,
+    realm: string,
+    scheme: string,
+    parameters?: {[key: string]: any} ) => AuthCredentials,
+};
+
+declare type USER_AGENT= string;
+
+declare function driver(url: string,
+  authToken: AuthCredentials,
+  config: ConfigurationOptions ): Driver;
+
+declare type types = {
+  Node,
+  Relationship,
+  UnboundRelationship,
+  PathSegment,
+  Path,
+  Result,
+  ResultSummary,
+  Record
+  };
+
+declare type session = {
+  READ,
+  WRITE
+};
+
+declare type error = {
+  SERVICE_UNAVAILABLE,
+  SESSION_EXPIRED
+};
+declare type integer = {
+  toNumber,
+  toString,
+  inSafeRange
+};
+
+declare type forExport = {
+  driver,
+  int,
+  isInt,
+  integer,
+  Neo4jError,
+  auth,
+  types,
+  session,
+  error,
+  AuthCredentials,
+  ConfigurationOptions,
+};
+
+export {
+  driver,
+  int,
+  isInt,
+  integer,
+  Neo4jError,
+  auth,
+  types,
+  session,
+  error,
+  AuthCredentials,
+  ConfigurationOptions,
+}
+
+export default forExport;

src/v1/index.js

@@ -187,6 +187,6 @@ export {
   auth,
   types,
   session,
-  error
+  error,
 }
 export default forExport

src/v1/integer.d.ts

@@ -0,0 +1,116 @@
+import { newError } from "./error";
+
+declare class Integer {
+  low: number;
+  high: number;
+
+  constructor( low: number, high: number )
+
+  inSafeRange(): boolean;
+
+  toInt(): number;
+
+  toNumber(): number;
+
+  toString(): string;
+
+  getHighBits(): number;
+
+  getLowBits(): number;
+
+  getNumBitsAbs(): number;
+
+  isZero(): boolean;
+
+  isNegative(): boolean;
+
+  isPositive(): boolean;
+
+  isOdd(): boolean;
+
+  isEven(): boolean;
+
+  equals( other: Integer | number | string ): boolean;
+
+  notEquals( other: Integer | number | string ): boolean;
+
+  lessThan( other: Integer | number | string ): boolean;
+
+  lessThanOrEqual( other: Integer | number | string ): boolean;
+
+  greaterThan( other: Integer | number | string ): boolean;
+
+  greaterThanOrEqual( other: Integer | number | string ): boolean;
+
+  compare( other: Integer | number | string ): number;
+
+  negate(): Integer;
+
+  add( addend: Integer | number | string ): Integer;
+
+  subtract( subtrahend: Integer | number | string ): Integer;
+
+  multiply( multiplier: Integer | number | string ): Integer;
+
+  div( divisor: Integer | number | string ): Integer;
+
+  modulo( divisor: Integer | number | string ): Integer;
+
+  not(): Integer;
+
+  and( other: Integer | number | string ): Integer;
+
+  or( other: Integer | number | string ): Integer;
+
+  xor( other: Integer | number | string ): Integer;
+
+  shiftLeft( numBits: Integer | number ): Integer;
+
+  shiftRight( numBits: Integer | number ): Integer;
+
+  static __isInteger__: true;
+
+  static isInteger(obj: Object): boolean;
+
+  static fromInt(value: number): Integer;
+  static fromNumber(value: number): Integer;
+  static fromBits(lowBits: number, highBits: number): Integer;
+  static fromString(str: string, radix?: number): Integer;
+  static fromValue(val: Integer | number | string | {low: number, high: number}): Integer;
+  static toNumber(val: Integer | number | string | {low: number, high: number}): number;
+  static toString(val: Integer | number | string | {low: number, high: number}, radix?: number): Integer;
+  static inSafeRange(val: Integer | number | string | {low: number, high: number}): boolean;
+
+  static ZERO: Integer;
+  static ONE: Integer;
+  static NEG_ONE: Integer;
+  static MAX_VALUE: Integer;
+  static MIN_VALUE: Integer;
+  static MIN_SAFE_VALUE: Integer;
+  static MAX_SAFE_VALUE: Integer;
+}
+
+declare function int(val: Integer | number | string | {low: number, high: number}): Integer;
+declare function isInt(obj: Object): boolean;
+declare function inSafeRange(val: Integer | number | string | {low: number, high: number}): boolean;
+declare function toNumber(val: Integer | number | string | {low: number, high: number}): number;
+declare function toString(val: Integer | number | string | {low: number, high: number}, radix?: number): Integer;
+
+declare type TWO_PWR_16_DBL = number;
+declare type TWO_PWR_24_DBL = number;
+declare type TWO_PWR_32_DBL = number;
+declare type TWO_PWR_64_DBL = number;
+declare type TWO_PWR_63_DBL = number;
+declare type TWO_PWR_24 = Integer;
+
+declare type INT_CACHE = Object;
+
+export {
+  int,
+  isInt,
+  inSafeRange,
+  toNumber,
+  toString
+}
+
+export default Integer;