@aceplus/smartace-api 2.2.0 → 2.3.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/auth.firmware_pb.d.ts +238 -0
- package/auth.firmware_pb.js +1850 -0
- package/auth.firmware_pb_service.d.ts +120 -0
- package/auth.firmware_pb_service.js +181 -0
- package/package.json +1 -1
|
@@ -0,0 +1,120 @@
|
|
|
1
|
+
// package: Auth
|
|
2
|
+
// file: auth.firmware.proto
|
|
3
|
+
|
|
4
|
+
import * as auth_firmware_pb from "./auth.firmware_pb";
|
|
5
|
+
import {grpc} from "@improbable-eng/grpc-web";
|
|
6
|
+
|
|
7
|
+
type FirmwareGRPCCreate = {
|
|
8
|
+
readonly methodName: string;
|
|
9
|
+
readonly service: typeof FirmwareGRPC;
|
|
10
|
+
readonly requestStream: false;
|
|
11
|
+
readonly responseStream: false;
|
|
12
|
+
readonly requestType: typeof auth_firmware_pb.FirmwareProto.CreateRequest;
|
|
13
|
+
readonly responseType: typeof auth_firmware_pb.FirmwareProto;
|
|
14
|
+
};
|
|
15
|
+
|
|
16
|
+
type FirmwareGRPCRetrieve = {
|
|
17
|
+
readonly methodName: string;
|
|
18
|
+
readonly service: typeof FirmwareGRPC;
|
|
19
|
+
readonly requestStream: false;
|
|
20
|
+
readonly responseStream: false;
|
|
21
|
+
readonly requestType: typeof auth_firmware_pb.FirmwareProto.RetrieveRequest;
|
|
22
|
+
readonly responseType: typeof auth_firmware_pb.FirmwareProto;
|
|
23
|
+
};
|
|
24
|
+
|
|
25
|
+
type FirmwareGRPCUpdate = {
|
|
26
|
+
readonly methodName: string;
|
|
27
|
+
readonly service: typeof FirmwareGRPC;
|
|
28
|
+
readonly requestStream: false;
|
|
29
|
+
readonly responseStream: false;
|
|
30
|
+
readonly requestType: typeof auth_firmware_pb.FirmwareProto.UpdateRequest;
|
|
31
|
+
readonly responseType: typeof auth_firmware_pb.FirmwareProto;
|
|
32
|
+
};
|
|
33
|
+
|
|
34
|
+
type FirmwareGRPCSearch = {
|
|
35
|
+
readonly methodName: string;
|
|
36
|
+
readonly service: typeof FirmwareGRPC;
|
|
37
|
+
readonly requestStream: false;
|
|
38
|
+
readonly responseStream: false;
|
|
39
|
+
readonly requestType: typeof auth_firmware_pb.FirmwareProto.SearchRequest;
|
|
40
|
+
readonly responseType: typeof auth_firmware_pb.FirmwareProto.SearchReply;
|
|
41
|
+
};
|
|
42
|
+
|
|
43
|
+
export class FirmwareGRPC {
|
|
44
|
+
static readonly serviceName: string;
|
|
45
|
+
static readonly Create: FirmwareGRPCCreate;
|
|
46
|
+
static readonly Retrieve: FirmwareGRPCRetrieve;
|
|
47
|
+
static readonly Update: FirmwareGRPCUpdate;
|
|
48
|
+
static readonly Search: FirmwareGRPCSearch;
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
export type ServiceError = { message: string, code: number; metadata: grpc.Metadata }
|
|
52
|
+
export type Status = { details: string, code: number; metadata: grpc.Metadata }
|
|
53
|
+
|
|
54
|
+
interface UnaryResponse {
|
|
55
|
+
cancel(): void;
|
|
56
|
+
}
|
|
57
|
+
interface ResponseStream<T> {
|
|
58
|
+
cancel(): void;
|
|
59
|
+
on(type: 'data', handler: (message: T) => void): ResponseStream<T>;
|
|
60
|
+
on(type: 'end', handler: (status?: Status) => void): ResponseStream<T>;
|
|
61
|
+
on(type: 'status', handler: (status: Status) => void): ResponseStream<T>;
|
|
62
|
+
}
|
|
63
|
+
interface RequestStream<T> {
|
|
64
|
+
write(message: T): RequestStream<T>;
|
|
65
|
+
end(): void;
|
|
66
|
+
cancel(): void;
|
|
67
|
+
on(type: 'end', handler: (status?: Status) => void): RequestStream<T>;
|
|
68
|
+
on(type: 'status', handler: (status: Status) => void): RequestStream<T>;
|
|
69
|
+
}
|
|
70
|
+
interface BidirectionalStream<ReqT, ResT> {
|
|
71
|
+
write(message: ReqT): BidirectionalStream<ReqT, ResT>;
|
|
72
|
+
end(): void;
|
|
73
|
+
cancel(): void;
|
|
74
|
+
on(type: 'data', handler: (message: ResT) => void): BidirectionalStream<ReqT, ResT>;
|
|
75
|
+
on(type: 'end', handler: (status?: Status) => void): BidirectionalStream<ReqT, ResT>;
|
|
76
|
+
on(type: 'status', handler: (status: Status) => void): BidirectionalStream<ReqT, ResT>;
|
|
77
|
+
}
|
|
78
|
+
|
|
79
|
+
export class FirmwareGRPCClient {
|
|
80
|
+
readonly serviceHost: string;
|
|
81
|
+
|
|
82
|
+
constructor(serviceHost: string, options?: grpc.RpcOptions);
|
|
83
|
+
create(
|
|
84
|
+
requestMessage: auth_firmware_pb.FirmwareProto.CreateRequest,
|
|
85
|
+
metadata: grpc.Metadata,
|
|
86
|
+
callback: (error: ServiceError|null, responseMessage: auth_firmware_pb.FirmwareProto|null) => void
|
|
87
|
+
): UnaryResponse;
|
|
88
|
+
create(
|
|
89
|
+
requestMessage: auth_firmware_pb.FirmwareProto.CreateRequest,
|
|
90
|
+
callback: (error: ServiceError|null, responseMessage: auth_firmware_pb.FirmwareProto|null) => void
|
|
91
|
+
): UnaryResponse;
|
|
92
|
+
retrieve(
|
|
93
|
+
requestMessage: auth_firmware_pb.FirmwareProto.RetrieveRequest,
|
|
94
|
+
metadata: grpc.Metadata,
|
|
95
|
+
callback: (error: ServiceError|null, responseMessage: auth_firmware_pb.FirmwareProto|null) => void
|
|
96
|
+
): UnaryResponse;
|
|
97
|
+
retrieve(
|
|
98
|
+
requestMessage: auth_firmware_pb.FirmwareProto.RetrieveRequest,
|
|
99
|
+
callback: (error: ServiceError|null, responseMessage: auth_firmware_pb.FirmwareProto|null) => void
|
|
100
|
+
): UnaryResponse;
|
|
101
|
+
update(
|
|
102
|
+
requestMessage: auth_firmware_pb.FirmwareProto.UpdateRequest,
|
|
103
|
+
metadata: grpc.Metadata,
|
|
104
|
+
callback: (error: ServiceError|null, responseMessage: auth_firmware_pb.FirmwareProto|null) => void
|
|
105
|
+
): UnaryResponse;
|
|
106
|
+
update(
|
|
107
|
+
requestMessage: auth_firmware_pb.FirmwareProto.UpdateRequest,
|
|
108
|
+
callback: (error: ServiceError|null, responseMessage: auth_firmware_pb.FirmwareProto|null) => void
|
|
109
|
+
): UnaryResponse;
|
|
110
|
+
search(
|
|
111
|
+
requestMessage: auth_firmware_pb.FirmwareProto.SearchRequest,
|
|
112
|
+
metadata: grpc.Metadata,
|
|
113
|
+
callback: (error: ServiceError|null, responseMessage: auth_firmware_pb.FirmwareProto.SearchReply|null) => void
|
|
114
|
+
): UnaryResponse;
|
|
115
|
+
search(
|
|
116
|
+
requestMessage: auth_firmware_pb.FirmwareProto.SearchRequest,
|
|
117
|
+
callback: (error: ServiceError|null, responseMessage: auth_firmware_pb.FirmwareProto.SearchReply|null) => void
|
|
118
|
+
): UnaryResponse;
|
|
119
|
+
}
|
|
120
|
+
|
|
@@ -0,0 +1,181 @@
|
|
|
1
|
+
// package: Auth
|
|
2
|
+
// file: auth.firmware.proto
|
|
3
|
+
|
|
4
|
+
var auth_firmware_pb = require("./auth.firmware_pb");
|
|
5
|
+
var grpc = require("@improbable-eng/grpc-web").grpc;
|
|
6
|
+
|
|
7
|
+
var FirmwareGRPC = (function () {
|
|
8
|
+
function FirmwareGRPC() {}
|
|
9
|
+
FirmwareGRPC.serviceName = "Auth.FirmwareGRPC";
|
|
10
|
+
return FirmwareGRPC;
|
|
11
|
+
}());
|
|
12
|
+
|
|
13
|
+
FirmwareGRPC.Create = {
|
|
14
|
+
methodName: "Create",
|
|
15
|
+
service: FirmwareGRPC,
|
|
16
|
+
requestStream: false,
|
|
17
|
+
responseStream: false,
|
|
18
|
+
requestType: auth_firmware_pb.FirmwareProto.CreateRequest,
|
|
19
|
+
responseType: auth_firmware_pb.FirmwareProto
|
|
20
|
+
};
|
|
21
|
+
|
|
22
|
+
FirmwareGRPC.Retrieve = {
|
|
23
|
+
methodName: "Retrieve",
|
|
24
|
+
service: FirmwareGRPC,
|
|
25
|
+
requestStream: false,
|
|
26
|
+
responseStream: false,
|
|
27
|
+
requestType: auth_firmware_pb.FirmwareProto.RetrieveRequest,
|
|
28
|
+
responseType: auth_firmware_pb.FirmwareProto
|
|
29
|
+
};
|
|
30
|
+
|
|
31
|
+
FirmwareGRPC.Update = {
|
|
32
|
+
methodName: "Update",
|
|
33
|
+
service: FirmwareGRPC,
|
|
34
|
+
requestStream: false,
|
|
35
|
+
responseStream: false,
|
|
36
|
+
requestType: auth_firmware_pb.FirmwareProto.UpdateRequest,
|
|
37
|
+
responseType: auth_firmware_pb.FirmwareProto
|
|
38
|
+
};
|
|
39
|
+
|
|
40
|
+
FirmwareGRPC.Search = {
|
|
41
|
+
methodName: "Search",
|
|
42
|
+
service: FirmwareGRPC,
|
|
43
|
+
requestStream: false,
|
|
44
|
+
responseStream: false,
|
|
45
|
+
requestType: auth_firmware_pb.FirmwareProto.SearchRequest,
|
|
46
|
+
responseType: auth_firmware_pb.FirmwareProto.SearchReply
|
|
47
|
+
};
|
|
48
|
+
|
|
49
|
+
exports.FirmwareGRPC = FirmwareGRPC;
|
|
50
|
+
|
|
51
|
+
function FirmwareGRPCClient(serviceHost, options) {
|
|
52
|
+
this.serviceHost = serviceHost;
|
|
53
|
+
this.options = options || {};
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
FirmwareGRPCClient.prototype.create = function create(requestMessage, metadata, callback) {
|
|
57
|
+
if (arguments.length === 2) {
|
|
58
|
+
callback = arguments[1];
|
|
59
|
+
}
|
|
60
|
+
var client = grpc.unary(FirmwareGRPC.Create, {
|
|
61
|
+
request: requestMessage,
|
|
62
|
+
host: this.serviceHost,
|
|
63
|
+
metadata: metadata,
|
|
64
|
+
transport: this.options.transport,
|
|
65
|
+
debug: this.options.debug,
|
|
66
|
+
onEnd: function (response) {
|
|
67
|
+
if (callback) {
|
|
68
|
+
if (response.status !== grpc.Code.OK) {
|
|
69
|
+
var err = new Error(response.statusMessage);
|
|
70
|
+
err.code = response.status;
|
|
71
|
+
err.metadata = response.trailers;
|
|
72
|
+
callback(err, null);
|
|
73
|
+
} else {
|
|
74
|
+
callback(null, response.message);
|
|
75
|
+
}
|
|
76
|
+
}
|
|
77
|
+
}
|
|
78
|
+
});
|
|
79
|
+
return {
|
|
80
|
+
cancel: function () {
|
|
81
|
+
callback = null;
|
|
82
|
+
client.close();
|
|
83
|
+
}
|
|
84
|
+
};
|
|
85
|
+
};
|
|
86
|
+
|
|
87
|
+
FirmwareGRPCClient.prototype.retrieve = function retrieve(requestMessage, metadata, callback) {
|
|
88
|
+
if (arguments.length === 2) {
|
|
89
|
+
callback = arguments[1];
|
|
90
|
+
}
|
|
91
|
+
var client = grpc.unary(FirmwareGRPC.Retrieve, {
|
|
92
|
+
request: requestMessage,
|
|
93
|
+
host: this.serviceHost,
|
|
94
|
+
metadata: metadata,
|
|
95
|
+
transport: this.options.transport,
|
|
96
|
+
debug: this.options.debug,
|
|
97
|
+
onEnd: function (response) {
|
|
98
|
+
if (callback) {
|
|
99
|
+
if (response.status !== grpc.Code.OK) {
|
|
100
|
+
var err = new Error(response.statusMessage);
|
|
101
|
+
err.code = response.status;
|
|
102
|
+
err.metadata = response.trailers;
|
|
103
|
+
callback(err, null);
|
|
104
|
+
} else {
|
|
105
|
+
callback(null, response.message);
|
|
106
|
+
}
|
|
107
|
+
}
|
|
108
|
+
}
|
|
109
|
+
});
|
|
110
|
+
return {
|
|
111
|
+
cancel: function () {
|
|
112
|
+
callback = null;
|
|
113
|
+
client.close();
|
|
114
|
+
}
|
|
115
|
+
};
|
|
116
|
+
};
|
|
117
|
+
|
|
118
|
+
FirmwareGRPCClient.prototype.update = function update(requestMessage, metadata, callback) {
|
|
119
|
+
if (arguments.length === 2) {
|
|
120
|
+
callback = arguments[1];
|
|
121
|
+
}
|
|
122
|
+
var client = grpc.unary(FirmwareGRPC.Update, {
|
|
123
|
+
request: requestMessage,
|
|
124
|
+
host: this.serviceHost,
|
|
125
|
+
metadata: metadata,
|
|
126
|
+
transport: this.options.transport,
|
|
127
|
+
debug: this.options.debug,
|
|
128
|
+
onEnd: function (response) {
|
|
129
|
+
if (callback) {
|
|
130
|
+
if (response.status !== grpc.Code.OK) {
|
|
131
|
+
var err = new Error(response.statusMessage);
|
|
132
|
+
err.code = response.status;
|
|
133
|
+
err.metadata = response.trailers;
|
|
134
|
+
callback(err, null);
|
|
135
|
+
} else {
|
|
136
|
+
callback(null, response.message);
|
|
137
|
+
}
|
|
138
|
+
}
|
|
139
|
+
}
|
|
140
|
+
});
|
|
141
|
+
return {
|
|
142
|
+
cancel: function () {
|
|
143
|
+
callback = null;
|
|
144
|
+
client.close();
|
|
145
|
+
}
|
|
146
|
+
};
|
|
147
|
+
};
|
|
148
|
+
|
|
149
|
+
FirmwareGRPCClient.prototype.search = function search(requestMessage, metadata, callback) {
|
|
150
|
+
if (arguments.length === 2) {
|
|
151
|
+
callback = arguments[1];
|
|
152
|
+
}
|
|
153
|
+
var client = grpc.unary(FirmwareGRPC.Search, {
|
|
154
|
+
request: requestMessage,
|
|
155
|
+
host: this.serviceHost,
|
|
156
|
+
metadata: metadata,
|
|
157
|
+
transport: this.options.transport,
|
|
158
|
+
debug: this.options.debug,
|
|
159
|
+
onEnd: function (response) {
|
|
160
|
+
if (callback) {
|
|
161
|
+
if (response.status !== grpc.Code.OK) {
|
|
162
|
+
var err = new Error(response.statusMessage);
|
|
163
|
+
err.code = response.status;
|
|
164
|
+
err.metadata = response.trailers;
|
|
165
|
+
callback(err, null);
|
|
166
|
+
} else {
|
|
167
|
+
callback(null, response.message);
|
|
168
|
+
}
|
|
169
|
+
}
|
|
170
|
+
}
|
|
171
|
+
});
|
|
172
|
+
return {
|
|
173
|
+
cancel: function () {
|
|
174
|
+
callback = null;
|
|
175
|
+
client.close();
|
|
176
|
+
}
|
|
177
|
+
};
|
|
178
|
+
};
|
|
179
|
+
|
|
180
|
+
exports.FirmwareGRPCClient = FirmwareGRPCClient;
|
|
181
|
+
|