kylefang/DefinitelyTyped
1
0
Fork 0
mirror of https://github.com/zhigang1992/DefinitelyTyped.git synced 2026-05-22 03:37:53 +08:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Jim Bouquet
2018-04-05 17:10:03 -05:00
parent 81dbe6d794
commit 4d7b0c1f0a
14 changed files with 1891 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

193
types/clearbladejs-client/clearbladejs-client-tests.ts Normal file
View File

@@ -0,0 +1,193 @@
// Testing type definitions for clearbladejs Client SDK v1.0.0
// Project: https://github.com/ClearBlade/JavaScript-API
// Definitions by: Jim Bouquet <https://github.com/ClearBlade/>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
var genericCallback = function(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);
var coll1 = ClearBlade.Collection("collectionID");
var coll2 = ClearBlade.Collection({ collectionName: "collectionName" });
var coll3 = ClearBlade.Collection({ collectionID: "collectionID" });
var query1 = ClearBlade.Query("collectionID");
var query2 = ClearBlade.Query({ offset: 5, limit: 5, collectionID: "collectionID" });
var query3 = ClearBlade.Query({ collectionName: "collectionName" });
var item1 = ClearBlade.Item({}, "collectionID");
var item2 = ClearBlade.Item({}, { collectionID: "collectionID" });
var code = ClearBlade.Code();
var user = ClearBlade.User();
var messaging = ClearBlade.Messaging({}, genericCallback);
var stats = ClearBlade.MessagingStats();
var edge = ClearBlade.Edge();
var metrics = ClearBlade.Metrics();
var device = ClearBlade.Device();
var analytics = ClearBlade.Analytics();
var portal = ClearBlade.Portal("MyPortal");
var 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);
var mcb = function(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);

5
types/clearbladejs-client/global.d.ts vendored Normal file
View File

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

441
types/clearbladejs-client/index.d.ts vendored Normal file
View File

@@ -0,0 +1,441 @@
// Type definitions for clearbladejs Client SDK v1.0.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.1
/// <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;
}
interface 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 const enum QuerySortDirections {
QUERY_SORT_ASCENDING = "ASC",
QUERY_SORT_DESCENDING = "DESC"
}
declare const 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;
}
interface 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;

32
types/clearbladejs-client/tsconfig.json Normal file
View File

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

79
types/clearbladejs-client/tslint.json Normal file
View File

@@ -0,0 +1,79 @@
{
"extends": "dtslint/dt.json",
"rules": {
"adjacent-overload-signatures": false,
"array-type": false,
"arrow-return-shorthand": false,
"ban-types": false,
"callable-types": false,
"comment-format": false,
"dt-header": false,
"eofline": false,
"export-just-namespace": false,
"import-spacing": false,
"interface-name": false,
"interface-over-type-literal": false,
"jsdoc-format": false,
"max-line-length": false,
"member-access": false,
"new-parens": false,
"no-any-union": false,
"no-boolean-literal-compare": false,
"no-conditional-assignment": false,
"no-consecutive-blank-lines": false,
"no-construct": false,
"no-declare-current-package": false,
"no-duplicate-imports": false,
"no-duplicate-variable": false,
"no-empty-interface": false,
"no-for-in-array": false,
"no-inferrable-types": false,
"no-internal-module": false,
"no-irregular-whitespace": false,
"no-mergeable-namespace": false,
"no-misused-new": false,
"no-namespace": false,
"no-object-literal-type-assertion": false,
"no-padding": false,
"no-redundant-jsdoc": false,
"no-redundant-jsdoc-2": false,
"no-redundant-undefined": false,
"no-reference-import": false,
"no-relative-import-in-test": false,
"no-self-import": false,
"no-single-declare-module": false,
"no-string-throw": false,
"no-unnecessary-callback-wrapper": false,
"no-unnecessary-class": false,
"no-unnecessary-generics": false,
"no-unnecessary-qualifier": false,
"no-unnecessary-type-assertion": false,
"no-useless-files": false,
"no-var-keyword": false,
"no-var-requires": false,
"no-void-expression": false,
"no-trailing-whitespace": false,
"object-literal-key-quotes": false,
"object-literal-shorthand": false,
"one-line": false,
"one-variable-per-declaration": false,
"only-arrow-functions": false,
"prefer-conditional-expression": false,
"prefer-const": false,
"prefer-declare-function": false,
"prefer-for-of": false,
"prefer-method-signature": false,
"prefer-template": false,
"radix": false,
"semicolon": false,
"space-before-function-paren": false,
"space-within-parens": false,
"strict-export-declare-modifiers": false,
"trim-file": false,
"triple-equals": false,
"typedef-whitespace": false,
"unified-signatures": false,
"void-return": false,
"whitespace": false
}
}

128
types/clearbladejs-node/clearbladejs-node-tests.ts Normal file
View File

@@ -0,0 +1,128 @@
import { ClearBlade, Resp, QuerySortDirections, QueryConditions } from ".";
// Sample code for clearbladejs Node SDK v1.0.0 used to test typescript definitions
// Project: https://github.com/ClearBlade/Node-SDK
// Definitions by: Jim Bouquet <https://github.com/ClearBlade/>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
const constants = require("./constants.json");
var genericCallback = function(error: boolean, response: Resp) {};
///////////////////////////////////////
//ClearBlade object API invocations
///////////////////////////////////////
ClearBlade.init({
email: "a@a.com",
password: "a",
systemKey: constants.systemKey,
systemSecret: constants.systemSecret,
URI: constants.URL,
messagingURI: constants.messageURL,
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;
var coll1 = ClearBlade.Collection("collectionID");
var coll2 = ClearBlade.Collection({collectionName: "collectionName"});
var coll3 = ClearBlade.Collection({collectionID: "collectionID"});
var query1 = ClearBlade.Query("collectionID");
var query2 = ClearBlade.Query({offset: 5, limit: 5, collectionID: "collectionID"});
var query3 = ClearBlade.Query({collectionName: "collectionName"});
var 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");
var opQueryStr = ClearBlade.parseOperationQuery(query1.query);
var parse1:string = ClearBlade.parseQuery(query1.query);
var parse2:string = ClearBlade.parseQuery(query1);
var item1 = ClearBlade.Item({}, "hello");
var item2 = ClearBlade.Item({}, {collectionID: "hello"});
var code = ClearBlade.Code();
var user = ClearBlade.User();
var 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");
}

256
types/clearbladejs-node/index.d.ts vendored Normal file
View File

@@ -0,0 +1,256 @@
import { Response, RequestCallback } from "request/index";
import { MqttClient, PacketCallback } from "mqtt";
// Type definitions for clearbladejs Node SDK v1.0.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.1
/// <reference types="request" />
/// <reference types="mqtt" />
declare 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; // todo: figure out if we can have the compiler throw an error if someone adds code after this
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 interface 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 declare const enum QuerySortDirections {
QUERY_SORT_ASCENDING = 'ASC',
QUERY_SORT_DESCENDING = 'DESC'
}
export declare const 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: MqttClient;
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?: PacketCallback): void;
}
export interface CommonMessagingProperties {
hosts?: string;
ports?: string;
}
export interface MessagingOptions extends CommonMessagingProperties {
qos?: MessagingQOS
}
export interface MessagingSubscribeOptions {
qos?: MessagingQOS;
timeout?: number;
}
export interface MessageCallback {
(message: string): void;
}
declare var ClearBlade: ClearBladeGlobal;
export {ClearBlade};

34
types/clearbladejs-node/tsconfig.json Normal file
View File

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

79
types/clearbladejs-node/tslint.json Normal file
View File

@@ -0,0 +1,79 @@
{
"extends": "dtslint/dt.json",
"rules": {
"adjacent-overload-signatures": false,
"array-type": false,
"arrow-return-shorthand": false,
"ban-types": false,
"callable-types": false,
"comment-format": false,
"dt-header": false,
"eofline": false,
"export-just-namespace": false,
"import-spacing": false,
"interface-name": false,
"interface-over-type-literal": false,
"jsdoc-format": false,
"max-line-length": false,
"member-access": false,
"new-parens": false,
"no-any-union": false,
"no-boolean-literal-compare": false,
"no-conditional-assignment": false,
"no-consecutive-blank-lines": false,
"no-construct": false,
"no-declare-current-package": false,
"no-duplicate-imports": false,
"no-duplicate-variable": false,
"no-empty-interface": false,
"no-for-in-array": false,
"no-inferrable-types": false,
"no-internal-module": false,
"no-irregular-whitespace": false,
"no-mergeable-namespace": false,
"no-misused-new": false,
"no-namespace": false,
"no-object-literal-type-assertion": false,
"no-padding": false,
"no-redundant-jsdoc": false,
"no-redundant-jsdoc-2": false,
"no-redundant-undefined": false,
"no-reference-import": false,
"no-relative-import-in-test": false,
"no-self-import": false,
"no-single-declare-module": false,
"no-string-throw": false,
"no-unnecessary-callback-wrapper": false,
"no-unnecessary-class": false,
"no-unnecessary-generics": false,
"no-unnecessary-qualifier": false,
"no-unnecessary-type-assertion": false,
"no-useless-files": false,
"no-var-keyword": false,
"no-var-requires": false,
"no-void-expression": false,
"no-trailing-whitespace": false,
"object-literal-key-quotes": false,
"object-literal-shorthand": false,
"one-line": false,
"one-variable-per-declaration": false,
"only-arrow-functions": false,
"prefer-conditional-expression": false,
"prefer-const": false,
"prefer-declare-function": false,
"prefer-for-of": false,
"prefer-method-signature": false,
"prefer-template": false,
"radix": false,
"semicolon": false,
"space-before-function-paren": false,
"space-within-parens": false,
"strict-export-declare-modifiers": false,
"trim-file": false,
"triple-equals": false,
"typedef-whitespace": false,
"unified-signatures": false,
"void-return": false,
"whitespace": false
}
}

192
types/clearbladejs-server/clearbladejs-server-tests.ts Normal file
View File

@@ -0,0 +1,192 @@
// Testing type definitions for clearbladejs Client SDK v1.0.0
// Project: https://github.com/ClearBlade/JavaScript-API
// Definitions by: Jim Bouquet <https://github.com/ClearBlade/>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
var genericCallback = function(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",
}});
var 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);
var edgeID = ClearBlade.edgeId();
var isEdge = ClearBlade.isEdge(genericCallback);
if (ClearBlade.isObjectEmpty({test: "test"})) {
ClearBlade.logger("Object is empty");
}
var kvPair = ClearBlade.makeKVPair("key", "value");
var coll1 = ClearBlade.Collection("collectionID");
var coll2 = ClearBlade.Collection({ collectionName: "collectionName" });
var coll3 = ClearBlade.Collection({ collectionID: "collectionID" });
var coll4 = ClearBlade.Collection({ collection: "collectionID" });
var query1 = ClearBlade.Query({ collectionID: "collectionID" });
var query2 = ClearBlade.Query({ collectionName: "collectionName" });
var query3 = ClearBlade.Query({ collection: "collectionID" });
var item1 = ClearBlade.Item({}, "collectionID");
var item2 = ClearBlade.Item({}, { collectionID: "collectionID" });
var code = ClearBlade.Code();
var deployment = ClearBlade.Deployment();
var user = ClearBlade.User();
var messaging = ClearBlade.Messaging({}, genericCallback);
var 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);
var parseOperation = ClearBlade.parseOperationQuery(query1.query);
var parseQuery1 = ClearBlade.parseQuery(query1);
var 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);

5
types/clearbladejs-server/global.d.ts vendored Normal file
View File

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

336
types/clearbladejs-server/index.d.ts vendored Normal file
View File

@@ -0,0 +1,336 @@
// Type definitions for clearbladejs Server SDK v1.0.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.1
/// <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;
}
interface 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 const enum QuerySortDirections {
QUERY_SORT_ASCENDING = 'ASC',
QUERY_SORT_DESCENDING = 'DESC'
}
declare const 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 const 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;

32
types/clearbladejs-server/tsconfig.json Normal file
View File

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

79
types/clearbladejs-server/tslint.json Normal file
View File

@@ -0,0 +1,79 @@
{
"extends": "dtslint/dt.json",
"rules": {
"adjacent-overload-signatures": false,
"array-type": false,
"arrow-return-shorthand": false,
"ban-types": false,
"callable-types": false,
"comment-format": false,
"dt-header": false,
"eofline": false,
"export-just-namespace": false,
"import-spacing": false,
"interface-name": false,
"interface-over-type-literal": false,
"jsdoc-format": false,
"max-line-length": false,
"member-access": false,
"new-parens": false,
"no-any-union": false,
"no-boolean-literal-compare": false,
"no-conditional-assignment": false,
"no-consecutive-blank-lines": false,
"no-construct": false,
"no-declare-current-package": false,
"no-duplicate-imports": false,
"no-duplicate-variable": false,
"no-empty-interface": false,
"no-for-in-array": false,
"no-inferrable-types": false,
"no-internal-module": false,
"no-irregular-whitespace": false,
"no-mergeable-namespace": false,
"no-misused-new": false,
"no-namespace": false,
"no-object-literal-type-assertion": false,
"no-padding": false,
"no-redundant-jsdoc": false,
"no-redundant-jsdoc-2": false,
"no-redundant-undefined": false,
"no-reference-import": false,
"no-relative-import-in-test": false,
"no-self-import": false,
"no-single-declare-module": false,
"no-string-throw": false,
"no-unnecessary-callback-wrapper": false,
"no-unnecessary-class": false,
"no-unnecessary-generics": false,
"no-unnecessary-qualifier": false,
"no-unnecessary-type-assertion": false,
"no-useless-files": false,
"no-var-keyword": false,
"no-var-requires": false,
"no-void-expression": false,
"no-trailing-whitespace": false,
"object-literal-key-quotes": false,
"object-literal-shorthand": false,
"one-line": false,
"one-variable-per-declaration": false,
"only-arrow-functions": false,
"prefer-conditional-expression": false,
"prefer-const": false,
"prefer-declare-function": false,
"prefer-for-of": false,
"prefer-method-signature": false,
"prefer-template": false,
"radix": false,
"semicolon": false,
"space-before-function-paren": false,
"space-within-parens": false,
"strict-export-declare-modifiers": false,
"trim-file": false,
"triple-equals": false,
"typedef-whitespace": false,
"unified-signatures": false,
"void-return": false,
"whitespace": false
}
}