Merge pull request #24750 from ClearBlade/clearbladejs

Added type definitions for clearbladejs-client, clearbladejs-server, clearbladejs-node

types/clearbladejs-client/clearbladejs-client-tests.ts

@@ -0,0 +1,193 @@
+// Testing type definitions for clearbladejs-client 1.0
+// Project: https://github.com/ClearBlade/JavaScript-API
+// Definitions by: Jim Bouquet <https://github.com/ClearBlade>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+let genericCallback = (error: boolean, response: Resp) => {};
+
+///////////////////////////////////////
+// ClearBlade object API invocations
+///////////////////////////////////////
+ClearBlade.init({
+    systemKey: "abcdef",
+    systemSecret: "abcdefg",
+    callback: genericCallback
+});
+
+ClearBlade.setUser("test@test.com", "password");
+ClearBlade.registerUser("test@test.com", "password", genericCallback);
+ClearBlade.isCurrentUserAuthenticated(genericCallback);
+ClearBlade.logoutUser(genericCallback);
+ClearBlade.loginAnon(genericCallback);
+ClearBlade.loginUser("test@test.com", "password", genericCallback);
+ClearBlade.loginUserMqtt("test@test.com", "password", genericCallback);
+ClearBlade.sendPush(["user1", "user2"], {data: "Test"}, "appId: string", genericCallback);
+ClearBlade.getAllCollections(genericCallback);
+
+let coll1 = ClearBlade.Collection("collectionID");
+let coll2 = ClearBlade.Collection({ collectionName: "collectionName" });
+let coll3 = ClearBlade.Collection({ collectionID: "collectionID" });
+
+let query1 = ClearBlade.Query("collectionID");
+let query2 = ClearBlade.Query({ offset: 5, limit: 5, collectionID: "collectionID" });
+let query3 = ClearBlade.Query({ collectionName: "collectionName" });
+
+let item1 = ClearBlade.Item({}, "collectionID");
+let item2 = ClearBlade.Item({}, { collectionID: "collectionID" });
+
+let code = ClearBlade.Code();
+let user = ClearBlade.User();
+
+let messaging = ClearBlade.Messaging({}, genericCallback);
+let stats = ClearBlade.MessagingStats();
+
+let edge = ClearBlade.Edge();
+let metrics = ClearBlade.Metrics();
+let device = ClearBlade.Device();
+let analytics = ClearBlade.Analytics();
+let portal = ClearBlade.Portal("MyPortal");
+let triggers = ClearBlade.Triggers();
+
+ClearBlade.getEdges(query1.query, genericCallback);
+
+///////////////////////////////////////
+// Collection API invocations
+///////////////////////////////////////
+coll1.fetch(query1.query, genericCallback);
+coll1.create(ClearBlade.Item({}, ""), genericCallback);
+coll1.update(query1.query, {}, genericCallback);
+coll1.remove(query1.query, genericCallback);
+coll1.columns(genericCallback);
+coll1.count(query1.query, genericCallback);
+
+///////////////////////////////////////
+// Query API invocations
+///////////////////////////////////////
+query1.addSortToQuery(
+    query1,
+    QuerySortDirections.QUERY_SORT_ASCENDING,
+    "column1"
+);
+query1.addFilterToQuery(
+    query1,
+    QueryConditions.QUERY_GREATERTHAN,
+    "key",
+    "value"
+);
+query1.ascending("string");
+query1.descending("string");
+query1.equalTo("string", "string");
+query1.greaterThan("string", 2);
+query1.greaterThanEqualTo("string", false);
+query1.lessThan("string", "string");
+query1.lessThanEqualTo("string", "string");
+query1.notEqualTo("string", "string");
+query1.matches("string", new RegExp(/.*/));
+query1.or(query2);
+query1.setPage(1, 1);
+query1.fetch(genericCallback);
+query1.update({}, genericCallback);
+query1.columns([]);
+query1.remove(genericCallback);
+
+///////////////////////////////////////
+// Item API invocations
+///////////////////////////////////////
+item1.save(genericCallback);
+item1.refresh(genericCallback);
+item1.destroy(genericCallback);
+
+///////////////////////////////////////
+// Code API invocations
+///////////////////////////////////////
+code.create("codeName", "body: string", genericCallback);
+code.update("codeName", "body: string", genericCallback);
+code.delete("codeName", genericCallback);
+code.execute("codeName", {}, genericCallback);
+code.getCompletedServices(genericCallback);
+code.getFailedServices(genericCallback);
+code.getAllServices(genericCallback);
+
+///////////////////////////////////////
+// User API invocations
+///////////////////////////////////////
+user.getUser(genericCallback);
+user.setUser({}, genericCallback);
+user.allUsers(query1.query, genericCallback);
+user.setPassword("old_password", "new_password", genericCallback);
+user.count(query1.query, genericCallback);
+
+///////////////////////////////////////
+// Messaging API invocations
+///////////////////////////////////////
+messaging.getMessageHistoryWithTimeFrame("topic", 5, 10, 15, 20, genericCallback);
+messaging.getMessageHistory("topic", 5, 15, genericCallback);
+messaging.getAndDeleteMessageHistory("topic", 5, 10, 1, 20, genericCallback);
+messaging.currentTopics(genericCallback);
+messaging.publish("topic", {});
+messaging.publishREST("topic", { payload: Object }, genericCallback);
+let mcb = (message: string) => {};
+messaging.subscribe("topic", {}, mcb);
+messaging.unsubscribe("topic", {});
+messaging.disconnect();
+
+///////////////////////////////////////
+// MessagingStats API invocations
+///////////////////////////////////////
+stats.getAveragePayloadSize("topic: string", 5, 5, genericCallback);
+stats.getOpenConnections(genericCallback);
+stats.getCurrentSubscribers("topic: string", genericCallback);
+
+///////////////////////////////////////
+// Edge API invocations
+///////////////////////////////////////
+edge.updateEdgeByName("edgename", {changedColumn: "New value"}, genericCallback);
+edge.deleteEdgeByName("edgename", genericCallback);
+edge.create({newEdge: Object}, "edgename", genericCallback);
+edge.columns(genericCallback);
+edge.count(query1.query, genericCallback);
+
+///////////////////////////////////////
+// Metrics API invocations
+///////////////////////////////////////
+metrics.setQuery(query1.query);
+metrics.getStatistics(genericCallback);
+metrics.getStatisticsHistory(genericCallback);
+metrics.getDBConnections(genericCallback);
+metrics.getLogs(genericCallback);
+
+///////////////////////////////////////
+// Device API invocations
+///////////////////////////////////////
+device.getDeviceByName("devicename", genericCallback);
+device.updateDeviceByName("devicename", { object: Object }, true, genericCallback);
+device.deleteDeviceByName("devicename", genericCallback);
+device.fetch(query1.query, genericCallback);
+device.update(query1.query, { object: Object }, false, genericCallback);
+device.delete(query1.query, genericCallback);
+device.create({ newDevice: Object }, genericCallback);
+device.columns(genericCallback);
+device.count(query1.query, genericCallback);
+
+///////////////////////////////////////
+// Analytics API invocations
+///////////////////////////////////////
+analytics.getStorage({}, genericCallback);
+analytics.getCount({}, genericCallback);
+analytics.getEventList({}, genericCallback);
+analytics.getEventTotals({}, genericCallback);
+analytics.getUserEvents({}, genericCallback);
+
+///////////////////////////////////////
+// Portal API invocations
+///////////////////////////////////////
+portal.fetch(genericCallback);
+portal.update({data: Object}, genericCallback);
+
+///////////////////////////////////////
+// Triggers API invocations
+///////////////////////////////////////
+triggers.fetchDefinitions(genericCallback);
+triggers.create("triggername", {data: Object}, genericCallback);
+triggers.update("triggername", {data: Object}, genericCallback);
+triggers.delete("triggername", genericCallback);

types/clearbladejs-client/global.d.ts

@@ -0,0 +1,5 @@
+declare global {
+    var ClearBlade: ClearBladeGlobal;
+}
+
+export {};

types/clearbladejs-client/index.d.ts

@@ -0,0 +1,436 @@
+// Type definitions for clearbladejs-client 1.0
+// Project: https://github.com/ClearBlade/JavaScript-API
+// Definitions by: Jim Bouquet <https://github.com/ClearBlade>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.4
+
+/// <reference types="paho-mqtt" />
+
+interface Resp {
+    error(msg: any): never; // todo: figure out if we can have the compiler throw an error if someone adds code after this
+    success(msg: any): never;
+}
+
+declare enum MessagingQOS {
+    MESSAGING_QOS_AT_MOST_ONCE = 0,
+    MESSAGING_QOS_AT_LEAST_ONCE = 1,
+    MESSAGING_QOS_EXACTLY_ONCE = 2
+}
+
+interface InitOptions {
+    systemKey: string;
+    systemSecret: string;
+    masterSecret?: string;
+    logging?: boolean;
+    callback?: CbCallback;
+    email?: string;
+    password?: string;
+    registerUser?: boolean;
+    useUser?: APIUser;
+    URI?: string;
+    messagingURI?: string;
+    messagingPort?: number;
+    defaultQoS?: MessagingQOS;
+    callTimeout?: number;
+    messagingAuthPort?: number;
+}
+
+interface RequestOptions {
+    method?: string;
+    endpoint?: string;
+    body?: string;
+    qs?: string;
+    URI?: string;
+    useUser?: boolean;
+    authToken?: string;
+    timeout?: number;
+    user?: APIUser;
+}
+
+interface APIUser {
+    email: string;
+    authToken: string;
+}
+
+type CbCallback = (error: boolean, response: Resp) => void;
+
+interface ClearBladeGlobal extends ClearBladeInt {
+    MESSAGING_QOS_AT_MOST_ONCE: MessagingQOS.MESSAGING_QOS_AT_MOST_ONCE;
+    MESSAGING_QOS_AT_LEAST_ONCE: MessagingQOS.MESSAGING_QOS_AT_LEAST_ONCE;
+    MESSAGING_QOS_EXACTLY_ONCE: MessagingQOS.MESSAGING_QOS_EXACTLY_ONCE;
+
+    request(options: RequestOptions, callback: CbCallback): void;
+}
+
+interface ClearBladeInt {
+    systemKey: string;
+    systemSecret: string;
+    masterSecret: string;
+    URI: string;
+    messagingURI: string;
+    messagingPort: number;
+    logging: boolean;
+    defaultQoS: MessagingQOS;
+
+    init(options: InitOptions): void;
+    setUser(email: string, password: string): void;
+    registerUser(email: string, password: string, callback: CbCallback): void;
+    isCurrentUserAuthenticated(callback: CbCallback): void;
+    logoutUser(callback: CbCallback): void;
+    loginAnon(callback: CbCallback): void;
+    loginUser(email: string, password: string, callback: CbCallback): void;
+    loginUserMqtt(email: string, password: string, callback: CbCallback): void;
+    registerMasterCallback(callback: CbCallback): void;
+    Collection(options: string | CollectionOptionsWithName | CollectionOptionsWithID): Collection;
+    Query(
+        options: string | QueryOptionsWithName | QueryOptionsWithID
+    ): QueryObj;
+    Item(data: object, collectionID: string | ItemOptions): Item;
+    Code(): Code;
+    User(): AppUser;
+    Messaging(options: MessagingOptions, callback: CbCallback): Messaging;
+    MessagingStats(): MessagingStats;
+    sendPush(
+        users: string[],
+        payload: object,
+        appId: string,
+        callback: CbCallback
+    ): void;
+    getEdges(query: Query, callback: CbCallback): void;
+    Edge(): Edge;
+    Metrics(): Metrics;
+    Device(): Device;
+    Analytics(): Analytics;
+    Portal(name: string): Portal;
+    Triggers(): Triggers;
+
+    getAllCollections(callback: CbCallback): void;
+}
+interface CollectionOptionsWithName {
+    collectionName: string;
+}
+
+interface CollectionOptionsWithID {
+    collectionID: string;
+}
+
+interface Collection {
+    name: string;
+    endpoint: string;
+    isUsingCollectionName: boolean;
+    user: APIUser;
+    URI: string;
+    systemKey: string;
+    systemSecret: string;
+
+    fetch(query: Query, callback: CbCallback): void;
+    create(newItem: Item, callback: CbCallback): void;
+    update(query: Query, changes: object, callback: CbCallback): void;
+    remove(query: Query, callback: CbCallback): void;
+    columns(callback: CbCallback): void;
+    count(query: Query, callback: CbCallback): void;
+}
+
+declare enum QuerySortDirections {
+    QUERY_SORT_ASCENDING = "ASC",
+    QUERY_SORT_DESCENDING = "DESC"
+}
+
+declare enum QueryConditions {
+    QUERY_EQUAL = "EQ",
+    QUERY_NOTEQUAL = "NEQ",
+    QUERY_GREATERTHAN = "GT",
+    QUERY_GREATERTHAN_EQUAL = "GTE",
+    QUERY_LESSTHAN = "LT",
+    QUERY_LESSTHAN_EQUAL = "LTE",
+    QUERY_MATCHES = "RE"
+}
+
+type QueryValue = string | number | boolean;
+
+interface QueryOptions {
+    offset?: number;
+    limit?: number;
+}
+
+interface QueryOptionsWithName
+    extends CollectionOptionsWithName,
+        QueryOptions {}
+interface QueryOptionsWithID extends CollectionOptionsWithID, QueryOptions {}
+
+interface Query {
+    SELECTCOLUMNS?: string[];
+    SORT?: QuerySortDirections;
+    FILTERS?: QueryFilter[];
+    PAGESIZE?: number;
+    PAGENUM?: number;
+}
+
+interface QueryFilter {
+    [QueryConditions: string]: QueryFilterValue;
+}
+
+interface QueryFilterValue {
+    [name: string]: QueryValue;
+}
+
+interface QueryObj {
+    endpoint: string;
+    user: APIUser;
+    URI: string;
+    systemKey: string;
+    systemSecret: string;
+    query: Query;
+    OR: Query[];
+    offset: number;
+    limit: number;
+
+    addSortToQuery(
+        query: QueryObj,
+        direction: QuerySortDirections,
+        column: string
+    ): void;
+    addFilterToQuery(
+        query: QueryObj,
+        condition: QueryConditions,
+        key: string,
+        value: QueryValue
+    ): void;
+    ascending(field: string): void;
+    descending(field: string): void;
+    equalTo(field: string, value: QueryValue): void;
+    greaterThan(field: string, value: QueryValue): void;
+    greaterThanEqualTo(field: string, value: QueryValue): void;
+    lessThan(field: string, value: QueryValue): void;
+    lessThanEqualTo(field: string, value: QueryValue): void;
+    notEqualTo(field: string, value: QueryValue): void;
+    matches(field: string, pattern: RegExp): void;
+    or(query: QueryObj): void;
+    setPage(pageSize: number, pageNum: number): void;
+    fetch(callback: CbCallback): void;
+    update(changes: object, callback: CbCallback): void;
+    columns(columnsArray: string[]): void;
+    remove(callback: CbCallback): void;
+}
+
+interface ItemOptions extends CollectionOptionsWithID {}
+
+interface Item {
+    data: object;
+
+    save(callback: CbCallback): void;
+    refresh(callback: CbCallback): void;
+    destroy(callback: CbCallback): void;
+}
+
+interface Code {
+    user: APIUser;
+    URI: string;
+    systemKey: string;
+    systemSecret: string;
+    callTimeout: number;
+
+    create(name: string, body: string, callback: CbCallback): void;
+    update(name: string, body: string, callback: CbCallback): void;
+    delete(name: string, callback: CbCallback): void;
+    execute(name: string, params: object, callback: CbCallback): void;
+    getCompletedServices(callback: CbCallback): void;
+    getFailedServices(callback: CbCallback): void;
+    getAllServices(callback: CbCallback): void;
+}
+
+interface AppUser {
+    user: APIUser;
+    URI: string;
+    endpoint: string;
+    systemKey: string;
+    systemSecret: string;
+    callTimeout: number;
+
+    getUser(callback: CbCallback): void;
+    setUser(data: object, callback: CbCallback): void;
+    allUsers(query: Query, callback: CbCallback): void;
+    setPassword(
+        old_password: string,
+        new_password: string,
+        callback: CbCallback
+    ): void;
+    count(query: Query, callback: CbCallback): void;
+}
+
+interface Messaging {
+    user: APIUser;
+    URI: string;
+    endpoint: string;
+    systemKey: string;
+    systemSecret: string;
+    callTimeout: number;
+    client: Paho.MQTT.Client;
+
+    getMessageHistoryWithTimeFrame(
+        topic: string,
+        count: number,
+        last: number,
+        start: number,
+        stop: number,
+        callback: CbCallback
+    ): void;
+    getMessageHistory(
+        topic: string,
+        last: number,
+        count: number,
+        callback: CbCallback
+    ): void;
+    getAndDeleteMessageHistory(
+        topic: string,
+        count: number,
+        last: number,
+        start: number,
+        stop: number,
+        callback: CbCallback
+    ): void;
+    currentTopics(callback: CbCallback): void;
+    publish(topic: string, payload: object): void;
+    publishREST(topic: string, payload: object, callback: CbCallback): void;
+    subscribe(
+        topic: string,
+        options: MessagingSubscribeOptions,
+        messageCallback: MessageCallback
+    ): void;
+    unsubscribe(topic: string, options: MessagingSubscribeOptions): void;
+    disconnect(): void;
+}
+
+interface CommonMessagingProperties {
+    cleanSession?: boolean;
+    useSSL?: boolean;
+    hosts?: string;
+    ports?: string;
+    onSuccess?: Function;
+    onFailure?: Function;
+}
+
+interface MessagingOptions extends CommonMessagingProperties {
+    qos?: MessagingQOS;
+}
+
+interface MessagingConfiguration extends CommonMessagingProperties {
+    userName: string;
+    password: string;
+}
+
+type MessageCallback = (message: string) => void;
+
+interface MessagingSubscribeOptions {
+    qos?: MessagingQOS;
+    invocationContext?: object;
+    onSuccess?: Function;
+    onFailure?: Function;
+    timeout?: number;
+}
+
+interface MessagingStats {
+    user: APIUser;
+    URI: string;
+    endpoint: string;
+    systemKey: string;
+
+    getAveragePayloadSize(
+        topic: string,
+        start: number,
+        stop: number,
+        callback: CbCallback
+    ): void;
+    getOpenConnections(callback: CbCallback): void;
+    getCurrentSubscribers(topic: string, callback: CbCallback): void;
+}
+
+interface Edge {
+    user: APIUser;
+    URI: string;
+    systemKey: string;
+    systemSecret: string;
+
+    updateEdgeByName(name: string, object: object, callback: CbCallback): void;
+    deleteEdgeByName(name: string, callback: CbCallback): void;
+    create(newEdge: object, name: string, callback: CbCallback): void;
+    columns(callback: CbCallback): void;
+    count(query: Query, callback: CbCallback): void;
+}
+
+interface Metrics {
+    user: APIUser;
+    URI: string;
+    systemKey: string;
+
+    setQuery(query: Query): void;
+    getStatistics(callback: CbCallback): void;
+    getStatisticsHistory(callback: CbCallback): void;
+    getDBConnections(callback: CbCallback): void;
+    getLogs(callback: CbCallback): void;
+}
+
+interface Device {
+    user: APIUser;
+    URI: string;
+    systemKey: string;
+    systemSecret: string;
+
+    getDeviceByName(name: string, callback: CbCallback): void;
+    updateDeviceByName(
+        name: string,
+        object: object,
+        trigger: boolean,
+        callback: CbCallback
+    ): void;
+    deleteDeviceByName(name: string, callback: CbCallback): void;
+    fetch(query: Query, callback: CbCallback): void;
+    update(
+        query: Query,
+        object: object,
+        trigger: boolean,
+        callback: CbCallback
+    ): void;
+    delete(query: Query, callback: CbCallback): void;
+    create(newDevice: object, callback: CbCallback): void;
+    columns(callback: CbCallback): void;
+    count(query: Query, callback: CbCallback): void;
+}
+
+interface Analytics {
+    user: APIUser;
+    URI: string;
+    systemKey: string;
+    systemSecret: string;
+
+    getStorage(filter: QueryFilter, callback: CbCallback): void;
+    getCount(filter: QueryFilter, callback: CbCallback): void;
+    getEventList(filter: QueryFilter, callback: CbCallback): void;
+    getEventTotals(filter: QueryFilter, callback: CbCallback): void;
+    getUserEvents(filter: QueryFilter, callback: CbCallback): void;
+}
+
+interface Portal {
+    name: string;
+    user: APIUser;
+    URI: string;
+    systemKey: string;
+    systemSecret: string;
+
+    fetch(callback: CbCallback): void;
+    update(data: object, callback: CbCallback): void;
+}
+
+interface Triggers {
+    user: APIUser;
+    URI: string;
+    systemKey: string;
+    systemSecret: string;
+
+    fetchDefinitions(callback: CbCallback): void;
+    create(name: string, data: object, callback: CbCallback): void;
+    update(name: string, data: object, callback: CbCallback): void;
+    delete(name: string, callback: CbCallback): void;
+}
+
+declare var ClearBlade: ClearBladeGlobal;

types/clearbladejs-client/tsconfig.json

@@ -0,0 +1,29 @@
+{
+    "compilerOptions": {
+        "target": "ES5",
+        "module": "commonjs",
+        "lib": [
+            "es6"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "clearbladejs-client-tests.ts",
+        "global.d.ts"
+    ],
+    "exclude": [
+        "**/clearbladejs-node/*",
+        "**/clearbladejs-server/*"
+    ]
+}

types/clearbladejs-client/tslint.json

@@ -0,0 +1,7 @@
+{
+    "extends": "dtslint/dt.json",
+    "rules": {
+        "ban-types": false,
+        "no-empty-interface": false
+    }
+}

types/clearbladejs-node/clearbladejs-node-tests.ts

@@ -0,0 +1,124 @@
+// Testing type definitions for clearbladejs-node 1.0
+// Project: https://github.com/ClearBlade/Node-SDK
+// Definitions by: Jim Bouquet <https://github.com/ClearBlade>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+import { ClearBlade, Resp, QuerySortDirections, QueryConditions } from ".";
+
+// Sample code for clearbladejs Node SDK v1.0.0 used to test typescript definitions
+
+const genericCallback = (error: boolean, response: Resp) => {};
+
+///////////////////////////////////////
+// ClearBlade object API invocations
+///////////////////////////////////////
+ClearBlade.init({
+	email: "a@a.com",
+	password: "a",
+	systemKey: "testkey",
+	systemSecret: "testsecret",
+	URI: "https://mycbplatform.com",
+	messagingURI: "mycbplatform.com",
+	callback: genericCallback
+});
+
+ClearBlade.setUser("test@test.com", "password");
+ClearBlade.registerUser("test@test.com", "password", genericCallback);
+ClearBlade.isCurrentUserAuthenticated(genericCallback);
+if (!ClearBlade.isObjectEmpty({prop: "test"})) {
+	ClearBlade.logger("Object is not empty");
+}
+
+ClearBlade.validateEmailPassword("test@test.com", "password");
+
+ClearBlade.logoutUser(genericCallback);
+ClearBlade.loginAnon(genericCallback);
+ClearBlade.loginUser("test@test.com", "password", genericCallback);
+
+ClearBlade.sendPush([], {}, "appId: string", genericCallback);
+
+// execute(error: Object, response: Object, callback: ClearBladeCallback): void;
+// makeKVPair(key: string, value: string): KeyValuePair;
+// request(options: RequestOptions, callback: RequestCallback): void;
+
+const coll1 = ClearBlade.Collection("collectionID");
+const coll2 = ClearBlade.Collection({collectionName: "collectionName"});
+const coll3 = ClearBlade.Collection({collectionID: "collectionID"});
+
+const query1 = ClearBlade.Query("collectionID");
+const query2 = ClearBlade.Query({offset: 5, limit: 5, collectionID: "collectionID"});
+const query3 = ClearBlade.Query({collectionName: "collectionName"});
+const query4 = ClearBlade.Query({collection: "collectionID"});
+
+ClearBlade.addToQuery(query1, "key", "value");
+ClearBlade.addFilterToQuery(query1, QueryConditions.QUERY_GREATERTHAN, "key", "value");
+ClearBlade.addSortToQuery(query1, QuerySortDirections.QUERY_SORT_ASCENDING, "column1");
+
+const opQueryStr = ClearBlade.parseOperationQuery(query1.query);
+const parse1: string = ClearBlade.parseQuery(query1.query);
+const parse2: string = ClearBlade.parseQuery(query1);
+
+const item1 = ClearBlade.Item({}, "hello");
+const item2 = ClearBlade.Item({}, {collectionID: "hello"});
+
+const code = ClearBlade.Code();
+const user = ClearBlade.User();
+
+const messaging = ClearBlade.Messaging({}, genericCallback);
+
+///////////////////////////////////////
+// Collection API invocations
+///////////////////////////////////////
+coll1.fetch(query1, genericCallback);
+coll1.create(ClearBlade.Item({}, ""), genericCallback);
+coll1.update(query1.query, {}, genericCallback);
+coll1.remove(query1.query, genericCallback);
+
+///////////////////////////////////////
+// Query API invocations
+///////////////////////////////////////
+query1.ascending("string");
+query1.descending("string");
+query1.equalTo("string", "string");
+query1.greaterThan("string", 2);
+query1.greaterThanEqualTo("string", false);
+query1.lessThan("string", "string");
+query1.lessThanEqualTo("string", "string");
+query1.notEqualTo("string", "string");
+query1.or(query2);
+query1.setPage(1, 1);
+query1.fetch(genericCallback);
+query1.update({}, genericCallback);
+query1.remove(genericCallback);
+
+///////////////////////////////////////
+// Item API invocations
+///////////////////////////////////////
+item1.save();
+item1.refresh();
+item1.destroy();
+
+///////////////////////////////////////
+// Code API invocations
+///////////////////////////////////////
+code.execute("codeName", {}, genericCallback);
+
+///////////////////////////////////////
+// User API invocations
+///////////////////////////////////////
+user.getUser(genericCallback);
+user.setUser({}, genericCallback);
+user.allUsers(query1.query, genericCallback);
+
+///////////////////////////////////////
+// Messaging API invocations
+///////////////////////////////////////
+messaging.getMessageHistory("topic: string", 5, 15, genericCallback);
+
+messaging.publish("topic: string", {});
+
+messaging.subscribe("my/topic", {}, messageReceivedCb);
+
+function messageReceivedCb(message: string) {
+	messaging.unsubscribe("my/topic");
+}

types/clearbladejs-node/index.d.ts

@@ -0,0 +1,249 @@
+// Type definitions for clearbladejs-node 1.0
+// Project: https://github.com/ClearBlade/Node-SDK
+// Definitions by: Jim Bouquet <https://github.com/ClearBlade>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.4
+
+/// <reference types="request" />
+
+import { Response, RequestCallback } from "request/index";
+// import {//PacketCallback } from "mqtt";
+
+export enum MessagingQOS {
+    MESSAGING_QOS_AT_MOST_ONCE = 0,
+    MESSAGING_QOS_AT_LEAST_ONCE = 1,
+    MESSAGING_QOS_EXACTLY_ONCE = 2
+}
+
+export interface Resp {
+    error(msg: any): never;
+    success(msg: any): never;
+}
+
+export interface InitOptions {
+    systemKey: string;
+    systemSecret: string;
+    logging?: boolean;
+    callback?: CbCallback;
+    email?: string;
+    password?: string;
+    registerUser?: boolean;
+    useUser?: APIUser;
+    URI?: string;
+    messagingURI?: string;
+    messagingPort?: number;
+    defaultQoS?: MessagingQOS;
+    callTimeout?: number;
+}
+
+export interface RequestOptions {
+    systemKey: string;
+    systemSecret: string;
+    method?: string;
+    endpoint?: string;
+    body?: string;
+    qs?: string;
+    URI?: string;
+    useUser?: boolean;
+    authToken?: string;
+    user?: APIUser;
+}
+
+export interface APIUser {
+    email: string;
+    authToken: string;
+}
+
+export interface KeyValuePair {
+    [key: string]: any;
+}
+
+export type CbCallback = (error: boolean, response: Resp) => void;
+
+export default interface ClearBladeGlobal extends ClearBladeInt {
+    isCurrentUserAuthenticated(callback: CbCallback): void;
+}
+
+export interface ClearBladeInt {
+    addToQuery(queryObj: QueryObj, key: string, value: string): void;
+    addFilterToQuery(queryObj: QueryObj, condition: QueryConditions, key: string, value: QueryValue): void;
+    addSortToQuery(queryObj: QueryObj, direction: QuerySortDirections, column: string): void;
+    Code(): Code;
+    Collection(options: string | CollectionOptionsWithName | CollectionOptionsWithID): Collection;
+    execute(error: object, response: object, callback: CbCallback): void;
+    init(options: InitOptions): void;
+    isObjectEmpty(obj: object): boolean;
+    Item(data: object, options: string | ItemOptions): Item;
+    logger(message: string): void;
+    loginAnon(callback: CbCallback): void;
+    loginUser(email: string, password: string, callback: CbCallback): void;
+    logoutUser(callback: CbCallback): void;
+    makeKVPair(key: string, value: string): KeyValuePair;
+    parseOperationQuery(query: Query): string;
+    parseQuery(query: Query | QueryObj): string;
+    Query(options: string | QueryOptionsWithCollection | QueryOptionsWithName | QueryOptionsWithID): QueryObj;
+    registerUser(email: string, password: string, callback: CbCallback): void;
+    request(options: RequestOptions, callback: RequestCallback): void;
+    setUser(email: string, password: string): void;
+    User(): AppUser;
+    Messaging(options: MessagingOptions, callback: CbCallback): Messaging;
+    sendPush(users: string[], payload: object, appId: string, callback: CbCallback): void;
+    validateEmailPassword(email: string, password: string): void;
+}
+
+export interface CollectionOptionsWithName {
+    collectionName: string;
+}
+
+export interface CollectionOptionsWithID {
+    collectionID: string;
+}
+
+export interface Collection {
+    endpoint: string;
+    user: APIUser;
+    URI: string;
+    systemKey: string;
+    systemSecret: string;
+
+    fetch(query: QueryObj, callback: CbCallback): void;
+    create(newItem: Item, callback: CbCallback): void;
+    update(query: Query, changes: object, callback: CbCallback): void;
+    remove(query: Query, callback: CbCallback): void;
+}
+
+export enum QuerySortDirections {
+    QUERY_SORT_ASCENDING = 'ASC',
+    QUERY_SORT_DESCENDING = 'DESC'
+}
+
+export enum QueryConditions {
+    QUERY_EQUAL = 'EQ',
+    QUERY_NOTEQUAL = 'NEQ',
+    QUERY_GREATERTHAN = 'GT',
+    QUERY_GREATERTHAN_EQUAL = 'GTE',
+    QUERY_LESSTHAN = 'LT',
+    QUERY_LESSTHAN_EQUAL = 'LTE',
+    QUERY_MATCHES = 'RE'
+}
+
+export type QueryValue = string|number|boolean;
+
+export interface QueryOptions {
+    offset?: number;
+    limit?: number;
+}
+
+export interface QueryOptionsWithCollection extends QueryOptions {
+    collection: string;
+}
+
+export interface QueryOptionsWithName extends CollectionOptionsWithName, QueryOptions {}
+
+export interface QueryOptionsWithID extends CollectionOptionsWithID, QueryOptions {}
+
+export interface Query {
+    SELECTCOLUMNS?: string[];
+    SORT?: QuerySortDirections;
+    FILTERS?: QueryFilter[];
+    PAGESIZE?: number;
+    PAGENUM?: number;
+}
+
+export interface QueryFilter {
+    [QueryConditions: string]: QueryFilterValue;
+}
+
+export interface QueryFilterValue {
+    [name: string]: QueryValue;
+}
+
+export interface QueryObj {
+    endpoint: string;
+    user: APIUser;
+    URI: string;
+    systemKey: string;
+    systemSecret: string;
+    query: Query;
+    OR: Query[];
+    offset: number;
+    limit: number;
+
+    ascending(field: string): Query;
+    descending(field: string): Query;
+    equalTo(field: string, value: QueryValue): Query;
+    greaterThan(field: string, value: QueryValue): Query;
+    greaterThanEqualTo(field: string, value: QueryValue): Query;
+    lessThan(field: string, value: QueryValue): Query;
+    lessThanEqualTo(field: string, value: QueryValue): Query;
+    notEqualTo(field: string, value: QueryValue): Query;
+    matches(field: string, pattern: string): Query;
+    or(query: QueryObj): Query;
+    setPage(pageSize: number, pageNum: number): Query;
+    fetch(callback: CbCallback): void;
+    update(changes: object, callback: CbCallback): void;
+    remove(callback: CbCallback): void;
+}
+
+export interface ItemOptions extends CollectionOptionsWithID {}
+
+export interface Item {
+    data: object;
+
+    save(): void;
+    refresh(): void;
+    destroy(): void;
+}
+
+export interface Code {
+    user: APIUser;
+    URI: string;
+    systemKey: string;
+    systemSecret: string;
+    callTimeout: number;
+    URIPrefix: string;
+
+    execute(name: string, params: object, callback: CbCallback): void;
+}
+
+export interface AppUser {
+    user: APIUser;
+    URI: string;
+    systemKey: string;
+    systemSecret: string;
+
+    getUser(callback: CbCallback): void;
+    setUser(data: object, callback: CbCallback): void;
+    allUsers(query: Query, callback: CbCallback): void;
+}
+
+export interface Messaging {
+    user: APIUser;
+    URI: string;
+    systemKey: string;
+    systemSecret: string;
+    client: object;
+
+    getMessageHistory(topic: string, startTime: number, count: number, callback: CbCallback): void;
+    publish(topic: string, payload: object): void;
+    subscribe(topic: string, options: MessagingSubscribeOptions, messageCallback: MessageCallback): void;
+    unsubscribe(topic: string, callback?: (error?: Error, packet?: object) => any): void;
+}
+
+export interface CommonMessagingProperties {
+    hosts?: string;
+    ports?: string;
+}
+
+export interface MessagingOptions extends CommonMessagingProperties {
+    qos?: MessagingQOS;
+}
+
+export interface MessagingSubscribeOptions {
+    qos?: MessagingQOS;
+    timeout?: number;
+}
+
+export type MessageCallback = (message: string) => void;
+
+export let ClearBlade: ClearBladeGlobal;

types/clearbladejs-node/tsconfig.json

@@ -0,0 +1,27 @@
+{
+    "compileOnSave": true,
+    "compilerOptions": {
+        "target": "ES5",
+        "module": "commonjs",
+        "lib": [
+            "es6"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "baseUrl": "../",
+        "typeRoots": ["../"],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "clearbladejs-node-tests.ts"
+    ],
+    "exclude": [
+        "**/clearbladejs-client/*",
+        "**/clearbladejs-server/*"
+    ]
+}

types/clearbladejs-node/tslint.json

@@ -0,0 +1,7 @@
+{
+    "extends": "dtslint/dt.json",
+    "rules": {
+        "no-empty-interface": false,
+        "no-relative-import-in-test": false
+    }
+}

types/clearbladejs-server/clearbladejs-server-tests.ts

@@ -0,0 +1,192 @@
+// Testing type definitions for clearbladejs-server 1.0
+// Project: https://github.com/ClearBlade/JavaScript-API
+// Definitions by: Jim Bouquet <https://github.com/ClearBlade>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+const genericCallback = (error: boolean, response: Resp) => {};
+
+///////////////////////////////////////
+// ClearBlade object API invocations
+///////////////////////////////////////
+ClearBlade.init({
+    systemKey: "abcdef",
+    systemSecret: "abcdefg",
+    callback: genericCallback
+});
+
+ClearBlade.init({request: {
+    isLogging: false,
+    params: {
+      param1: "1",
+      param2: 2
+    },
+    systemKey: "abcdef",
+    systemSecret: "abcdef",
+    userEmail: "test@test.com",
+    userToken: "abcdef",
+    userid: "abcdef",
+}});
+
+const about = ClearBlade.about();
+ClearBlade.setUser("test@test.com", "authtoken", "userId");
+ClearBlade.registerUser("test@test.com", "password", genericCallback);
+ClearBlade.isCurrentUserAuthenticated(genericCallback);
+ClearBlade.logoutUser(genericCallback);
+ClearBlade.loginAnon(genericCallback);
+ClearBlade.loginUser("test@test.com", "password", genericCallback);
+
+ClearBlade.getAllCollections(genericCallback);
+const edgeID = ClearBlade.edgeId();
+const isEdge = ClearBlade.isEdge(genericCallback);
+if (ClearBlade.isObjectEmpty({test: "test"})) {
+    ClearBlade.logger("Object is empty");
+}
+const kvPair = ClearBlade.makeKVPair("key", "value");
+
+const coll1 = ClearBlade.Collection("collectionID");
+const coll2 = ClearBlade.Collection({ collectionName: "collectionName" });
+const coll3 = ClearBlade.Collection({ collectionID: "collectionID" });
+const coll4 = ClearBlade.Collection({ collection: "collectionID" });
+
+const query1 = ClearBlade.Query({ collectionID: "collectionID" });
+const query2 = ClearBlade.Query({ collectionName: "collectionName" });
+const query3 = ClearBlade.Query({ collection: "collectionID" });
+
+const item1 = ClearBlade.Item({}, "collectionID");
+const item2 = ClearBlade.Item({}, { collectionID: "collectionID" });
+
+const code = ClearBlade.Code();
+const deployment = ClearBlade.Deployment();
+const user = ClearBlade.User();
+
+const messaging = ClearBlade.Messaging({}, genericCallback);
+
+const device = ClearBlade.Device();
+
+ClearBlade.addToQuery(query1, "key", "value");
+ClearBlade.addSortToQuery(
+    query1,
+    QuerySortDirections.QUERY_SORT_ASCENDING,
+    "column1"
+);
+ClearBlade.addFilterToQuery(
+    query1,
+    QueryConditions.QUERY_GREATERTHAN,
+    "key",
+    "value"
+);
+
+ClearBlade.newCollection("collectionName", genericCallback);
+
+const parseOperation = ClearBlade.parseOperationQuery(query1.query);
+const parseQuery1 = ClearBlade.parseQuery(query1);
+const parseQuery2 = ClearBlade.parseQuery(query1.query);
+
+ClearBlade.createDevice("devicename", {type: "devicetype"}, false, genericCallback);
+ClearBlade.deleteDevice("devicename", true, genericCallback);
+ClearBlade.updateDevice("devicename", {type: "devicetype"}, true, genericCallback);
+ClearBlade.getDeviceByName("devicename", genericCallback);
+ClearBlade.getAllDevicesForSystem(genericCallback);
+ClearBlade.validateEmailPassword("test@test.com", "password");
+
+///////////////////////////////////////
+// Collection API invocations
+///////////////////////////////////////
+coll1.addColumn({name: "column1"}, genericCallback);
+coll1.dropColumn("column1", genericCallback);
+coll1.deleteCollection(genericCallback);
+coll1.fetch(query1.query, genericCallback);
+coll1.create(ClearBlade.Item({}, ""), genericCallback);
+coll1.update(query1.query, {}, genericCallback);
+coll1.remove(query1.query, genericCallback);
+coll1.columns(genericCallback);
+coll1.count(query1.query, genericCallback);
+
+///////////////////////////////////////
+// Query API invocations
+///////////////////////////////////////
+query2.ascending("string");
+query1.descending("string");
+query1.equalTo("string", "string");
+query1.greaterThan("string", 2);
+query1.greaterThanEqualTo("string", false);
+query1.lessThan("string", "string");
+query1.lessThanEqualTo("string", "string");
+query1.notEqualTo("string", "string");
+query1.matches("string", ".*");
+query1.or(query2);
+query1.setPage(1, 1);
+query1.fetch(genericCallback);
+query1.update({}, genericCallback);
+query1.columns([]);
+query1.remove(genericCallback);
+
+///////////////////////////////////////
+// Item API invocations
+///////////////////////////////////////
+item1.save();
+item1.refresh();
+item1.destroy();
+
+///////////////////////////////////////
+// Code API invocations
+///////////////////////////////////////
+code.execute("codeName", {}, true, genericCallback);
+code.getAllServices(genericCallback);
+
+///////////////////////////////////////
+// Deployment API invocations
+///////////////////////////////////////
+deployment.create("deploymentname", "deployment description", {}, genericCallback);
+deployment.update("deploymentname", {}, genericCallback);
+deployment.delete("deploymentname", genericCallback);
+deployment.read("deploymentname", genericCallback);
+deployment.readAll(query1, genericCallback);
+
+///////////////////////////////////////
+// User API invocations
+///////////////////////////////////////
+user.getUser(genericCallback);
+user.setUser({}, genericCallback);
+user.setUsers(query2, {name: "Fred"}, genericCallback);
+user.allUsers(query1, genericCallback);
+user.count(query1, genericCallback);
+
+///////////////////////////////////////
+// Messaging API invocations
+///////////////////////////////////////
+messaging.getMessageHistoryWithTimeFrame("topic", 5, 10, 15, 20, genericCallback);
+messaging.getMessageHistory("topic", 5, 15, genericCallback);
+messaging.getAndDeleteMessageHistory("topic", 5, 10, 1, 20, genericCallback);
+messaging.getCurrentTopics(genericCallback);
+messaging.publish("topic", "payload");
+
+///////////////////////////////////////
+// Device API invocations
+///////////////////////////////////////
+device.fetch(query1.query, genericCallback);
+device.update(query1.query, { object: Object }, genericCallback);
+device.delete(query1.query, genericCallback);
+device.create({ newDevice: Object }, genericCallback);
+
+///////////////////////////////////////
+// Triggers API invocations
+///////////////////////////////////////
+ClearBlade.Trigger.Create(
+    "triggername",
+    {
+        system_key: "key",
+	    name: "triggername",
+	    def_module: TriggerModule.DEVICE,
+	    def_name: "someName",
+	    key_value_pairs: [],
+        service_name: "ServiceName"
+    },
+    genericCallback);
+ClearBlade.Trigger.Fetch("triggername", genericCallback);
+
+///////////////////////////////////////
+// Timers API invocations
+///////////////////////////////////////
+ClearBlade.Timer.Create("timername", {}, genericCallback);
+ClearBlade.Timer.Fetch("timername", genericCallback);

types/clearbladejs-server/global.d.ts

@@ -0,0 +1,5 @@
+declare global {
+    var ClearBlade: ClearBladeGlobal;
+}
+
+export {};

types/clearbladejs-server/index.d.ts

@@ -0,0 +1,335 @@
+// Type definitions for clearbladejs-server 1.0
+// Project: https://docs.clearblade.com/v/3/4-developer_reference/platformsdk/ClearBlade.js/
+// Definitions by: Jim Bouquet <https://github.com/ClearBlade>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.4
+
+/// <reference types="paho-mqtt" />
+
+interface BasicReq {
+    readonly isLogging: boolean;
+    readonly params: {
+      [id: string]: any;
+    };
+    readonly systemKey: string;
+    readonly systemSecret: string;
+    readonly userEmail: string;
+    readonly userToken: string;
+    readonly userid: string;
+}
+type ReqTypes = BasicReq;
+declare var req: ReqTypes;
+interface Resp {
+    error(msg: any): never;
+    success(msg: any): never;
+}
+declare var resp: Resp;
+
+declare enum MessagingQOS {
+    MESSAGING_QOS_AT_MOST_ONCE = 0,
+    MESSAGING_QOS_AT_LEAST_ONCE = 1,
+    MESSAGING_QOS_EXACTLY_ONCE = 2
+}
+
+interface InitOptions {
+    systemKey: string;
+    systemSecret: string;
+    logging?: boolean;
+    callback?: CbCallback;
+    authToken?: string;
+    userToken?: string;
+    email?: string;
+    password?: string;
+    registerUser?: boolean;
+    useUser?: APIUser;
+    URI?: string;
+    messagingURI?: string;
+    messagingPort?: number;
+    defaultQoS?: MessagingQOS;
+    callTimeout?: number;
+}
+
+interface APIUser {
+    email: string;
+    authToken: string;
+    user_id?: string;
+}
+
+interface KeyValuePair {
+    [key: string]: any;
+}
+
+type CbCallback = (error: boolean, response: Resp) => void;
+
+interface ClearBladeGlobal extends ClearBladeInt {
+    user: APIUser;
+}
+
+interface ClearBladeInt {
+    Trigger: TriggerClass;
+    Timer: TimerClass;
+
+    about(): string;
+    addToQuery(queryObj: QueryObj, key: string, value: string): void;
+    addFilterToQuery(queryObj: QueryObj, condition: QueryConditions, key: string, value: QueryValue): void;
+    addSortToQuery(queryObj: QueryObj, direction: QuerySortDirections, column: string): void;
+    Code(): Code;
+    Collection(options: string | CollectionOptionsWithName | CollectionOptionsWithID | CollectionOptionsWithCollection): Collection;
+    Deployment(): Deployment;
+    Device(): Device;
+    edgeId(): string;
+    execute(error: object, response: object, callback: CbCallback): any;
+    getAllCollections(callback: CbCallback): void;
+    http(): object;
+    init(options: InitOptions | {request: BasicReq}): void;
+    isEdge(callback: CbCallback): boolean;
+    isCurrentUserAuthenticated(callback: CbCallback): void;
+    isObjectEmpty(obj: object): boolean;
+    Item(data: object, options: string | ItemOptions): Item;
+    logger(message: string): void;
+    loginAnon(callback: CbCallback): void;
+    loginUser(email: string, password: string, callback: CbCallback): void;
+    logoutUser(callback: CbCallback): void;
+    makeKVPair(key: string, value: string): KeyValuePair;
+    Messaging(options: MessagingOptions, callback: CbCallback): Messaging;
+    newCollection(name: string, callback: CbCallback): void;
+    Query(options: QueryOptionsWithCollection | QueryOptionsWithName | QueryOptionsWithID): QueryObj;
+    parseOperationQuery(query: Query): string;
+    parseQuery(query: Query | QueryObj): string;
+    registerUser(email: string, password: string, callback: CbCallback): void;
+    setUser(email: string, authToken: string, userId: string): void;
+    User(): AppUser;
+
+    createDevice(name: string, data: object, causeTrigger: boolean, callback: CbCallback): void;
+    deleteDevice(name: string, causeTrigger: boolean, callback: CbCallback): void;
+    updateDevice(name: string, data: object, causeTrigger: boolean, callback: CbCallback): void;
+    getDeviceByName(name: string, callback: CbCallback): void;
+    getAllDevicesForSystem(callback: CbCallback): void;
+    validateEmailPassword(email: string, password: string): void;
+}
+
+interface CollectionOptionsWithCollection {
+    collection: string;
+}
+
+interface CollectionOptionsWithName {
+    collectionName: string;
+}
+
+interface CollectionOptionsWithID {
+    collectionID: string;
+}
+
+interface Collection {
+    user: APIUser;
+    URI: string;
+    systemKey: string;
+    systemSecret: string;
+
+    addColumn(options: object, callback: CbCallback): void;
+    dropColumn(name: string, callback: CbCallback): void;
+    deleteCollection(callback: CbCallback): void;
+    fetch(query: Query, callback: CbCallback): void;
+    create(newItem: Item, callback: CbCallback): void;
+    update(query: Query, changes: object, callback: CbCallback): void;
+    remove(query: Query, callback: CbCallback): void;
+    columns(callback: CbCallback): void;
+    count(query: Query, callback: CbCallback): void;
+}
+
+declare enum QuerySortDirections {
+    QUERY_SORT_ASCENDING = 'ASC',
+    QUERY_SORT_DESCENDING = 'DESC'
+}
+
+declare enum QueryConditions {
+    QUERY_EQUAL = 'EQ',
+    QUERY_NOTEQUAL = 'NEQ',
+    QUERY_GREATERTHAN = 'GT',
+    QUERY_GREATERTHAN_EQUAL = 'GTE',
+    QUERY_LESSTHAN = 'LT',
+    QUERY_LESSTHAN_EQUAL = 'LTE',
+    QUERY_MATCHES = 'RE'
+}
+
+type QueryValue = string|number|boolean;
+
+interface QueryOptions {
+    offset?: number;
+    limit?: number;
+}
+
+interface QueryOptionsWithCollection extends CollectionOptionsWithCollection, QueryOptions {}
+
+interface QueryOptionsWithName extends CollectionOptionsWithName, QueryOptions {}
+
+interface QueryOptionsWithID extends CollectionOptionsWithID, QueryOptions {}
+
+interface Query {
+    SELECTCOLUMNS?: string[];
+    SORT?: QuerySortDirections;
+    FILTERS?: QueryFilter[];
+    PAGESIZE?: number;
+    PAGENUM?: number;
+}
+
+interface QueryFilter {
+    [QueryConditions: string]: QueryFilterValue;
+}
+
+interface QueryFilterValue {
+    [name: string]: QueryValue;
+}
+
+interface QueryObj {
+    id: string;
+    user: APIUser;
+    URI: string;
+    systemKey: string;
+    systemSecret: string;
+    query: Query;
+    OR: Query[];
+    offset: number;
+    limit: number;
+
+    ascending(field: string): void;
+    descending(field: string): void;
+    equalTo(field: string, value: QueryValue): void;
+    greaterThan(field: string, value: QueryValue): void;
+    greaterThanEqualTo(field: string, value: QueryValue): void;
+    lessThan(field: string, value: QueryValue): void;
+    lessThanEqualTo(field: string, value: QueryValue): void;
+    notEqualTo(field: string, value: QueryValue): void;
+    matches(field: string, pattern: QueryValue): void;
+    or(query: QueryObj): void;
+    setPage(pageSize: number, pageNum: number): void;
+    fetch(callback: CbCallback): void;
+    update(changes: object, callback: CbCallback): void;
+    columns(columnsArray: string[]): void;
+    remove(callback: CbCallback): void;
+}
+
+interface ItemOptions extends CollectionOptionsWithID {}
+
+interface Item {
+    data: object;
+
+    save(): void;
+    refresh(): void;
+    destroy(): void;
+}
+
+interface Code {
+    user: APIUser;
+    systemKey: string;
+    systemSecret: string;
+
+    execute(name: string, params: object, loggingEnabled: boolean, callback: CbCallback): void;
+    getAllServices(callback: CbCallback): void;
+}
+
+interface DeploymentOptions {}
+
+interface Deployment {
+    user: APIUser;
+    systemKey: string;
+    systemSecret: string;
+
+    create(name: string, description: string, options: DeploymentOptions, callback: CbCallback): void;
+    update(name: string, options: DeploymentOptions, callback: CbCallback): void;
+    delete(name: string, callback: CbCallback): void;
+    read(name: string, callback: CbCallback): void;
+    readAll(query: QueryObj, callback: CbCallback): void;
+}
+
+interface AppUser {
+    user: APIUser;
+    URI: string;
+    systemKey: string;
+    systemSecret: string;
+
+    getUser(callback: CbCallback): void;
+    setUser(data: object, callback: CbCallback): void;
+    setUsers(query: QueryObj, data: object, callback: CbCallback): void;
+    allUsers(query: QueryObj, callback: CbCallback): void;
+    count(query: QueryObj, callback: CbCallback): void;
+}
+
+interface Messaging {
+    user: APIUser;
+    systemKey: string;
+    systemSecret: string;
+
+    getMessageHistoryWithTimeFrame(topic: string, count: number, last: number, start: number, stop: number, callback: CbCallback): void;
+    getMessageHistory(topic: string, start: number, count: number, callback: CbCallback): void;
+    getAndDeleteMessageHistory(topic: string, count: number, last: number, start: number, stop: number, callback: CbCallback): void;
+    getCurrentTopics(callback: CbCallback): void;
+    publish(topic: string, payload: string | ArrayBuffer): void;
+}
+
+interface MessagingOptions {}
+
+interface Device {
+    URI: string;
+    systemKey: string;
+    systemSecret: string;
+
+    fetch(query: Query, callback: CbCallback): void;
+    update(query: Query, changes: object, callback: CbCallback): void;
+    delete(query: Query, callback: CbCallback): void;
+    create(newDevice: object, callback: CbCallback): void;
+}
+
+declare enum TriggerModule {
+    DEVICE = "Device",
+    Data = "Data",
+    MESSAGING = "Messaging",
+    USER = "User"
+}
+
+interface TriggerCreateOptions {
+    system_key: string;
+	name: string;
+	def_module: TriggerModule;
+	def_name: string;
+	key_value_pairs: KeyValuePair[];
+	service_name: string;
+}
+
+interface TriggerClass {
+    Create(name: string, options: TriggerCreateOptions, callback: CbCallback): void;
+    Fetch(name: string, callback: CbCallback): void;
+}
+
+interface TimerCreateOptions {
+    description?: string;
+    start_time?: Date;
+    repeats?: number;
+    frequency?: number;
+    service_name?: string;
+    user_id?: string;
+    user_token?: string;
+}
+
+interface TimerClass {
+    Create(name: string, options: TimerCreateOptions, callback: CbCallback): void;
+    Fetch(name: string, callback: CbCallback): void;
+}
+
+interface TriggerInstance {
+    name: string;
+    systemKey: string;
+
+    Update(options: object, callback: CbCallback): void;
+    Delete(callback: CbCallback): void;
+}
+
+interface TimerInstance {
+    name: string;
+    systemKey: string;
+
+    Update(options: object, callback: CbCallback): void;
+    Delete(callback: CbCallback): void;
+}
+
+declare var ClearBlade: ClearBladeGlobal;

types/clearbladejs-server/tsconfig.json

@@ -0,0 +1,27 @@
+{
+    "compilerOptions": {
+        "target": "ES5",
+        "module": "commonjs",
+        "lib": [
+            "es6"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "baseUrl": "../",
+        "typeRoots": ["../"],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "clearbladejs-server-tests.ts",
+        "global.d.ts"
+    ],
+    "exclude": [
+        "**/clearbladejs-client/*",
+        "**/clearbladejs-node/*"
+    ]
+}

types/clearbladejs-server/tslint.json

@@ -0,0 +1,6 @@
+{
+    "extends": "dtslint/dt.json",
+    "rules": {
+        "no-empty-interface": false
+    }
+}