@aceplus/smartace-api 3.7.0-alpha.3 → 3.7.0-alpha.5
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.passkey_pb.d.ts +186 -0
- package/auth.passkey_pb.js +1423 -0
- package/auth.passkey_pb_service.d.ts +121 -0
- package/auth.passkey_pb_service.js +182 -0
- package/package.json +1 -1
|
@@ -0,0 +1,121 @@
|
|
|
1
|
+
// package: Auth
|
|
2
|
+
// file: auth.passkey.proto
|
|
3
|
+
|
|
4
|
+
import * as auth_passkey_pb from "./auth.passkey_pb";
|
|
5
|
+
import * as auth_authn_pb from "./auth.authn_pb";
|
|
6
|
+
import {grpc} from "@improbable-eng/grpc-web";
|
|
7
|
+
|
|
8
|
+
type PassKeyGRPCGetCredentialsOptions = {
|
|
9
|
+
readonly methodName: string;
|
|
10
|
+
readonly service: typeof PassKeyGRPC;
|
|
11
|
+
readonly requestStream: false;
|
|
12
|
+
readonly responseStream: false;
|
|
13
|
+
readonly requestType: typeof auth_passkey_pb.PasskeyProto.GetCredentialsRequest;
|
|
14
|
+
readonly responseType: typeof auth_passkey_pb.PasskeyProto.CredentialCreateOptions;
|
|
15
|
+
};
|
|
16
|
+
|
|
17
|
+
type PassKeyGRPCCreateCredential = {
|
|
18
|
+
readonly methodName: string;
|
|
19
|
+
readonly service: typeof PassKeyGRPC;
|
|
20
|
+
readonly requestStream: false;
|
|
21
|
+
readonly responseStream: false;
|
|
22
|
+
readonly requestType: typeof auth_passkey_pb.PasskeyProto.CreateCredentialsRequest;
|
|
23
|
+
readonly responseType: typeof auth_passkey_pb.PasskeyProto;
|
|
24
|
+
};
|
|
25
|
+
|
|
26
|
+
type PassKeyGRPCGetAssertionOptions = {
|
|
27
|
+
readonly methodName: string;
|
|
28
|
+
readonly service: typeof PassKeyGRPC;
|
|
29
|
+
readonly requestStream: false;
|
|
30
|
+
readonly responseStream: false;
|
|
31
|
+
readonly requestType: typeof auth_passkey_pb.PasskeyProto.GetAssertionOptionsRequest;
|
|
32
|
+
readonly responseType: typeof auth_passkey_pb.PasskeyProto.AssertionOptions;
|
|
33
|
+
};
|
|
34
|
+
|
|
35
|
+
type PassKeyGRPCMakeAssertion = {
|
|
36
|
+
readonly methodName: string;
|
|
37
|
+
readonly service: typeof PassKeyGRPC;
|
|
38
|
+
readonly requestStream: false;
|
|
39
|
+
readonly responseStream: false;
|
|
40
|
+
readonly requestType: typeof auth_passkey_pb.PasskeyProto.MakeAssertionRequest;
|
|
41
|
+
readonly responseType: typeof auth_authn_pb.AuthnProto;
|
|
42
|
+
};
|
|
43
|
+
|
|
44
|
+
export class PassKeyGRPC {
|
|
45
|
+
static readonly serviceName: string;
|
|
46
|
+
static readonly GetCredentialsOptions: PassKeyGRPCGetCredentialsOptions;
|
|
47
|
+
static readonly CreateCredential: PassKeyGRPCCreateCredential;
|
|
48
|
+
static readonly GetAssertionOptions: PassKeyGRPCGetAssertionOptions;
|
|
49
|
+
static readonly MakeAssertion: PassKeyGRPCMakeAssertion;
|
|
50
|
+
}
|
|
51
|
+
|
|
52
|
+
export type ServiceError = { message: string, code: number; metadata: grpc.Metadata }
|
|
53
|
+
export type Status = { details: string, code: number; metadata: grpc.Metadata }
|
|
54
|
+
|
|
55
|
+
interface UnaryResponse {
|
|
56
|
+
cancel(): void;
|
|
57
|
+
}
|
|
58
|
+
interface ResponseStream<T> {
|
|
59
|
+
cancel(): void;
|
|
60
|
+
on(type: 'data', handler: (message: T) => void): ResponseStream<T>;
|
|
61
|
+
on(type: 'end', handler: (status?: Status) => void): ResponseStream<T>;
|
|
62
|
+
on(type: 'status', handler: (status: Status) => void): ResponseStream<T>;
|
|
63
|
+
}
|
|
64
|
+
interface RequestStream<T> {
|
|
65
|
+
write(message: T): RequestStream<T>;
|
|
66
|
+
end(): void;
|
|
67
|
+
cancel(): void;
|
|
68
|
+
on(type: 'end', handler: (status?: Status) => void): RequestStream<T>;
|
|
69
|
+
on(type: 'status', handler: (status: Status) => void): RequestStream<T>;
|
|
70
|
+
}
|
|
71
|
+
interface BidirectionalStream<ReqT, ResT> {
|
|
72
|
+
write(message: ReqT): BidirectionalStream<ReqT, ResT>;
|
|
73
|
+
end(): void;
|
|
74
|
+
cancel(): void;
|
|
75
|
+
on(type: 'data', handler: (message: ResT) => void): BidirectionalStream<ReqT, ResT>;
|
|
76
|
+
on(type: 'end', handler: (status?: Status) => void): BidirectionalStream<ReqT, ResT>;
|
|
77
|
+
on(type: 'status', handler: (status: Status) => void): BidirectionalStream<ReqT, ResT>;
|
|
78
|
+
}
|
|
79
|
+
|
|
80
|
+
export class PassKeyGRPCClient {
|
|
81
|
+
readonly serviceHost: string;
|
|
82
|
+
|
|
83
|
+
constructor(serviceHost: string, options?: grpc.RpcOptions);
|
|
84
|
+
getCredentialsOptions(
|
|
85
|
+
requestMessage: auth_passkey_pb.PasskeyProto.GetCredentialsRequest,
|
|
86
|
+
metadata: grpc.Metadata,
|
|
87
|
+
callback: (error: ServiceError|null, responseMessage: auth_passkey_pb.PasskeyProto.CredentialCreateOptions|null) => void
|
|
88
|
+
): UnaryResponse;
|
|
89
|
+
getCredentialsOptions(
|
|
90
|
+
requestMessage: auth_passkey_pb.PasskeyProto.GetCredentialsRequest,
|
|
91
|
+
callback: (error: ServiceError|null, responseMessage: auth_passkey_pb.PasskeyProto.CredentialCreateOptions|null) => void
|
|
92
|
+
): UnaryResponse;
|
|
93
|
+
createCredential(
|
|
94
|
+
requestMessage: auth_passkey_pb.PasskeyProto.CreateCredentialsRequest,
|
|
95
|
+
metadata: grpc.Metadata,
|
|
96
|
+
callback: (error: ServiceError|null, responseMessage: auth_passkey_pb.PasskeyProto|null) => void
|
|
97
|
+
): UnaryResponse;
|
|
98
|
+
createCredential(
|
|
99
|
+
requestMessage: auth_passkey_pb.PasskeyProto.CreateCredentialsRequest,
|
|
100
|
+
callback: (error: ServiceError|null, responseMessage: auth_passkey_pb.PasskeyProto|null) => void
|
|
101
|
+
): UnaryResponse;
|
|
102
|
+
getAssertionOptions(
|
|
103
|
+
requestMessage: auth_passkey_pb.PasskeyProto.GetAssertionOptionsRequest,
|
|
104
|
+
metadata: grpc.Metadata,
|
|
105
|
+
callback: (error: ServiceError|null, responseMessage: auth_passkey_pb.PasskeyProto.AssertionOptions|null) => void
|
|
106
|
+
): UnaryResponse;
|
|
107
|
+
getAssertionOptions(
|
|
108
|
+
requestMessage: auth_passkey_pb.PasskeyProto.GetAssertionOptionsRequest,
|
|
109
|
+
callback: (error: ServiceError|null, responseMessage: auth_passkey_pb.PasskeyProto.AssertionOptions|null) => void
|
|
110
|
+
): UnaryResponse;
|
|
111
|
+
makeAssertion(
|
|
112
|
+
requestMessage: auth_passkey_pb.PasskeyProto.MakeAssertionRequest,
|
|
113
|
+
metadata: grpc.Metadata,
|
|
114
|
+
callback: (error: ServiceError|null, responseMessage: auth_authn_pb.AuthnProto|null) => void
|
|
115
|
+
): UnaryResponse;
|
|
116
|
+
makeAssertion(
|
|
117
|
+
requestMessage: auth_passkey_pb.PasskeyProto.MakeAssertionRequest,
|
|
118
|
+
callback: (error: ServiceError|null, responseMessage: auth_authn_pb.AuthnProto|null) => void
|
|
119
|
+
): UnaryResponse;
|
|
120
|
+
}
|
|
121
|
+
|
|
@@ -0,0 +1,182 @@
|
|
|
1
|
+
// package: Auth
|
|
2
|
+
// file: auth.passkey.proto
|
|
3
|
+
|
|
4
|
+
var auth_passkey_pb = require("./auth.passkey_pb");
|
|
5
|
+
var auth_authn_pb = require("./auth.authn_pb");
|
|
6
|
+
var grpc = require("@improbable-eng/grpc-web").grpc;
|
|
7
|
+
|
|
8
|
+
var PassKeyGRPC = (function () {
|
|
9
|
+
function PassKeyGRPC() {}
|
|
10
|
+
PassKeyGRPC.serviceName = "Auth.PassKeyGRPC";
|
|
11
|
+
return PassKeyGRPC;
|
|
12
|
+
}());
|
|
13
|
+
|
|
14
|
+
PassKeyGRPC.GetCredentialsOptions = {
|
|
15
|
+
methodName: "GetCredentialsOptions",
|
|
16
|
+
service: PassKeyGRPC,
|
|
17
|
+
requestStream: false,
|
|
18
|
+
responseStream: false,
|
|
19
|
+
requestType: auth_passkey_pb.PasskeyProto.GetCredentialsRequest,
|
|
20
|
+
responseType: auth_passkey_pb.PasskeyProto.CredentialCreateOptions
|
|
21
|
+
};
|
|
22
|
+
|
|
23
|
+
PassKeyGRPC.CreateCredential = {
|
|
24
|
+
methodName: "CreateCredential",
|
|
25
|
+
service: PassKeyGRPC,
|
|
26
|
+
requestStream: false,
|
|
27
|
+
responseStream: false,
|
|
28
|
+
requestType: auth_passkey_pb.PasskeyProto.CreateCredentialsRequest,
|
|
29
|
+
responseType: auth_passkey_pb.PasskeyProto
|
|
30
|
+
};
|
|
31
|
+
|
|
32
|
+
PassKeyGRPC.GetAssertionOptions = {
|
|
33
|
+
methodName: "GetAssertionOptions",
|
|
34
|
+
service: PassKeyGRPC,
|
|
35
|
+
requestStream: false,
|
|
36
|
+
responseStream: false,
|
|
37
|
+
requestType: auth_passkey_pb.PasskeyProto.GetAssertionOptionsRequest,
|
|
38
|
+
responseType: auth_passkey_pb.PasskeyProto.AssertionOptions
|
|
39
|
+
};
|
|
40
|
+
|
|
41
|
+
PassKeyGRPC.MakeAssertion = {
|
|
42
|
+
methodName: "MakeAssertion",
|
|
43
|
+
service: PassKeyGRPC,
|
|
44
|
+
requestStream: false,
|
|
45
|
+
responseStream: false,
|
|
46
|
+
requestType: auth_passkey_pb.PasskeyProto.MakeAssertionRequest,
|
|
47
|
+
responseType: auth_authn_pb.AuthnProto
|
|
48
|
+
};
|
|
49
|
+
|
|
50
|
+
exports.PassKeyGRPC = PassKeyGRPC;
|
|
51
|
+
|
|
52
|
+
function PassKeyGRPCClient(serviceHost, options) {
|
|
53
|
+
this.serviceHost = serviceHost;
|
|
54
|
+
this.options = options || {};
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
PassKeyGRPCClient.prototype.getCredentialsOptions = function getCredentialsOptions(requestMessage, metadata, callback) {
|
|
58
|
+
if (arguments.length === 2) {
|
|
59
|
+
callback = arguments[1];
|
|
60
|
+
}
|
|
61
|
+
var client = grpc.unary(PassKeyGRPC.GetCredentialsOptions, {
|
|
62
|
+
request: requestMessage,
|
|
63
|
+
host: this.serviceHost,
|
|
64
|
+
metadata: metadata,
|
|
65
|
+
transport: this.options.transport,
|
|
66
|
+
debug: this.options.debug,
|
|
67
|
+
onEnd: function (response) {
|
|
68
|
+
if (callback) {
|
|
69
|
+
if (response.status !== grpc.Code.OK) {
|
|
70
|
+
var err = new Error(response.statusMessage);
|
|
71
|
+
err.code = response.status;
|
|
72
|
+
err.metadata = response.trailers;
|
|
73
|
+
callback(err, null);
|
|
74
|
+
} else {
|
|
75
|
+
callback(null, response.message);
|
|
76
|
+
}
|
|
77
|
+
}
|
|
78
|
+
}
|
|
79
|
+
});
|
|
80
|
+
return {
|
|
81
|
+
cancel: function () {
|
|
82
|
+
callback = null;
|
|
83
|
+
client.close();
|
|
84
|
+
}
|
|
85
|
+
};
|
|
86
|
+
};
|
|
87
|
+
|
|
88
|
+
PassKeyGRPCClient.prototype.createCredential = function createCredential(requestMessage, metadata, callback) {
|
|
89
|
+
if (arguments.length === 2) {
|
|
90
|
+
callback = arguments[1];
|
|
91
|
+
}
|
|
92
|
+
var client = grpc.unary(PassKeyGRPC.CreateCredential, {
|
|
93
|
+
request: requestMessage,
|
|
94
|
+
host: this.serviceHost,
|
|
95
|
+
metadata: metadata,
|
|
96
|
+
transport: this.options.transport,
|
|
97
|
+
debug: this.options.debug,
|
|
98
|
+
onEnd: function (response) {
|
|
99
|
+
if (callback) {
|
|
100
|
+
if (response.status !== grpc.Code.OK) {
|
|
101
|
+
var err = new Error(response.statusMessage);
|
|
102
|
+
err.code = response.status;
|
|
103
|
+
err.metadata = response.trailers;
|
|
104
|
+
callback(err, null);
|
|
105
|
+
} else {
|
|
106
|
+
callback(null, response.message);
|
|
107
|
+
}
|
|
108
|
+
}
|
|
109
|
+
}
|
|
110
|
+
});
|
|
111
|
+
return {
|
|
112
|
+
cancel: function () {
|
|
113
|
+
callback = null;
|
|
114
|
+
client.close();
|
|
115
|
+
}
|
|
116
|
+
};
|
|
117
|
+
};
|
|
118
|
+
|
|
119
|
+
PassKeyGRPCClient.prototype.getAssertionOptions = function getAssertionOptions(requestMessage, metadata, callback) {
|
|
120
|
+
if (arguments.length === 2) {
|
|
121
|
+
callback = arguments[1];
|
|
122
|
+
}
|
|
123
|
+
var client = grpc.unary(PassKeyGRPC.GetAssertionOptions, {
|
|
124
|
+
request: requestMessage,
|
|
125
|
+
host: this.serviceHost,
|
|
126
|
+
metadata: metadata,
|
|
127
|
+
transport: this.options.transport,
|
|
128
|
+
debug: this.options.debug,
|
|
129
|
+
onEnd: function (response) {
|
|
130
|
+
if (callback) {
|
|
131
|
+
if (response.status !== grpc.Code.OK) {
|
|
132
|
+
var err = new Error(response.statusMessage);
|
|
133
|
+
err.code = response.status;
|
|
134
|
+
err.metadata = response.trailers;
|
|
135
|
+
callback(err, null);
|
|
136
|
+
} else {
|
|
137
|
+
callback(null, response.message);
|
|
138
|
+
}
|
|
139
|
+
}
|
|
140
|
+
}
|
|
141
|
+
});
|
|
142
|
+
return {
|
|
143
|
+
cancel: function () {
|
|
144
|
+
callback = null;
|
|
145
|
+
client.close();
|
|
146
|
+
}
|
|
147
|
+
};
|
|
148
|
+
};
|
|
149
|
+
|
|
150
|
+
PassKeyGRPCClient.prototype.makeAssertion = function makeAssertion(requestMessage, metadata, callback) {
|
|
151
|
+
if (arguments.length === 2) {
|
|
152
|
+
callback = arguments[1];
|
|
153
|
+
}
|
|
154
|
+
var client = grpc.unary(PassKeyGRPC.MakeAssertion, {
|
|
155
|
+
request: requestMessage,
|
|
156
|
+
host: this.serviceHost,
|
|
157
|
+
metadata: metadata,
|
|
158
|
+
transport: this.options.transport,
|
|
159
|
+
debug: this.options.debug,
|
|
160
|
+
onEnd: function (response) {
|
|
161
|
+
if (callback) {
|
|
162
|
+
if (response.status !== grpc.Code.OK) {
|
|
163
|
+
var err = new Error(response.statusMessage);
|
|
164
|
+
err.code = response.status;
|
|
165
|
+
err.metadata = response.trailers;
|
|
166
|
+
callback(err, null);
|
|
167
|
+
} else {
|
|
168
|
+
callback(null, response.message);
|
|
169
|
+
}
|
|
170
|
+
}
|
|
171
|
+
}
|
|
172
|
+
});
|
|
173
|
+
return {
|
|
174
|
+
cancel: function () {
|
|
175
|
+
callback = null;
|
|
176
|
+
client.close();
|
|
177
|
+
}
|
|
178
|
+
};
|
|
179
|
+
};
|
|
180
|
+
|
|
181
|
+
exports.PassKeyGRPCClient = PassKeyGRPCClient;
|
|
182
|
+
|