@flashstart/client 0.1.1 → 8.10.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/README.md +9 -2
- package/dist/src/generated/authentication/client/client.gen.d.ts +2 -0
- package/dist/src/generated/authentication/client/client.gen.js +216 -0
- package/dist/src/generated/authentication/client/index.d.ts +10 -0
- package/dist/src/generated/authentication/client/index.js +6 -0
- package/dist/src/generated/authentication/client/types.gen.d.ts +120 -0
- package/dist/src/generated/authentication/client/types.gen.js +2 -0
- package/dist/src/generated/authentication/client/utils.gen.d.ts +37 -0
- package/dist/src/generated/authentication/client/utils.gen.js +228 -0
- package/dist/src/generated/authentication/client.gen.d.ts +12 -0
- package/dist/src/generated/authentication/client.gen.js +3 -0
- package/dist/src/generated/authentication/core/auth.gen.d.ts +25 -0
- package/dist/src/generated/authentication/core/auth.gen.js +14 -0
- package/dist/src/generated/authentication/core/bodySerializer.gen.d.ts +25 -0
- package/dist/src/generated/authentication/core/bodySerializer.gen.js +57 -0
- package/dist/src/generated/authentication/core/params.gen.d.ts +43 -0
- package/dist/src/generated/authentication/core/params.gen.js +109 -0
- package/dist/src/generated/authentication/core/pathSerializer.gen.d.ts +33 -0
- package/dist/src/generated/authentication/core/pathSerializer.gen.js +106 -0
- package/dist/src/generated/authentication/core/queryKeySerializer.gen.d.ts +18 -0
- package/dist/src/generated/authentication/core/queryKeySerializer.gen.js +92 -0
- package/dist/src/generated/authentication/core/serverSentEvents.gen.d.ts +71 -0
- package/dist/src/generated/authentication/core/serverSentEvents.gen.js +132 -0
- package/dist/src/generated/authentication/core/types.gen.d.ts +83 -0
- package/dist/src/generated/authentication/core/types.gen.js +2 -0
- package/dist/src/generated/authentication/core/utils.gen.d.ts +19 -0
- package/dist/src/generated/authentication/core/utils.gen.js +87 -0
- package/dist/src/generated/authentication/index.d.ts +2 -0
- package/dist/src/generated/authentication/index.js +2 -0
- package/dist/src/generated/authentication/sdk.gen.d.ts +159 -0
- package/dist/src/generated/authentication/sdk.gen.js +371 -0
- package/dist/src/generated/authentication/types.gen.d.ts +1135 -0
- package/dist/src/generated/authentication/types.gen.js +2 -0
- package/dist/src/generated/integration/client/client.gen.d.ts +2 -0
- package/dist/src/generated/integration/client/client.gen.js +216 -0
- package/dist/src/generated/integration/client/index.d.ts +10 -0
- package/dist/src/generated/integration/client/index.js +6 -0
- package/dist/src/generated/integration/client/types.gen.d.ts +120 -0
- package/dist/src/generated/integration/client/types.gen.js +2 -0
- package/dist/src/generated/integration/client/utils.gen.d.ts +37 -0
- package/dist/src/generated/integration/client/utils.gen.js +228 -0
- package/dist/src/generated/integration/client.gen.d.ts +12 -0
- package/dist/src/generated/integration/client.gen.js +3 -0
- package/dist/src/generated/integration/core/auth.gen.d.ts +25 -0
- package/dist/src/generated/integration/core/auth.gen.js +14 -0
- package/dist/src/generated/integration/core/bodySerializer.gen.d.ts +25 -0
- package/dist/src/generated/integration/core/bodySerializer.gen.js +57 -0
- package/dist/src/generated/integration/core/params.gen.d.ts +43 -0
- package/dist/src/generated/integration/core/params.gen.js +109 -0
- package/dist/src/generated/integration/core/pathSerializer.gen.d.ts +33 -0
- package/dist/src/generated/integration/core/pathSerializer.gen.js +106 -0
- package/dist/src/generated/integration/core/queryKeySerializer.gen.d.ts +18 -0
- package/dist/src/generated/integration/core/queryKeySerializer.gen.js +92 -0
- package/dist/src/generated/integration/core/serverSentEvents.gen.d.ts +71 -0
- package/dist/src/generated/integration/core/serverSentEvents.gen.js +132 -0
- package/dist/src/generated/integration/core/types.gen.d.ts +83 -0
- package/dist/src/generated/integration/core/types.gen.js +2 -0
- package/dist/src/generated/integration/core/utils.gen.d.ts +19 -0
- package/dist/src/generated/integration/core/utils.gen.js +87 -0
- package/dist/src/generated/integration/index.d.ts +2 -0
- package/dist/src/generated/integration/index.js +2 -0
- package/dist/src/generated/integration/sdk.gen.d.ts +211 -0
- package/dist/src/generated/integration/sdk.gen.js +537 -0
- package/dist/src/generated/integration/types.gen.d.ts +2658 -0
- package/dist/src/generated/integration/types.gen.js +2 -0
- package/dist/src/generated/network/index.d.ts +1 -1
- package/dist/src/generated/network/types.gen.d.ts +751 -55
- package/dist/src/generated/protection/index.d.ts +1 -1
- package/dist/src/generated/protection/types.gen.d.ts +627 -357
- package/dist/src/generated/report/client/client.gen.d.ts +2 -0
- package/dist/src/generated/report/client/client.gen.js +216 -0
- package/dist/src/generated/report/client/index.d.ts +10 -0
- package/dist/src/generated/report/client/index.js +6 -0
- package/dist/src/generated/report/client/types.gen.d.ts +120 -0
- package/dist/src/generated/report/client/types.gen.js +2 -0
- package/dist/src/generated/report/client/utils.gen.d.ts +37 -0
- package/dist/src/generated/report/client/utils.gen.js +228 -0
- package/dist/src/generated/report/client.gen.d.ts +12 -0
- package/dist/src/generated/report/client.gen.js +3 -0
- package/dist/src/generated/report/core/auth.gen.d.ts +25 -0
- package/dist/src/generated/report/core/auth.gen.js +14 -0
- package/dist/src/generated/report/core/bodySerializer.gen.d.ts +25 -0
- package/dist/src/generated/report/core/bodySerializer.gen.js +57 -0
- package/dist/src/generated/report/core/params.gen.d.ts +43 -0
- package/dist/src/generated/report/core/params.gen.js +109 -0
- package/dist/src/generated/report/core/pathSerializer.gen.d.ts +33 -0
- package/dist/src/generated/report/core/pathSerializer.gen.js +106 -0
- package/dist/src/generated/report/core/queryKeySerializer.gen.d.ts +18 -0
- package/dist/src/generated/report/core/queryKeySerializer.gen.js +92 -0
- package/dist/src/generated/report/core/serverSentEvents.gen.d.ts +71 -0
- package/dist/src/generated/report/core/serverSentEvents.gen.js +132 -0
- package/dist/src/generated/report/core/types.gen.d.ts +83 -0
- package/dist/src/generated/report/core/types.gen.js +2 -0
- package/dist/src/generated/report/core/utils.gen.d.ts +19 -0
- package/dist/src/generated/report/core/utils.gen.js +87 -0
- package/dist/src/generated/report/index.d.ts +2 -0
- package/dist/src/generated/report/index.js +2 -0
- package/dist/src/generated/report/sdk.gen.d.ts +59 -0
- package/dist/src/generated/report/sdk.gen.js +89 -0
- package/dist/src/generated/report/types.gen.d.ts +389 -0
- package/dist/src/generated/report/types.gen.js +2 -0
- package/dist/src/index.d.ts +13 -1
- package/dist/src/index.js +39 -4
- package/package.json +6 -4
|
@@ -0,0 +1,2658 @@
|
|
|
1
|
+
export type ClientOptions = {
|
|
2
|
+
baseUrl: 'https://core.flashstart.com/integration' | (string & {});
|
|
3
|
+
};
|
|
4
|
+
export type FlashStartErrorBody = {
|
|
5
|
+
code: string;
|
|
6
|
+
message?: string;
|
|
7
|
+
details?: unknown;
|
|
8
|
+
};
|
|
9
|
+
export type MissingCredentialsErrorBody = {
|
|
10
|
+
message: string;
|
|
11
|
+
};
|
|
12
|
+
export type GetCloudBoxDnsRoutesData = {
|
|
13
|
+
body?: never;
|
|
14
|
+
path?: never;
|
|
15
|
+
query?: {
|
|
16
|
+
organizationId?: string;
|
|
17
|
+
};
|
|
18
|
+
url: '/v1/dns-routes/cloudbox';
|
|
19
|
+
};
|
|
20
|
+
export type GetCloudBoxDnsRoutesErrors = {
|
|
21
|
+
/**
|
|
22
|
+
* Unauthorized
|
|
23
|
+
*/
|
|
24
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
25
|
+
/**
|
|
26
|
+
* Forbidden
|
|
27
|
+
*/
|
|
28
|
+
403: FlashStartErrorBody;
|
|
29
|
+
/**
|
|
30
|
+
* Not found
|
|
31
|
+
*/
|
|
32
|
+
404: FlashStartErrorBody;
|
|
33
|
+
/**
|
|
34
|
+
* Invalid request
|
|
35
|
+
*/
|
|
36
|
+
422: FlashStartErrorBody;
|
|
37
|
+
/**
|
|
38
|
+
* Internal server error
|
|
39
|
+
*/
|
|
40
|
+
500: FlashStartErrorBody;
|
|
41
|
+
};
|
|
42
|
+
export type GetCloudBoxDnsRoutesError = GetCloudBoxDnsRoutesErrors[keyof GetCloudBoxDnsRoutesErrors];
|
|
43
|
+
export type GetCloudBoxDnsRoutesResponses = {
|
|
44
|
+
/**
|
|
45
|
+
* CloudBox DNS routes
|
|
46
|
+
*/
|
|
47
|
+
200: Array<{
|
|
48
|
+
id: string;
|
|
49
|
+
primaryForwardIp: string;
|
|
50
|
+
secondaryForwardIp?: string;
|
|
51
|
+
domain: string;
|
|
52
|
+
deviceIds: Array<string>;
|
|
53
|
+
organizationId: string;
|
|
54
|
+
target: 'CLOUDBOX' | 'ENDPOINT';
|
|
55
|
+
}>;
|
|
56
|
+
};
|
|
57
|
+
export type GetCloudBoxDnsRoutesResponse = GetCloudBoxDnsRoutesResponses[keyof GetCloudBoxDnsRoutesResponses];
|
|
58
|
+
export type CreateCloudBoxDnsRouteData = {
|
|
59
|
+
body: {
|
|
60
|
+
domain: string;
|
|
61
|
+
primaryForwardIp: string | string;
|
|
62
|
+
secondaryForwardIp?: string | string;
|
|
63
|
+
organizationId: string;
|
|
64
|
+
};
|
|
65
|
+
path?: never;
|
|
66
|
+
query?: never;
|
|
67
|
+
url: '/v1/dns-routes/cloudbox';
|
|
68
|
+
};
|
|
69
|
+
export type CreateCloudBoxDnsRouteErrors = {
|
|
70
|
+
/**
|
|
71
|
+
* Unauthorized
|
|
72
|
+
*/
|
|
73
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
74
|
+
/**
|
|
75
|
+
* Forbidden
|
|
76
|
+
*/
|
|
77
|
+
403: FlashStartErrorBody;
|
|
78
|
+
/**
|
|
79
|
+
* Not found
|
|
80
|
+
*/
|
|
81
|
+
404: FlashStartErrorBody;
|
|
82
|
+
/**
|
|
83
|
+
* Invalid request
|
|
84
|
+
*/
|
|
85
|
+
422: FlashStartErrorBody;
|
|
86
|
+
/**
|
|
87
|
+
* Internal server error
|
|
88
|
+
*/
|
|
89
|
+
500: FlashStartErrorBody;
|
|
90
|
+
};
|
|
91
|
+
export type CreateCloudBoxDnsRouteError = CreateCloudBoxDnsRouteErrors[keyof CreateCloudBoxDnsRouteErrors];
|
|
92
|
+
export type CreateCloudBoxDnsRouteResponses = {
|
|
93
|
+
/**
|
|
94
|
+
* Created CloudBox DNS route
|
|
95
|
+
*/
|
|
96
|
+
201: {
|
|
97
|
+
id: string;
|
|
98
|
+
primaryForwardIp: string;
|
|
99
|
+
secondaryForwardIp?: string;
|
|
100
|
+
domain: string;
|
|
101
|
+
deviceIds: Array<string>;
|
|
102
|
+
organizationId: string;
|
|
103
|
+
target: 'CLOUDBOX' | 'ENDPOINT';
|
|
104
|
+
};
|
|
105
|
+
};
|
|
106
|
+
export type CreateCloudBoxDnsRouteResponse = CreateCloudBoxDnsRouteResponses[keyof CreateCloudBoxDnsRouteResponses];
|
|
107
|
+
export type DeleteCloudBoxDnsRouteData = {
|
|
108
|
+
body?: never;
|
|
109
|
+
path: {
|
|
110
|
+
dnsRouteId: string;
|
|
111
|
+
};
|
|
112
|
+
query?: never;
|
|
113
|
+
url: '/v1/dns-routes/cloudbox/{dnsRouteId}';
|
|
114
|
+
};
|
|
115
|
+
export type DeleteCloudBoxDnsRouteErrors = {
|
|
116
|
+
/**
|
|
117
|
+
* Unauthorized
|
|
118
|
+
*/
|
|
119
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
120
|
+
/**
|
|
121
|
+
* Forbidden
|
|
122
|
+
*/
|
|
123
|
+
403: FlashStartErrorBody;
|
|
124
|
+
/**
|
|
125
|
+
* Not found
|
|
126
|
+
*/
|
|
127
|
+
404: FlashStartErrorBody;
|
|
128
|
+
/**
|
|
129
|
+
* Invalid request
|
|
130
|
+
*/
|
|
131
|
+
422: FlashStartErrorBody;
|
|
132
|
+
/**
|
|
133
|
+
* Internal server error
|
|
134
|
+
*/
|
|
135
|
+
500: FlashStartErrorBody;
|
|
136
|
+
};
|
|
137
|
+
export type DeleteCloudBoxDnsRouteError = DeleteCloudBoxDnsRouteErrors[keyof DeleteCloudBoxDnsRouteErrors];
|
|
138
|
+
export type DeleteCloudBoxDnsRouteResponses = {
|
|
139
|
+
/**
|
|
140
|
+
* Deleted CloudBox DNS route
|
|
141
|
+
*/
|
|
142
|
+
200: {
|
|
143
|
+
id: string;
|
|
144
|
+
primaryForwardIp: string;
|
|
145
|
+
secondaryForwardIp?: string;
|
|
146
|
+
domain: string;
|
|
147
|
+
deviceIds: Array<string>;
|
|
148
|
+
organizationId: string;
|
|
149
|
+
target: 'CLOUDBOX' | 'ENDPOINT';
|
|
150
|
+
};
|
|
151
|
+
};
|
|
152
|
+
export type DeleteCloudBoxDnsRouteResponse = DeleteCloudBoxDnsRouteResponses[keyof DeleteCloudBoxDnsRouteResponses];
|
|
153
|
+
export type GetEndPointDnsRoutesData = {
|
|
154
|
+
body?: never;
|
|
155
|
+
path?: never;
|
|
156
|
+
query?: {
|
|
157
|
+
organizationId?: string;
|
|
158
|
+
};
|
|
159
|
+
url: '/v1/dns-routes/endpoint-policy';
|
|
160
|
+
};
|
|
161
|
+
export type GetEndPointDnsRoutesErrors = {
|
|
162
|
+
/**
|
|
163
|
+
* Unauthorized
|
|
164
|
+
*/
|
|
165
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
166
|
+
/**
|
|
167
|
+
* Forbidden
|
|
168
|
+
*/
|
|
169
|
+
403: FlashStartErrorBody;
|
|
170
|
+
/**
|
|
171
|
+
* Not found
|
|
172
|
+
*/
|
|
173
|
+
404: FlashStartErrorBody;
|
|
174
|
+
/**
|
|
175
|
+
* Invalid request
|
|
176
|
+
*/
|
|
177
|
+
422: FlashStartErrorBody;
|
|
178
|
+
/**
|
|
179
|
+
* Internal server error
|
|
180
|
+
*/
|
|
181
|
+
500: FlashStartErrorBody;
|
|
182
|
+
};
|
|
183
|
+
export type GetEndPointDnsRoutesError = GetEndPointDnsRoutesErrors[keyof GetEndPointDnsRoutesErrors];
|
|
184
|
+
export type GetEndPointDnsRoutesResponses = {
|
|
185
|
+
/**
|
|
186
|
+
* Endpoint DNS routes
|
|
187
|
+
*/
|
|
188
|
+
200: Array<{
|
|
189
|
+
id: string;
|
|
190
|
+
primaryForwardIp: string;
|
|
191
|
+
secondaryForwardIp?: string;
|
|
192
|
+
domain: string;
|
|
193
|
+
endpointPolicyIds: Array<string>;
|
|
194
|
+
organizationId: string;
|
|
195
|
+
target: 'CLOUDBOX' | 'ENDPOINT';
|
|
196
|
+
}>;
|
|
197
|
+
};
|
|
198
|
+
export type GetEndPointDnsRoutesResponse = GetEndPointDnsRoutesResponses[keyof GetEndPointDnsRoutesResponses];
|
|
199
|
+
export type CreateEndPointDnsRouteData = {
|
|
200
|
+
body: {
|
|
201
|
+
domain: string;
|
|
202
|
+
primaryForwardIp: string | string;
|
|
203
|
+
secondaryForwardIp?: string | string;
|
|
204
|
+
organizationId: string;
|
|
205
|
+
};
|
|
206
|
+
path?: never;
|
|
207
|
+
query?: never;
|
|
208
|
+
url: '/v1/dns-routes/endpoint-policy';
|
|
209
|
+
};
|
|
210
|
+
export type CreateEndPointDnsRouteErrors = {
|
|
211
|
+
/**
|
|
212
|
+
* Unauthorized
|
|
213
|
+
*/
|
|
214
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
215
|
+
/**
|
|
216
|
+
* Forbidden
|
|
217
|
+
*/
|
|
218
|
+
403: FlashStartErrorBody;
|
|
219
|
+
/**
|
|
220
|
+
* Not found
|
|
221
|
+
*/
|
|
222
|
+
404: FlashStartErrorBody;
|
|
223
|
+
/**
|
|
224
|
+
* Invalid request
|
|
225
|
+
*/
|
|
226
|
+
422: FlashStartErrorBody;
|
|
227
|
+
/**
|
|
228
|
+
* Internal server error
|
|
229
|
+
*/
|
|
230
|
+
500: FlashStartErrorBody;
|
|
231
|
+
};
|
|
232
|
+
export type CreateEndPointDnsRouteError = CreateEndPointDnsRouteErrors[keyof CreateEndPointDnsRouteErrors];
|
|
233
|
+
export type CreateEndPointDnsRouteResponses = {
|
|
234
|
+
/**
|
|
235
|
+
* Created Endpoint DNS route
|
|
236
|
+
*/
|
|
237
|
+
201: {
|
|
238
|
+
id: string;
|
|
239
|
+
primaryForwardIp: string;
|
|
240
|
+
secondaryForwardIp?: string;
|
|
241
|
+
domain: string;
|
|
242
|
+
endpointPolicyIds: Array<string>;
|
|
243
|
+
organizationId: string;
|
|
244
|
+
target: 'CLOUDBOX' | 'ENDPOINT';
|
|
245
|
+
};
|
|
246
|
+
};
|
|
247
|
+
export type CreateEndPointDnsRouteResponse = CreateEndPointDnsRouteResponses[keyof CreateEndPointDnsRouteResponses];
|
|
248
|
+
export type DeleteEndPointDnsRouteData = {
|
|
249
|
+
body?: never;
|
|
250
|
+
path: {
|
|
251
|
+
dnsRouteId: string;
|
|
252
|
+
};
|
|
253
|
+
query?: never;
|
|
254
|
+
url: '/v1/dns-routes/endpoint-policy/{dnsRouteId}';
|
|
255
|
+
};
|
|
256
|
+
export type DeleteEndPointDnsRouteErrors = {
|
|
257
|
+
/**
|
|
258
|
+
* Unauthorized
|
|
259
|
+
*/
|
|
260
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
261
|
+
/**
|
|
262
|
+
* Forbidden
|
|
263
|
+
*/
|
|
264
|
+
403: FlashStartErrorBody;
|
|
265
|
+
/**
|
|
266
|
+
* Not found
|
|
267
|
+
*/
|
|
268
|
+
404: FlashStartErrorBody;
|
|
269
|
+
/**
|
|
270
|
+
* Invalid request
|
|
271
|
+
*/
|
|
272
|
+
422: FlashStartErrorBody;
|
|
273
|
+
/**
|
|
274
|
+
* Internal server error
|
|
275
|
+
*/
|
|
276
|
+
500: FlashStartErrorBody;
|
|
277
|
+
};
|
|
278
|
+
export type DeleteEndPointDnsRouteError = DeleteEndPointDnsRouteErrors[keyof DeleteEndPointDnsRouteErrors];
|
|
279
|
+
export type DeleteEndPointDnsRouteResponses = {
|
|
280
|
+
/**
|
|
281
|
+
* Deleted Endpoint DNS route
|
|
282
|
+
*/
|
|
283
|
+
200: {
|
|
284
|
+
id: string;
|
|
285
|
+
primaryForwardIp: string;
|
|
286
|
+
secondaryForwardIp?: string;
|
|
287
|
+
domain: string;
|
|
288
|
+
endpointPolicyIds: Array<string>;
|
|
289
|
+
organizationId: string;
|
|
290
|
+
target: 'CLOUDBOX' | 'ENDPOINT';
|
|
291
|
+
};
|
|
292
|
+
};
|
|
293
|
+
export type DeleteEndPointDnsRouteResponse = DeleteEndPointDnsRouteResponses[keyof DeleteEndPointDnsRouteResponses];
|
|
294
|
+
export type AssociateCloudBoxDnsRouteData = {
|
|
295
|
+
body: {
|
|
296
|
+
cloudboxId: string;
|
|
297
|
+
};
|
|
298
|
+
path: {
|
|
299
|
+
dnsRouteId: string;
|
|
300
|
+
};
|
|
301
|
+
query?: never;
|
|
302
|
+
url: '/v1/dns-routes/{dnsRouteId}/cloudbox';
|
|
303
|
+
};
|
|
304
|
+
export type AssociateCloudBoxDnsRouteErrors = {
|
|
305
|
+
/**
|
|
306
|
+
* Unauthorized
|
|
307
|
+
*/
|
|
308
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
309
|
+
/**
|
|
310
|
+
* Forbidden
|
|
311
|
+
*/
|
|
312
|
+
403: FlashStartErrorBody;
|
|
313
|
+
/**
|
|
314
|
+
* Not found
|
|
315
|
+
*/
|
|
316
|
+
404: FlashStartErrorBody;
|
|
317
|
+
/**
|
|
318
|
+
* Invalid request
|
|
319
|
+
*/
|
|
320
|
+
422: FlashStartErrorBody;
|
|
321
|
+
/**
|
|
322
|
+
* Internal server error
|
|
323
|
+
*/
|
|
324
|
+
500: FlashStartErrorBody;
|
|
325
|
+
};
|
|
326
|
+
export type AssociateCloudBoxDnsRouteError = AssociateCloudBoxDnsRouteErrors[keyof AssociateCloudBoxDnsRouteErrors];
|
|
327
|
+
export type AssociateCloudBoxDnsRouteResponses = {
|
|
328
|
+
/**
|
|
329
|
+
* Associated DNS route
|
|
330
|
+
*/
|
|
331
|
+
201: {
|
|
332
|
+
id: string;
|
|
333
|
+
primaryForwardIp: string;
|
|
334
|
+
secondaryForwardIp?: string;
|
|
335
|
+
domain: string;
|
|
336
|
+
deviceIds: Array<string>;
|
|
337
|
+
organizationId: string;
|
|
338
|
+
target: 'CLOUDBOX' | 'ENDPOINT';
|
|
339
|
+
};
|
|
340
|
+
};
|
|
341
|
+
export type AssociateCloudBoxDnsRouteResponse = AssociateCloudBoxDnsRouteResponses[keyof AssociateCloudBoxDnsRouteResponses];
|
|
342
|
+
export type AssociateEndPointDnsRouteData = {
|
|
343
|
+
body: {
|
|
344
|
+
endpointPolicyId: string;
|
|
345
|
+
};
|
|
346
|
+
path: {
|
|
347
|
+
dnsRouteId: string;
|
|
348
|
+
};
|
|
349
|
+
query?: never;
|
|
350
|
+
url: '/v1/dns-routes/{dnsRouteId}/endpoint-policy';
|
|
351
|
+
};
|
|
352
|
+
export type AssociateEndPointDnsRouteErrors = {
|
|
353
|
+
/**
|
|
354
|
+
* Unauthorized
|
|
355
|
+
*/
|
|
356
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
357
|
+
/**
|
|
358
|
+
* Forbidden
|
|
359
|
+
*/
|
|
360
|
+
403: FlashStartErrorBody;
|
|
361
|
+
/**
|
|
362
|
+
* Not found
|
|
363
|
+
*/
|
|
364
|
+
404: FlashStartErrorBody;
|
|
365
|
+
/**
|
|
366
|
+
* Invalid request
|
|
367
|
+
*/
|
|
368
|
+
422: FlashStartErrorBody;
|
|
369
|
+
/**
|
|
370
|
+
* Internal server error
|
|
371
|
+
*/
|
|
372
|
+
500: FlashStartErrorBody;
|
|
373
|
+
};
|
|
374
|
+
export type AssociateEndPointDnsRouteError = AssociateEndPointDnsRouteErrors[keyof AssociateEndPointDnsRouteErrors];
|
|
375
|
+
export type AssociateEndPointDnsRouteResponses = {
|
|
376
|
+
/**
|
|
377
|
+
* Associated DNS route
|
|
378
|
+
*/
|
|
379
|
+
201: {
|
|
380
|
+
id: string;
|
|
381
|
+
primaryForwardIp: string;
|
|
382
|
+
secondaryForwardIp?: string;
|
|
383
|
+
domain: string;
|
|
384
|
+
endpointPolicyIds: Array<string>;
|
|
385
|
+
organizationId: string;
|
|
386
|
+
target: 'CLOUDBOX' | 'ENDPOINT';
|
|
387
|
+
};
|
|
388
|
+
};
|
|
389
|
+
export type AssociateEndPointDnsRouteResponse = AssociateEndPointDnsRouteResponses[keyof AssociateEndPointDnsRouteResponses];
|
|
390
|
+
export type DisassociateCloudBoxDnsRouteData = {
|
|
391
|
+
body?: never;
|
|
392
|
+
path: {
|
|
393
|
+
dnsRouteId: string;
|
|
394
|
+
cloudboxId: string;
|
|
395
|
+
};
|
|
396
|
+
query?: never;
|
|
397
|
+
url: '/v1/dns-routes/{dnsRouteId}/cloudbox/{cloudboxId}';
|
|
398
|
+
};
|
|
399
|
+
export type DisassociateCloudBoxDnsRouteErrors = {
|
|
400
|
+
/**
|
|
401
|
+
* Unauthorized
|
|
402
|
+
*/
|
|
403
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
404
|
+
/**
|
|
405
|
+
* Forbidden
|
|
406
|
+
*/
|
|
407
|
+
403: FlashStartErrorBody;
|
|
408
|
+
/**
|
|
409
|
+
* Not found
|
|
410
|
+
*/
|
|
411
|
+
404: FlashStartErrorBody;
|
|
412
|
+
/**
|
|
413
|
+
* Invalid request
|
|
414
|
+
*/
|
|
415
|
+
422: FlashStartErrorBody;
|
|
416
|
+
/**
|
|
417
|
+
* Internal server error
|
|
418
|
+
*/
|
|
419
|
+
500: FlashStartErrorBody;
|
|
420
|
+
};
|
|
421
|
+
export type DisassociateCloudBoxDnsRouteError = DisassociateCloudBoxDnsRouteErrors[keyof DisassociateCloudBoxDnsRouteErrors];
|
|
422
|
+
export type DisassociateCloudBoxDnsRouteResponses = {
|
|
423
|
+
/**
|
|
424
|
+
* Disassociated DNS route
|
|
425
|
+
*/
|
|
426
|
+
200: {
|
|
427
|
+
id: string;
|
|
428
|
+
primaryForwardIp: string;
|
|
429
|
+
secondaryForwardIp?: string;
|
|
430
|
+
domain: string;
|
|
431
|
+
deviceIds: Array<string>;
|
|
432
|
+
organizationId: string;
|
|
433
|
+
target: 'CLOUDBOX' | 'ENDPOINT';
|
|
434
|
+
};
|
|
435
|
+
};
|
|
436
|
+
export type DisassociateCloudBoxDnsRouteResponse = DisassociateCloudBoxDnsRouteResponses[keyof DisassociateCloudBoxDnsRouteResponses];
|
|
437
|
+
export type DisassociateEndPointDnsRouteData = {
|
|
438
|
+
body?: never;
|
|
439
|
+
path: {
|
|
440
|
+
dnsRouteId: string;
|
|
441
|
+
endpointPolicyId: string;
|
|
442
|
+
};
|
|
443
|
+
query?: never;
|
|
444
|
+
url: '/v1/dns-routes/{dnsRouteId}/endpoint-policy/{endpointPolicyId}';
|
|
445
|
+
};
|
|
446
|
+
export type DisassociateEndPointDnsRouteErrors = {
|
|
447
|
+
/**
|
|
448
|
+
* Unauthorized
|
|
449
|
+
*/
|
|
450
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
451
|
+
/**
|
|
452
|
+
* Forbidden
|
|
453
|
+
*/
|
|
454
|
+
403: FlashStartErrorBody;
|
|
455
|
+
/**
|
|
456
|
+
* Not found
|
|
457
|
+
*/
|
|
458
|
+
404: FlashStartErrorBody;
|
|
459
|
+
/**
|
|
460
|
+
* Invalid request
|
|
461
|
+
*/
|
|
462
|
+
422: FlashStartErrorBody;
|
|
463
|
+
/**
|
|
464
|
+
* Internal server error
|
|
465
|
+
*/
|
|
466
|
+
500: FlashStartErrorBody;
|
|
467
|
+
};
|
|
468
|
+
export type DisassociateEndPointDnsRouteError = DisassociateEndPointDnsRouteErrors[keyof DisassociateEndPointDnsRouteErrors];
|
|
469
|
+
export type DisassociateEndPointDnsRouteResponses = {
|
|
470
|
+
/**
|
|
471
|
+
* Disassociated DNS route
|
|
472
|
+
*/
|
|
473
|
+
200: {
|
|
474
|
+
id: string;
|
|
475
|
+
primaryForwardIp: string;
|
|
476
|
+
secondaryForwardIp?: string;
|
|
477
|
+
domain: string;
|
|
478
|
+
endpointPolicyIds: Array<string>;
|
|
479
|
+
organizationId: string;
|
|
480
|
+
target: 'CLOUDBOX' | 'ENDPOINT';
|
|
481
|
+
};
|
|
482
|
+
};
|
|
483
|
+
export type DisassociateEndPointDnsRouteResponse = DisassociateEndPointDnsRouteResponses[keyof DisassociateEndPointDnsRouteResponses];
|
|
484
|
+
export type DeleteDnsRouteData = {
|
|
485
|
+
body?: never;
|
|
486
|
+
path: {
|
|
487
|
+
dnsRouteId: string;
|
|
488
|
+
};
|
|
489
|
+
query?: never;
|
|
490
|
+
url: '/v1/dns-routes/{dnsRouteId}';
|
|
491
|
+
};
|
|
492
|
+
export type DeleteDnsRouteErrors = {
|
|
493
|
+
/**
|
|
494
|
+
* Unauthorized
|
|
495
|
+
*/
|
|
496
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
497
|
+
/**
|
|
498
|
+
* Forbidden
|
|
499
|
+
*/
|
|
500
|
+
403: FlashStartErrorBody;
|
|
501
|
+
/**
|
|
502
|
+
* Not found
|
|
503
|
+
*/
|
|
504
|
+
404: FlashStartErrorBody;
|
|
505
|
+
/**
|
|
506
|
+
* Invalid request
|
|
507
|
+
*/
|
|
508
|
+
422: FlashStartErrorBody;
|
|
509
|
+
/**
|
|
510
|
+
* Internal server error
|
|
511
|
+
*/
|
|
512
|
+
500: FlashStartErrorBody;
|
|
513
|
+
};
|
|
514
|
+
export type DeleteDnsRouteError = DeleteDnsRouteErrors[keyof DeleteDnsRouteErrors];
|
|
515
|
+
export type DeleteDnsRouteResponses = {
|
|
516
|
+
/**
|
|
517
|
+
* Deleted DNS route
|
|
518
|
+
*/
|
|
519
|
+
200: {
|
|
520
|
+
id: string;
|
|
521
|
+
primaryForwardIp: string;
|
|
522
|
+
secondaryForwardIp?: string;
|
|
523
|
+
domain: string;
|
|
524
|
+
deviceIds: Array<string>;
|
|
525
|
+
organizationId: string;
|
|
526
|
+
target: 'CLOUDBOX' | 'ENDPOINT';
|
|
527
|
+
};
|
|
528
|
+
};
|
|
529
|
+
export type DeleteDnsRouteResponse = DeleteDnsRouteResponses[keyof DeleteDnsRouteResponses];
|
|
530
|
+
export type GetDevicesData = {
|
|
531
|
+
body?: never;
|
|
532
|
+
path?: {
|
|
533
|
+
deviceType?: 'CLOUDBOX';
|
|
534
|
+
};
|
|
535
|
+
query?: {
|
|
536
|
+
organizationId?: string;
|
|
537
|
+
};
|
|
538
|
+
url: '/v1/devices/{deviceType}';
|
|
539
|
+
};
|
|
540
|
+
export type GetDevicesErrors = {
|
|
541
|
+
/**
|
|
542
|
+
* Unauthorized
|
|
543
|
+
*/
|
|
544
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
545
|
+
/**
|
|
546
|
+
* Forbidden
|
|
547
|
+
*/
|
|
548
|
+
403: FlashStartErrorBody;
|
|
549
|
+
/**
|
|
550
|
+
* Not found
|
|
551
|
+
*/
|
|
552
|
+
404: FlashStartErrorBody;
|
|
553
|
+
/**
|
|
554
|
+
* Invalid request
|
|
555
|
+
*/
|
|
556
|
+
422: FlashStartErrorBody;
|
|
557
|
+
/**
|
|
558
|
+
* Internal server error
|
|
559
|
+
*/
|
|
560
|
+
500: FlashStartErrorBody;
|
|
561
|
+
};
|
|
562
|
+
export type GetDevicesError = GetDevicesErrors[keyof GetDevicesErrors];
|
|
563
|
+
export type GetDevicesResponses = {
|
|
564
|
+
/**
|
|
565
|
+
* Devices
|
|
566
|
+
*/
|
|
567
|
+
200: Array<{
|
|
568
|
+
id: string;
|
|
569
|
+
networkId: string;
|
|
570
|
+
publicIp: string;
|
|
571
|
+
catchAllRule: {
|
|
572
|
+
id: string;
|
|
573
|
+
isLimited: boolean;
|
|
574
|
+
isShared: boolean;
|
|
575
|
+
name: string;
|
|
576
|
+
organizationId: string;
|
|
577
|
+
};
|
|
578
|
+
info: {
|
|
579
|
+
deviceId?: string;
|
|
580
|
+
localDnsIp?: string;
|
|
581
|
+
publicDnsFallback?: boolean;
|
|
582
|
+
version?: string;
|
|
583
|
+
lastVersionCheckTime?: string | string;
|
|
584
|
+
lastLoginCheckTime?: string | string;
|
|
585
|
+
hardwareModel?: string;
|
|
586
|
+
osVersion?: string;
|
|
587
|
+
releaseVersion?: string;
|
|
588
|
+
firmwareVersion?: string;
|
|
589
|
+
cpuUsage?: number;
|
|
590
|
+
ramUsage?: number;
|
|
591
|
+
diskUsage?: number;
|
|
592
|
+
uptime?: number;
|
|
593
|
+
temperature?: number;
|
|
594
|
+
metadata?: {
|
|
595
|
+
[key: string]: unknown;
|
|
596
|
+
};
|
|
597
|
+
};
|
|
598
|
+
name: string;
|
|
599
|
+
organizationId: string;
|
|
600
|
+
type: 'CLOUDBOX';
|
|
601
|
+
}>;
|
|
602
|
+
};
|
|
603
|
+
export type GetDevicesResponse = GetDevicesResponses[keyof GetDevicesResponses];
|
|
604
|
+
export type CreateDeviceData = {
|
|
605
|
+
body: {
|
|
606
|
+
name: string;
|
|
607
|
+
catchAllPolicyId: string;
|
|
608
|
+
username: string;
|
|
609
|
+
password: string;
|
|
610
|
+
organizationId: string;
|
|
611
|
+
note?: string;
|
|
612
|
+
};
|
|
613
|
+
path?: {
|
|
614
|
+
deviceType?: 'CLOUDBOX';
|
|
615
|
+
};
|
|
616
|
+
query?: never;
|
|
617
|
+
url: '/v1/devices/{deviceType}';
|
|
618
|
+
};
|
|
619
|
+
export type CreateDeviceErrors = {
|
|
620
|
+
/**
|
|
621
|
+
* Unauthorized
|
|
622
|
+
*/
|
|
623
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
624
|
+
/**
|
|
625
|
+
* Forbidden
|
|
626
|
+
*/
|
|
627
|
+
403: FlashStartErrorBody;
|
|
628
|
+
/**
|
|
629
|
+
* Not found
|
|
630
|
+
*/
|
|
631
|
+
404: FlashStartErrorBody;
|
|
632
|
+
/**
|
|
633
|
+
* Invalid request
|
|
634
|
+
*/
|
|
635
|
+
422: FlashStartErrorBody;
|
|
636
|
+
/**
|
|
637
|
+
* Internal server error
|
|
638
|
+
*/
|
|
639
|
+
500: FlashStartErrorBody;
|
|
640
|
+
};
|
|
641
|
+
export type CreateDeviceError = CreateDeviceErrors[keyof CreateDeviceErrors];
|
|
642
|
+
export type CreateDeviceResponses = {
|
|
643
|
+
/**
|
|
644
|
+
* Created device
|
|
645
|
+
*/
|
|
646
|
+
201: {
|
|
647
|
+
id: string;
|
|
648
|
+
networkId: string;
|
|
649
|
+
publicIp: string;
|
|
650
|
+
catchAllRule: {
|
|
651
|
+
id: string;
|
|
652
|
+
isLimited: boolean;
|
|
653
|
+
isShared: boolean;
|
|
654
|
+
name: string;
|
|
655
|
+
organizationId: string;
|
|
656
|
+
};
|
|
657
|
+
info: {
|
|
658
|
+
deviceId?: string;
|
|
659
|
+
localDnsIp?: string;
|
|
660
|
+
publicDnsFallback?: boolean;
|
|
661
|
+
version?: string;
|
|
662
|
+
lastVersionCheckTime?: string | string;
|
|
663
|
+
lastLoginCheckTime?: string | string;
|
|
664
|
+
hardwareModel?: string;
|
|
665
|
+
osVersion?: string;
|
|
666
|
+
releaseVersion?: string;
|
|
667
|
+
firmwareVersion?: string;
|
|
668
|
+
cpuUsage?: number;
|
|
669
|
+
ramUsage?: number;
|
|
670
|
+
diskUsage?: number;
|
|
671
|
+
uptime?: number;
|
|
672
|
+
temperature?: number;
|
|
673
|
+
metadata?: {
|
|
674
|
+
[key: string]: unknown;
|
|
675
|
+
};
|
|
676
|
+
};
|
|
677
|
+
name: string;
|
|
678
|
+
organizationId: string;
|
|
679
|
+
type: 'CLOUDBOX';
|
|
680
|
+
};
|
|
681
|
+
};
|
|
682
|
+
export type CreateDeviceResponse = CreateDeviceResponses[keyof CreateDeviceResponses];
|
|
683
|
+
export type DeleteDeviceData = {
|
|
684
|
+
body?: never;
|
|
685
|
+
path: {
|
|
686
|
+
deviceType: 'CLOUDBOX' | 'ROUTER';
|
|
687
|
+
deviceId: string;
|
|
688
|
+
};
|
|
689
|
+
query?: never;
|
|
690
|
+
url: '/v1/devices/{deviceType}/{deviceId}';
|
|
691
|
+
};
|
|
692
|
+
export type DeleteDeviceErrors = {
|
|
693
|
+
/**
|
|
694
|
+
* Unauthorized
|
|
695
|
+
*/
|
|
696
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
697
|
+
/**
|
|
698
|
+
* Forbidden
|
|
699
|
+
*/
|
|
700
|
+
403: FlashStartErrorBody;
|
|
701
|
+
/**
|
|
702
|
+
* Not found
|
|
703
|
+
*/
|
|
704
|
+
404: FlashStartErrorBody;
|
|
705
|
+
/**
|
|
706
|
+
* Invalid request
|
|
707
|
+
*/
|
|
708
|
+
422: FlashStartErrorBody;
|
|
709
|
+
/**
|
|
710
|
+
* Internal server error
|
|
711
|
+
*/
|
|
712
|
+
500: FlashStartErrorBody;
|
|
713
|
+
};
|
|
714
|
+
export type DeleteDeviceError = DeleteDeviceErrors[keyof DeleteDeviceErrors];
|
|
715
|
+
export type DeleteDeviceResponses = {
|
|
716
|
+
/**
|
|
717
|
+
* Deleted device
|
|
718
|
+
*/
|
|
719
|
+
200: {
|
|
720
|
+
id: string;
|
|
721
|
+
networkId: string;
|
|
722
|
+
publicIp: string;
|
|
723
|
+
catchAllRule: {
|
|
724
|
+
id: string;
|
|
725
|
+
isLimited: boolean;
|
|
726
|
+
isShared: boolean;
|
|
727
|
+
name: string;
|
|
728
|
+
organizationId: string;
|
|
729
|
+
};
|
|
730
|
+
info: {
|
|
731
|
+
deviceId?: string;
|
|
732
|
+
localDnsIp?: string;
|
|
733
|
+
publicDnsFallback?: boolean;
|
|
734
|
+
version?: string;
|
|
735
|
+
lastVersionCheckTime?: string | string;
|
|
736
|
+
lastLoginCheckTime?: string | string;
|
|
737
|
+
hardwareModel?: string;
|
|
738
|
+
osVersion?: string;
|
|
739
|
+
releaseVersion?: string;
|
|
740
|
+
firmwareVersion?: string;
|
|
741
|
+
cpuUsage?: number;
|
|
742
|
+
ramUsage?: number;
|
|
743
|
+
diskUsage?: number;
|
|
744
|
+
uptime?: number;
|
|
745
|
+
temperature?: number;
|
|
746
|
+
metadata?: {
|
|
747
|
+
[key: string]: unknown;
|
|
748
|
+
};
|
|
749
|
+
};
|
|
750
|
+
name: string;
|
|
751
|
+
organizationId: string;
|
|
752
|
+
type: 'CLOUDBOX';
|
|
753
|
+
};
|
|
754
|
+
};
|
|
755
|
+
export type DeleteDeviceResponse = DeleteDeviceResponses[keyof DeleteDeviceResponses];
|
|
756
|
+
export type GetDeviceData = {
|
|
757
|
+
body?: never;
|
|
758
|
+
path: {
|
|
759
|
+
deviceType: 'CLOUDBOX' | 'ROUTER';
|
|
760
|
+
deviceId: string;
|
|
761
|
+
};
|
|
762
|
+
query?: never;
|
|
763
|
+
url: '/v1/devices/{deviceType}/{deviceId}';
|
|
764
|
+
};
|
|
765
|
+
export type GetDeviceErrors = {
|
|
766
|
+
/**
|
|
767
|
+
* Unauthorized
|
|
768
|
+
*/
|
|
769
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
770
|
+
/**
|
|
771
|
+
* Forbidden
|
|
772
|
+
*/
|
|
773
|
+
403: FlashStartErrorBody;
|
|
774
|
+
/**
|
|
775
|
+
* Not found
|
|
776
|
+
*/
|
|
777
|
+
404: FlashStartErrorBody;
|
|
778
|
+
/**
|
|
779
|
+
* Invalid request
|
|
780
|
+
*/
|
|
781
|
+
422: FlashStartErrorBody;
|
|
782
|
+
/**
|
|
783
|
+
* Internal server error
|
|
784
|
+
*/
|
|
785
|
+
500: FlashStartErrorBody;
|
|
786
|
+
};
|
|
787
|
+
export type GetDeviceError = GetDeviceErrors[keyof GetDeviceErrors];
|
|
788
|
+
export type GetDeviceResponses = {
|
|
789
|
+
/**
|
|
790
|
+
* Device
|
|
791
|
+
*/
|
|
792
|
+
200: {
|
|
793
|
+
id: string;
|
|
794
|
+
networkId: string;
|
|
795
|
+
publicIp: string;
|
|
796
|
+
catchAllRule: {
|
|
797
|
+
id: string;
|
|
798
|
+
isLimited: boolean;
|
|
799
|
+
isShared: boolean;
|
|
800
|
+
name: string;
|
|
801
|
+
organizationId: string;
|
|
802
|
+
};
|
|
803
|
+
info: {
|
|
804
|
+
deviceId?: string;
|
|
805
|
+
localDnsIp?: string;
|
|
806
|
+
publicDnsFallback?: boolean;
|
|
807
|
+
version?: string;
|
|
808
|
+
lastVersionCheckTime?: string | string;
|
|
809
|
+
lastLoginCheckTime?: string | string;
|
|
810
|
+
hardwareModel?: string;
|
|
811
|
+
osVersion?: string;
|
|
812
|
+
releaseVersion?: string;
|
|
813
|
+
firmwareVersion?: string;
|
|
814
|
+
cpuUsage?: number;
|
|
815
|
+
ramUsage?: number;
|
|
816
|
+
diskUsage?: number;
|
|
817
|
+
uptime?: number;
|
|
818
|
+
temperature?: number;
|
|
819
|
+
metadata?: {
|
|
820
|
+
[key: string]: unknown;
|
|
821
|
+
};
|
|
822
|
+
};
|
|
823
|
+
name: string;
|
|
824
|
+
organizationId: string;
|
|
825
|
+
type: 'CLOUDBOX';
|
|
826
|
+
};
|
|
827
|
+
};
|
|
828
|
+
export type GetDeviceResponse = GetDeviceResponses[keyof GetDeviceResponses];
|
|
829
|
+
export type UpdateDeviceData = {
|
|
830
|
+
body: {
|
|
831
|
+
name?: string;
|
|
832
|
+
note?: string;
|
|
833
|
+
};
|
|
834
|
+
path: {
|
|
835
|
+
deviceType: 'CLOUDBOX' | 'ROUTER';
|
|
836
|
+
deviceId: string;
|
|
837
|
+
};
|
|
838
|
+
query?: never;
|
|
839
|
+
url: '/v1/devices/{deviceType}/{deviceId}';
|
|
840
|
+
};
|
|
841
|
+
export type UpdateDeviceErrors = {
|
|
842
|
+
/**
|
|
843
|
+
* Unauthorized
|
|
844
|
+
*/
|
|
845
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
846
|
+
/**
|
|
847
|
+
* Forbidden
|
|
848
|
+
*/
|
|
849
|
+
403: FlashStartErrorBody;
|
|
850
|
+
/**
|
|
851
|
+
* Not found
|
|
852
|
+
*/
|
|
853
|
+
404: FlashStartErrorBody;
|
|
854
|
+
/**
|
|
855
|
+
* Invalid request
|
|
856
|
+
*/
|
|
857
|
+
422: FlashStartErrorBody;
|
|
858
|
+
/**
|
|
859
|
+
* Internal server error
|
|
860
|
+
*/
|
|
861
|
+
500: FlashStartErrorBody;
|
|
862
|
+
};
|
|
863
|
+
export type UpdateDeviceError = UpdateDeviceErrors[keyof UpdateDeviceErrors];
|
|
864
|
+
export type UpdateDeviceResponses = {
|
|
865
|
+
/**
|
|
866
|
+
* Updated device
|
|
867
|
+
*/
|
|
868
|
+
200: {
|
|
869
|
+
id: string;
|
|
870
|
+
networkId: string;
|
|
871
|
+
publicIp: string;
|
|
872
|
+
catchAllRule: {
|
|
873
|
+
id: string;
|
|
874
|
+
isLimited: boolean;
|
|
875
|
+
isShared: boolean;
|
|
876
|
+
name: string;
|
|
877
|
+
organizationId: string;
|
|
878
|
+
};
|
|
879
|
+
info: {
|
|
880
|
+
deviceId?: string;
|
|
881
|
+
localDnsIp?: string;
|
|
882
|
+
publicDnsFallback?: boolean;
|
|
883
|
+
version?: string;
|
|
884
|
+
lastVersionCheckTime?: string | string;
|
|
885
|
+
lastLoginCheckTime?: string | string;
|
|
886
|
+
hardwareModel?: string;
|
|
887
|
+
osVersion?: string;
|
|
888
|
+
releaseVersion?: string;
|
|
889
|
+
firmwareVersion?: string;
|
|
890
|
+
cpuUsage?: number;
|
|
891
|
+
ramUsage?: number;
|
|
892
|
+
diskUsage?: number;
|
|
893
|
+
uptime?: number;
|
|
894
|
+
temperature?: number;
|
|
895
|
+
metadata?: {
|
|
896
|
+
[key: string]: unknown;
|
|
897
|
+
};
|
|
898
|
+
};
|
|
899
|
+
name: string;
|
|
900
|
+
organizationId: string;
|
|
901
|
+
type: 'CLOUDBOX';
|
|
902
|
+
};
|
|
903
|
+
};
|
|
904
|
+
export type UpdateDeviceResponse = UpdateDeviceResponses[keyof UpdateDeviceResponses];
|
|
905
|
+
export type UpdateDeviceCatchAllData = {
|
|
906
|
+
body: {
|
|
907
|
+
catchAllPolicyId: string;
|
|
908
|
+
};
|
|
909
|
+
path: {
|
|
910
|
+
deviceType: 'CLOUDBOX' | 'ROUTER';
|
|
911
|
+
deviceId: string;
|
|
912
|
+
};
|
|
913
|
+
query?: never;
|
|
914
|
+
url: '/v1/devices/{deviceType}/{deviceId}/catch-all';
|
|
915
|
+
};
|
|
916
|
+
export type UpdateDeviceCatchAllErrors = {
|
|
917
|
+
/**
|
|
918
|
+
* Unauthorized
|
|
919
|
+
*/
|
|
920
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
921
|
+
/**
|
|
922
|
+
* Forbidden
|
|
923
|
+
*/
|
|
924
|
+
403: FlashStartErrorBody;
|
|
925
|
+
/**
|
|
926
|
+
* Not found
|
|
927
|
+
*/
|
|
928
|
+
404: FlashStartErrorBody;
|
|
929
|
+
/**
|
|
930
|
+
* Invalid request
|
|
931
|
+
*/
|
|
932
|
+
422: FlashStartErrorBody;
|
|
933
|
+
/**
|
|
934
|
+
* Internal server error
|
|
935
|
+
*/
|
|
936
|
+
500: FlashStartErrorBody;
|
|
937
|
+
};
|
|
938
|
+
export type UpdateDeviceCatchAllError = UpdateDeviceCatchAllErrors[keyof UpdateDeviceCatchAllErrors];
|
|
939
|
+
export type UpdateDeviceCatchAllResponses = {
|
|
940
|
+
/**
|
|
941
|
+
* Updated device
|
|
942
|
+
*/
|
|
943
|
+
200: {
|
|
944
|
+
id: string;
|
|
945
|
+
networkId: string;
|
|
946
|
+
publicIp: string;
|
|
947
|
+
catchAllRule: {
|
|
948
|
+
id: string;
|
|
949
|
+
isLimited: boolean;
|
|
950
|
+
isShared: boolean;
|
|
951
|
+
name: string;
|
|
952
|
+
organizationId: string;
|
|
953
|
+
};
|
|
954
|
+
info: {
|
|
955
|
+
deviceId?: string;
|
|
956
|
+
localDnsIp?: string;
|
|
957
|
+
publicDnsFallback?: boolean;
|
|
958
|
+
version?: string;
|
|
959
|
+
lastVersionCheckTime?: string | string;
|
|
960
|
+
lastLoginCheckTime?: string | string;
|
|
961
|
+
hardwareModel?: string;
|
|
962
|
+
osVersion?: string;
|
|
963
|
+
releaseVersion?: string;
|
|
964
|
+
firmwareVersion?: string;
|
|
965
|
+
cpuUsage?: number;
|
|
966
|
+
ramUsage?: number;
|
|
967
|
+
diskUsage?: number;
|
|
968
|
+
uptime?: number;
|
|
969
|
+
temperature?: number;
|
|
970
|
+
metadata?: {
|
|
971
|
+
[key: string]: unknown;
|
|
972
|
+
};
|
|
973
|
+
};
|
|
974
|
+
name: string;
|
|
975
|
+
organizationId: string;
|
|
976
|
+
type: 'CLOUDBOX';
|
|
977
|
+
};
|
|
978
|
+
};
|
|
979
|
+
export type UpdateDeviceCatchAllResponse = UpdateDeviceCatchAllResponses[keyof UpdateDeviceCatchAllResponses];
|
|
980
|
+
export type GetDeviceCredentialsData = {
|
|
981
|
+
body?: never;
|
|
982
|
+
path: {
|
|
983
|
+
deviceType: 'CLOUDBOX' | 'ROUTER';
|
|
984
|
+
deviceId: string;
|
|
985
|
+
};
|
|
986
|
+
query?: never;
|
|
987
|
+
url: '/v1/devices/{deviceType}/{deviceId}/credentials';
|
|
988
|
+
};
|
|
989
|
+
export type GetDeviceCredentialsErrors = {
|
|
990
|
+
/**
|
|
991
|
+
* Unauthorized
|
|
992
|
+
*/
|
|
993
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
994
|
+
/**
|
|
995
|
+
* Forbidden
|
|
996
|
+
*/
|
|
997
|
+
403: FlashStartErrorBody;
|
|
998
|
+
/**
|
|
999
|
+
* Not found
|
|
1000
|
+
*/
|
|
1001
|
+
404: FlashStartErrorBody;
|
|
1002
|
+
/**
|
|
1003
|
+
* Invalid request
|
|
1004
|
+
*/
|
|
1005
|
+
422: FlashStartErrorBody;
|
|
1006
|
+
/**
|
|
1007
|
+
* Internal server error
|
|
1008
|
+
*/
|
|
1009
|
+
500: FlashStartErrorBody;
|
|
1010
|
+
};
|
|
1011
|
+
export type GetDeviceCredentialsError = GetDeviceCredentialsErrors[keyof GetDeviceCredentialsErrors];
|
|
1012
|
+
export type GetDeviceCredentialsResponses = {
|
|
1013
|
+
/**
|
|
1014
|
+
* Device credentials
|
|
1015
|
+
*/
|
|
1016
|
+
200: {
|
|
1017
|
+
deviceId: string;
|
|
1018
|
+
password: string;
|
|
1019
|
+
username: string;
|
|
1020
|
+
};
|
|
1021
|
+
};
|
|
1022
|
+
export type GetDeviceCredentialsResponse = GetDeviceCredentialsResponses[keyof GetDeviceCredentialsResponses];
|
|
1023
|
+
export type UpdateDeviceCredentialsData = {
|
|
1024
|
+
body: {
|
|
1025
|
+
username?: string;
|
|
1026
|
+
password?: string;
|
|
1027
|
+
};
|
|
1028
|
+
path: {
|
|
1029
|
+
deviceType: 'CLOUDBOX' | 'ROUTER';
|
|
1030
|
+
deviceId: string;
|
|
1031
|
+
};
|
|
1032
|
+
query?: never;
|
|
1033
|
+
url: '/v1/devices/{deviceType}/{deviceId}/credentials';
|
|
1034
|
+
};
|
|
1035
|
+
export type UpdateDeviceCredentialsErrors = {
|
|
1036
|
+
/**
|
|
1037
|
+
* Unauthorized
|
|
1038
|
+
*/
|
|
1039
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1040
|
+
/**
|
|
1041
|
+
* Forbidden
|
|
1042
|
+
*/
|
|
1043
|
+
403: FlashStartErrorBody;
|
|
1044
|
+
/**
|
|
1045
|
+
* Not found
|
|
1046
|
+
*/
|
|
1047
|
+
404: FlashStartErrorBody;
|
|
1048
|
+
/**
|
|
1049
|
+
* Invalid request
|
|
1050
|
+
*/
|
|
1051
|
+
422: FlashStartErrorBody;
|
|
1052
|
+
/**
|
|
1053
|
+
* Internal server error
|
|
1054
|
+
*/
|
|
1055
|
+
500: FlashStartErrorBody;
|
|
1056
|
+
};
|
|
1057
|
+
export type UpdateDeviceCredentialsError = UpdateDeviceCredentialsErrors[keyof UpdateDeviceCredentialsErrors];
|
|
1058
|
+
export type UpdateDeviceCredentialsResponses = {
|
|
1059
|
+
/**
|
|
1060
|
+
* Updated credentials
|
|
1061
|
+
*/
|
|
1062
|
+
200: {
|
|
1063
|
+
deviceId: string;
|
|
1064
|
+
password: string;
|
|
1065
|
+
username: string;
|
|
1066
|
+
};
|
|
1067
|
+
};
|
|
1068
|
+
export type UpdateDeviceCredentialsResponse = UpdateDeviceCredentialsResponses[keyof UpdateDeviceCredentialsResponses];
|
|
1069
|
+
export type GetRulesData = {
|
|
1070
|
+
body?: never;
|
|
1071
|
+
path?: never;
|
|
1072
|
+
query?: {
|
|
1073
|
+
organizationId?: string;
|
|
1074
|
+
};
|
|
1075
|
+
url: '/v1/rules';
|
|
1076
|
+
};
|
|
1077
|
+
export type GetRulesErrors = {
|
|
1078
|
+
/**
|
|
1079
|
+
* Unauthorized
|
|
1080
|
+
*/
|
|
1081
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1082
|
+
/**
|
|
1083
|
+
* Forbidden
|
|
1084
|
+
*/
|
|
1085
|
+
403: FlashStartErrorBody;
|
|
1086
|
+
/**
|
|
1087
|
+
* Not found
|
|
1088
|
+
*/
|
|
1089
|
+
404: FlashStartErrorBody;
|
|
1090
|
+
/**
|
|
1091
|
+
* Invalid request
|
|
1092
|
+
*/
|
|
1093
|
+
422: FlashStartErrorBody;
|
|
1094
|
+
/**
|
|
1095
|
+
* Internal server error
|
|
1096
|
+
*/
|
|
1097
|
+
500: FlashStartErrorBody;
|
|
1098
|
+
};
|
|
1099
|
+
export type GetRulesError = GetRulesErrors[keyof GetRulesErrors];
|
|
1100
|
+
export type GetRulesResponses = {
|
|
1101
|
+
/**
|
|
1102
|
+
* Rules
|
|
1103
|
+
*/
|
|
1104
|
+
200: Array<{
|
|
1105
|
+
deviceIds: Array<string>;
|
|
1106
|
+
id: string;
|
|
1107
|
+
localAddress: {
|
|
1108
|
+
type: 'SINGLE';
|
|
1109
|
+
ip: string | string;
|
|
1110
|
+
} | {
|
|
1111
|
+
type: 'CIDR';
|
|
1112
|
+
cidr: string | string;
|
|
1113
|
+
} | {
|
|
1114
|
+
type: 'RANGE';
|
|
1115
|
+
startIp: string;
|
|
1116
|
+
endIp: string;
|
|
1117
|
+
};
|
|
1118
|
+
organizationId: string;
|
|
1119
|
+
policy: {
|
|
1120
|
+
id: string;
|
|
1121
|
+
isLimited: boolean;
|
|
1122
|
+
isShared: boolean;
|
|
1123
|
+
name: string;
|
|
1124
|
+
organizationId: string;
|
|
1125
|
+
};
|
|
1126
|
+
}>;
|
|
1127
|
+
};
|
|
1128
|
+
export type GetRulesResponse = GetRulesResponses[keyof GetRulesResponses];
|
|
1129
|
+
export type CreateRuleData = {
|
|
1130
|
+
body: {
|
|
1131
|
+
organizationId: string;
|
|
1132
|
+
policyId: string;
|
|
1133
|
+
localAddress?: {
|
|
1134
|
+
type: 'SINGLE';
|
|
1135
|
+
ip: string | string;
|
|
1136
|
+
} | {
|
|
1137
|
+
type: 'CIDR';
|
|
1138
|
+
cidr: string | string;
|
|
1139
|
+
} | {
|
|
1140
|
+
type: 'RANGE';
|
|
1141
|
+
startIp: string;
|
|
1142
|
+
endIp: string;
|
|
1143
|
+
};
|
|
1144
|
+
};
|
|
1145
|
+
path?: never;
|
|
1146
|
+
query?: never;
|
|
1147
|
+
url: '/v1/rules';
|
|
1148
|
+
};
|
|
1149
|
+
export type CreateRuleErrors = {
|
|
1150
|
+
/**
|
|
1151
|
+
* Unauthorized
|
|
1152
|
+
*/
|
|
1153
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1154
|
+
/**
|
|
1155
|
+
* Forbidden
|
|
1156
|
+
*/
|
|
1157
|
+
403: FlashStartErrorBody;
|
|
1158
|
+
/**
|
|
1159
|
+
* Not found
|
|
1160
|
+
*/
|
|
1161
|
+
404: FlashStartErrorBody;
|
|
1162
|
+
/**
|
|
1163
|
+
* Invalid request
|
|
1164
|
+
*/
|
|
1165
|
+
422: FlashStartErrorBody;
|
|
1166
|
+
/**
|
|
1167
|
+
* Internal server error
|
|
1168
|
+
*/
|
|
1169
|
+
500: FlashStartErrorBody;
|
|
1170
|
+
};
|
|
1171
|
+
export type CreateRuleError = CreateRuleErrors[keyof CreateRuleErrors];
|
|
1172
|
+
export type CreateRuleResponses = {
|
|
1173
|
+
/**
|
|
1174
|
+
* Created rule
|
|
1175
|
+
*/
|
|
1176
|
+
201: {
|
|
1177
|
+
deviceIds: Array<string>;
|
|
1178
|
+
id: string;
|
|
1179
|
+
localAddress: {
|
|
1180
|
+
type: 'SINGLE';
|
|
1181
|
+
ip: string | string;
|
|
1182
|
+
} | {
|
|
1183
|
+
type: 'CIDR';
|
|
1184
|
+
cidr: string | string;
|
|
1185
|
+
} | {
|
|
1186
|
+
type: 'RANGE';
|
|
1187
|
+
startIp: string;
|
|
1188
|
+
endIp: string;
|
|
1189
|
+
};
|
|
1190
|
+
organizationId: string;
|
|
1191
|
+
policy: {
|
|
1192
|
+
id: string;
|
|
1193
|
+
isLimited: boolean;
|
|
1194
|
+
isShared: boolean;
|
|
1195
|
+
name: string;
|
|
1196
|
+
organizationId: string;
|
|
1197
|
+
};
|
|
1198
|
+
};
|
|
1199
|
+
};
|
|
1200
|
+
export type CreateRuleResponse = CreateRuleResponses[keyof CreateRuleResponses];
|
|
1201
|
+
export type DeleteRuleData = {
|
|
1202
|
+
body?: never;
|
|
1203
|
+
path: {
|
|
1204
|
+
ruleId: string;
|
|
1205
|
+
};
|
|
1206
|
+
query?: never;
|
|
1207
|
+
url: '/v1/rules/{ruleId}';
|
|
1208
|
+
};
|
|
1209
|
+
export type DeleteRuleErrors = {
|
|
1210
|
+
/**
|
|
1211
|
+
* Unauthorized
|
|
1212
|
+
*/
|
|
1213
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1214
|
+
/**
|
|
1215
|
+
* Forbidden
|
|
1216
|
+
*/
|
|
1217
|
+
403: FlashStartErrorBody;
|
|
1218
|
+
/**
|
|
1219
|
+
* Not found
|
|
1220
|
+
*/
|
|
1221
|
+
404: FlashStartErrorBody;
|
|
1222
|
+
/**
|
|
1223
|
+
* Invalid request
|
|
1224
|
+
*/
|
|
1225
|
+
422: FlashStartErrorBody;
|
|
1226
|
+
/**
|
|
1227
|
+
* Internal server error
|
|
1228
|
+
*/
|
|
1229
|
+
500: FlashStartErrorBody;
|
|
1230
|
+
};
|
|
1231
|
+
export type DeleteRuleError = DeleteRuleErrors[keyof DeleteRuleErrors];
|
|
1232
|
+
export type DeleteRuleResponses = {
|
|
1233
|
+
/**
|
|
1234
|
+
* Deleted rule
|
|
1235
|
+
*/
|
|
1236
|
+
200: {
|
|
1237
|
+
deviceIds: Array<string>;
|
|
1238
|
+
id: string;
|
|
1239
|
+
localAddress: {
|
|
1240
|
+
type: 'SINGLE';
|
|
1241
|
+
ip: string | string;
|
|
1242
|
+
} | {
|
|
1243
|
+
type: 'CIDR';
|
|
1244
|
+
cidr: string | string;
|
|
1245
|
+
} | {
|
|
1246
|
+
type: 'RANGE';
|
|
1247
|
+
startIp: string;
|
|
1248
|
+
endIp: string;
|
|
1249
|
+
};
|
|
1250
|
+
organizationId: string;
|
|
1251
|
+
policy: {
|
|
1252
|
+
id: string;
|
|
1253
|
+
isLimited: boolean;
|
|
1254
|
+
isShared: boolean;
|
|
1255
|
+
name: string;
|
|
1256
|
+
organizationId: string;
|
|
1257
|
+
};
|
|
1258
|
+
};
|
|
1259
|
+
};
|
|
1260
|
+
export type DeleteRuleResponse = DeleteRuleResponses[keyof DeleteRuleResponses];
|
|
1261
|
+
export type AssociateDeviceToRuleData = {
|
|
1262
|
+
body: {
|
|
1263
|
+
deviceId: string;
|
|
1264
|
+
};
|
|
1265
|
+
path: {
|
|
1266
|
+
ruleId: string;
|
|
1267
|
+
};
|
|
1268
|
+
query?: never;
|
|
1269
|
+
url: '/v1/rules/{ruleId}/devices';
|
|
1270
|
+
};
|
|
1271
|
+
export type AssociateDeviceToRuleErrors = {
|
|
1272
|
+
/**
|
|
1273
|
+
* Unauthorized
|
|
1274
|
+
*/
|
|
1275
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1276
|
+
/**
|
|
1277
|
+
* Forbidden
|
|
1278
|
+
*/
|
|
1279
|
+
403: FlashStartErrorBody;
|
|
1280
|
+
/**
|
|
1281
|
+
* Not found
|
|
1282
|
+
*/
|
|
1283
|
+
404: FlashStartErrorBody;
|
|
1284
|
+
/**
|
|
1285
|
+
* Invalid request
|
|
1286
|
+
*/
|
|
1287
|
+
422: FlashStartErrorBody;
|
|
1288
|
+
/**
|
|
1289
|
+
* Internal server error
|
|
1290
|
+
*/
|
|
1291
|
+
500: FlashStartErrorBody;
|
|
1292
|
+
};
|
|
1293
|
+
export type AssociateDeviceToRuleError = AssociateDeviceToRuleErrors[keyof AssociateDeviceToRuleErrors];
|
|
1294
|
+
export type AssociateDeviceToRuleResponses = {
|
|
1295
|
+
/**
|
|
1296
|
+
* Associated rule
|
|
1297
|
+
*/
|
|
1298
|
+
201: {
|
|
1299
|
+
deviceIds: Array<string>;
|
|
1300
|
+
id: string;
|
|
1301
|
+
localAddress: {
|
|
1302
|
+
type: 'SINGLE';
|
|
1303
|
+
ip: string | string;
|
|
1304
|
+
} | {
|
|
1305
|
+
type: 'CIDR';
|
|
1306
|
+
cidr: string | string;
|
|
1307
|
+
} | {
|
|
1308
|
+
type: 'RANGE';
|
|
1309
|
+
startIp: string;
|
|
1310
|
+
endIp: string;
|
|
1311
|
+
};
|
|
1312
|
+
organizationId: string;
|
|
1313
|
+
policy: {
|
|
1314
|
+
id: string;
|
|
1315
|
+
isLimited: boolean;
|
|
1316
|
+
isShared: boolean;
|
|
1317
|
+
name: string;
|
|
1318
|
+
organizationId: string;
|
|
1319
|
+
};
|
|
1320
|
+
};
|
|
1321
|
+
};
|
|
1322
|
+
export type AssociateDeviceToRuleResponse = AssociateDeviceToRuleResponses[keyof AssociateDeviceToRuleResponses];
|
|
1323
|
+
export type DissociateDeviceFromRuleData = {
|
|
1324
|
+
body?: never;
|
|
1325
|
+
path: {
|
|
1326
|
+
ruleId: string;
|
|
1327
|
+
deviceId: string;
|
|
1328
|
+
};
|
|
1329
|
+
query?: never;
|
|
1330
|
+
url: '/v1/rules/{ruleId}/devices/{deviceId}';
|
|
1331
|
+
};
|
|
1332
|
+
export type DissociateDeviceFromRuleErrors = {
|
|
1333
|
+
/**
|
|
1334
|
+
* Unauthorized
|
|
1335
|
+
*/
|
|
1336
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1337
|
+
/**
|
|
1338
|
+
* Forbidden
|
|
1339
|
+
*/
|
|
1340
|
+
403: FlashStartErrorBody;
|
|
1341
|
+
/**
|
|
1342
|
+
* Not found
|
|
1343
|
+
*/
|
|
1344
|
+
404: FlashStartErrorBody;
|
|
1345
|
+
/**
|
|
1346
|
+
* Invalid request
|
|
1347
|
+
*/
|
|
1348
|
+
422: FlashStartErrorBody;
|
|
1349
|
+
/**
|
|
1350
|
+
* Internal server error
|
|
1351
|
+
*/
|
|
1352
|
+
500: FlashStartErrorBody;
|
|
1353
|
+
};
|
|
1354
|
+
export type DissociateDeviceFromRuleError = DissociateDeviceFromRuleErrors[keyof DissociateDeviceFromRuleErrors];
|
|
1355
|
+
export type DissociateDeviceFromRuleResponses = {
|
|
1356
|
+
/**
|
|
1357
|
+
* Dissociated rule
|
|
1358
|
+
*/
|
|
1359
|
+
200: {
|
|
1360
|
+
deviceIds: Array<string>;
|
|
1361
|
+
id: string;
|
|
1362
|
+
localAddress: {
|
|
1363
|
+
type: 'SINGLE';
|
|
1364
|
+
ip: string | string;
|
|
1365
|
+
} | {
|
|
1366
|
+
type: 'CIDR';
|
|
1367
|
+
cidr: string | string;
|
|
1368
|
+
} | {
|
|
1369
|
+
type: 'RANGE';
|
|
1370
|
+
startIp: string;
|
|
1371
|
+
endIp: string;
|
|
1372
|
+
};
|
|
1373
|
+
organizationId: string;
|
|
1374
|
+
policy: {
|
|
1375
|
+
id: string;
|
|
1376
|
+
isLimited: boolean;
|
|
1377
|
+
isShared: boolean;
|
|
1378
|
+
name: string;
|
|
1379
|
+
organizationId: string;
|
|
1380
|
+
};
|
|
1381
|
+
};
|
|
1382
|
+
};
|
|
1383
|
+
export type DissociateDeviceFromRuleResponse = DissociateDeviceFromRuleResponses[keyof DissociateDeviceFromRuleResponses];
|
|
1384
|
+
export type GetPhysicalDevicesData = {
|
|
1385
|
+
body?: never;
|
|
1386
|
+
path?: never;
|
|
1387
|
+
query?: never;
|
|
1388
|
+
url: '/v1/physical-devices';
|
|
1389
|
+
};
|
|
1390
|
+
export type GetPhysicalDevicesErrors = {
|
|
1391
|
+
/**
|
|
1392
|
+
* Unauthorized
|
|
1393
|
+
*/
|
|
1394
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1395
|
+
/**
|
|
1396
|
+
* Forbidden
|
|
1397
|
+
*/
|
|
1398
|
+
403: FlashStartErrorBody;
|
|
1399
|
+
/**
|
|
1400
|
+
* Not found
|
|
1401
|
+
*/
|
|
1402
|
+
404: FlashStartErrorBody;
|
|
1403
|
+
/**
|
|
1404
|
+
* Internal server error
|
|
1405
|
+
*/
|
|
1406
|
+
500: FlashStartErrorBody;
|
|
1407
|
+
};
|
|
1408
|
+
export type GetPhysicalDevicesError = GetPhysicalDevicesErrors[keyof GetPhysicalDevicesErrors];
|
|
1409
|
+
export type GetPhysicalDevicesResponses = {
|
|
1410
|
+
/**
|
|
1411
|
+
* Physical devices
|
|
1412
|
+
*/
|
|
1413
|
+
200: Array<{
|
|
1414
|
+
id: string;
|
|
1415
|
+
name: string;
|
|
1416
|
+
code: string;
|
|
1417
|
+
brand: string;
|
|
1418
|
+
features: Array<'ddns' | 'doh' | 'dot' | 'multi_wan' | 'configuration_script' | 'auth_check'>;
|
|
1419
|
+
}>;
|
|
1420
|
+
};
|
|
1421
|
+
export type GetPhysicalDevicesResponse = GetPhysicalDevicesResponses[keyof GetPhysicalDevicesResponses];
|
|
1422
|
+
export type GetRoutersData = {
|
|
1423
|
+
body?: never;
|
|
1424
|
+
path?: never;
|
|
1425
|
+
query?: {
|
|
1426
|
+
organizationId?: string;
|
|
1427
|
+
};
|
|
1428
|
+
url: '/v1/routers';
|
|
1429
|
+
};
|
|
1430
|
+
export type GetRoutersErrors = {
|
|
1431
|
+
/**
|
|
1432
|
+
* Unauthorized
|
|
1433
|
+
*/
|
|
1434
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1435
|
+
/**
|
|
1436
|
+
* Forbidden
|
|
1437
|
+
*/
|
|
1438
|
+
403: FlashStartErrorBody;
|
|
1439
|
+
/**
|
|
1440
|
+
* Not found
|
|
1441
|
+
*/
|
|
1442
|
+
404: FlashStartErrorBody;
|
|
1443
|
+
/**
|
|
1444
|
+
* Invalid request
|
|
1445
|
+
*/
|
|
1446
|
+
422: FlashStartErrorBody;
|
|
1447
|
+
/**
|
|
1448
|
+
* Internal server error
|
|
1449
|
+
*/
|
|
1450
|
+
500: FlashStartErrorBody;
|
|
1451
|
+
};
|
|
1452
|
+
export type GetRoutersError = GetRoutersErrors[keyof GetRoutersErrors];
|
|
1453
|
+
export type GetRoutersResponses = {
|
|
1454
|
+
/**
|
|
1455
|
+
* Routers
|
|
1456
|
+
*/
|
|
1457
|
+
200: Array<{
|
|
1458
|
+
id: string;
|
|
1459
|
+
name: string;
|
|
1460
|
+
organizationId: string;
|
|
1461
|
+
physicalDeviceId: string;
|
|
1462
|
+
note?: string;
|
|
1463
|
+
networks: Array<{
|
|
1464
|
+
primaryNetwork: {
|
|
1465
|
+
id: string;
|
|
1466
|
+
type: 'STATIC_ENCRYPTED';
|
|
1467
|
+
name: string;
|
|
1468
|
+
note?: string;
|
|
1469
|
+
tag: string;
|
|
1470
|
+
} | {
|
|
1471
|
+
id: string;
|
|
1472
|
+
type: 'DYNAMIC_INTERNAL';
|
|
1473
|
+
name: string;
|
|
1474
|
+
note?: string;
|
|
1475
|
+
ddns: {
|
|
1476
|
+
id?: string;
|
|
1477
|
+
username: string;
|
|
1478
|
+
password?: string;
|
|
1479
|
+
domain: string;
|
|
1480
|
+
};
|
|
1481
|
+
dynamicIp: string;
|
|
1482
|
+
};
|
|
1483
|
+
secondaryNetworks: Array<{
|
|
1484
|
+
id: string;
|
|
1485
|
+
type: 'STATIC_ENCRYPTED';
|
|
1486
|
+
name: string;
|
|
1487
|
+
note?: string;
|
|
1488
|
+
tag: string;
|
|
1489
|
+
} | {
|
|
1490
|
+
id: string;
|
|
1491
|
+
type: 'DYNAMIC_INTERNAL';
|
|
1492
|
+
name: string;
|
|
1493
|
+
note?: string;
|
|
1494
|
+
ddns: {
|
|
1495
|
+
id?: string;
|
|
1496
|
+
username: string;
|
|
1497
|
+
password?: string;
|
|
1498
|
+
domain: string;
|
|
1499
|
+
};
|
|
1500
|
+
dynamicIp: string;
|
|
1501
|
+
}>;
|
|
1502
|
+
}>;
|
|
1503
|
+
}>;
|
|
1504
|
+
};
|
|
1505
|
+
export type GetRoutersResponse = GetRoutersResponses[keyof GetRoutersResponses];
|
|
1506
|
+
export type CreateRouterData = {
|
|
1507
|
+
body: {
|
|
1508
|
+
name: string;
|
|
1509
|
+
physicalDeviceId: string;
|
|
1510
|
+
organizationId: string;
|
|
1511
|
+
network: {
|
|
1512
|
+
type: 'ddns';
|
|
1513
|
+
username: string;
|
|
1514
|
+
password: string;
|
|
1515
|
+
multiWan?: number;
|
|
1516
|
+
} | {
|
|
1517
|
+
type: 'doh' | 'dot';
|
|
1518
|
+
policyId: string;
|
|
1519
|
+
};
|
|
1520
|
+
note?: string;
|
|
1521
|
+
};
|
|
1522
|
+
path?: never;
|
|
1523
|
+
query?: never;
|
|
1524
|
+
url: '/v1/routers';
|
|
1525
|
+
};
|
|
1526
|
+
export type CreateRouterErrors = {
|
|
1527
|
+
/**
|
|
1528
|
+
* Unauthorized
|
|
1529
|
+
*/
|
|
1530
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1531
|
+
/**
|
|
1532
|
+
* Forbidden
|
|
1533
|
+
*/
|
|
1534
|
+
403: FlashStartErrorBody;
|
|
1535
|
+
/**
|
|
1536
|
+
* Not found
|
|
1537
|
+
*/
|
|
1538
|
+
404: FlashStartErrorBody;
|
|
1539
|
+
/**
|
|
1540
|
+
* Invalid request
|
|
1541
|
+
*/
|
|
1542
|
+
422: FlashStartErrorBody;
|
|
1543
|
+
/**
|
|
1544
|
+
* Internal server error
|
|
1545
|
+
*/
|
|
1546
|
+
500: FlashStartErrorBody;
|
|
1547
|
+
};
|
|
1548
|
+
export type CreateRouterError = CreateRouterErrors[keyof CreateRouterErrors];
|
|
1549
|
+
export type CreateRouterResponses = {
|
|
1550
|
+
/**
|
|
1551
|
+
* Created router
|
|
1552
|
+
*/
|
|
1553
|
+
201: {
|
|
1554
|
+
id: string;
|
|
1555
|
+
name: string;
|
|
1556
|
+
organizationId: string;
|
|
1557
|
+
physicalDeviceId: string;
|
|
1558
|
+
note?: string;
|
|
1559
|
+
networks: Array<{
|
|
1560
|
+
primaryNetwork: {
|
|
1561
|
+
id: string;
|
|
1562
|
+
type: 'STATIC_ENCRYPTED';
|
|
1563
|
+
name: string;
|
|
1564
|
+
note?: string;
|
|
1565
|
+
tag: string;
|
|
1566
|
+
} | {
|
|
1567
|
+
id: string;
|
|
1568
|
+
type: 'DYNAMIC_INTERNAL';
|
|
1569
|
+
name: string;
|
|
1570
|
+
note?: string;
|
|
1571
|
+
ddns: {
|
|
1572
|
+
id?: string;
|
|
1573
|
+
username: string;
|
|
1574
|
+
password?: string;
|
|
1575
|
+
domain: string;
|
|
1576
|
+
};
|
|
1577
|
+
dynamicIp: string;
|
|
1578
|
+
};
|
|
1579
|
+
secondaryNetworks: Array<{
|
|
1580
|
+
id: string;
|
|
1581
|
+
type: 'STATIC_ENCRYPTED';
|
|
1582
|
+
name: string;
|
|
1583
|
+
note?: string;
|
|
1584
|
+
tag: string;
|
|
1585
|
+
} | {
|
|
1586
|
+
id: string;
|
|
1587
|
+
type: 'DYNAMIC_INTERNAL';
|
|
1588
|
+
name: string;
|
|
1589
|
+
note?: string;
|
|
1590
|
+
ddns: {
|
|
1591
|
+
id?: string;
|
|
1592
|
+
username: string;
|
|
1593
|
+
password?: string;
|
|
1594
|
+
domain: string;
|
|
1595
|
+
};
|
|
1596
|
+
dynamicIp: string;
|
|
1597
|
+
}>;
|
|
1598
|
+
}>;
|
|
1599
|
+
};
|
|
1600
|
+
};
|
|
1601
|
+
export type CreateRouterResponse = CreateRouterResponses[keyof CreateRouterResponses];
|
|
1602
|
+
export type DeleteRouterData = {
|
|
1603
|
+
body?: never;
|
|
1604
|
+
path: {
|
|
1605
|
+
routerId: string;
|
|
1606
|
+
};
|
|
1607
|
+
query?: never;
|
|
1608
|
+
url: '/v1/routers/{routerId}';
|
|
1609
|
+
};
|
|
1610
|
+
export type DeleteRouterErrors = {
|
|
1611
|
+
/**
|
|
1612
|
+
* Unauthorized
|
|
1613
|
+
*/
|
|
1614
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1615
|
+
/**
|
|
1616
|
+
* Forbidden
|
|
1617
|
+
*/
|
|
1618
|
+
403: FlashStartErrorBody;
|
|
1619
|
+
/**
|
|
1620
|
+
* Not found
|
|
1621
|
+
*/
|
|
1622
|
+
404: FlashStartErrorBody;
|
|
1623
|
+
/**
|
|
1624
|
+
* Invalid request
|
|
1625
|
+
*/
|
|
1626
|
+
422: FlashStartErrorBody;
|
|
1627
|
+
/**
|
|
1628
|
+
* Internal server error
|
|
1629
|
+
*/
|
|
1630
|
+
500: FlashStartErrorBody;
|
|
1631
|
+
};
|
|
1632
|
+
export type DeleteRouterError = DeleteRouterErrors[keyof DeleteRouterErrors];
|
|
1633
|
+
export type DeleteRouterResponses = {
|
|
1634
|
+
/**
|
|
1635
|
+
* Deleted router
|
|
1636
|
+
*/
|
|
1637
|
+
200: {
|
|
1638
|
+
id: string;
|
|
1639
|
+
name: string;
|
|
1640
|
+
organizationId: string;
|
|
1641
|
+
physicalDeviceId: string;
|
|
1642
|
+
note?: string;
|
|
1643
|
+
networks: Array<{
|
|
1644
|
+
primaryNetwork: {
|
|
1645
|
+
id: string;
|
|
1646
|
+
type: 'STATIC_ENCRYPTED';
|
|
1647
|
+
name: string;
|
|
1648
|
+
note?: string;
|
|
1649
|
+
tag: string;
|
|
1650
|
+
} | {
|
|
1651
|
+
id: string;
|
|
1652
|
+
type: 'DYNAMIC_INTERNAL';
|
|
1653
|
+
name: string;
|
|
1654
|
+
note?: string;
|
|
1655
|
+
ddns: {
|
|
1656
|
+
id?: string;
|
|
1657
|
+
username: string;
|
|
1658
|
+
password?: string;
|
|
1659
|
+
domain: string;
|
|
1660
|
+
};
|
|
1661
|
+
dynamicIp: string;
|
|
1662
|
+
};
|
|
1663
|
+
secondaryNetworks: Array<{
|
|
1664
|
+
id: string;
|
|
1665
|
+
type: 'STATIC_ENCRYPTED';
|
|
1666
|
+
name: string;
|
|
1667
|
+
note?: string;
|
|
1668
|
+
tag: string;
|
|
1669
|
+
} | {
|
|
1670
|
+
id: string;
|
|
1671
|
+
type: 'DYNAMIC_INTERNAL';
|
|
1672
|
+
name: string;
|
|
1673
|
+
note?: string;
|
|
1674
|
+
ddns: {
|
|
1675
|
+
id?: string;
|
|
1676
|
+
username: string;
|
|
1677
|
+
password?: string;
|
|
1678
|
+
domain: string;
|
|
1679
|
+
};
|
|
1680
|
+
dynamicIp: string;
|
|
1681
|
+
}>;
|
|
1682
|
+
}>;
|
|
1683
|
+
};
|
|
1684
|
+
};
|
|
1685
|
+
export type DeleteRouterResponse = DeleteRouterResponses[keyof DeleteRouterResponses];
|
|
1686
|
+
export type GetRouterData = {
|
|
1687
|
+
body?: never;
|
|
1688
|
+
path: {
|
|
1689
|
+
routerId: string;
|
|
1690
|
+
};
|
|
1691
|
+
query?: never;
|
|
1692
|
+
url: '/v1/routers/{routerId}';
|
|
1693
|
+
};
|
|
1694
|
+
export type GetRouterErrors = {
|
|
1695
|
+
/**
|
|
1696
|
+
* Unauthorized
|
|
1697
|
+
*/
|
|
1698
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1699
|
+
/**
|
|
1700
|
+
* Forbidden
|
|
1701
|
+
*/
|
|
1702
|
+
403: FlashStartErrorBody;
|
|
1703
|
+
/**
|
|
1704
|
+
* Not found
|
|
1705
|
+
*/
|
|
1706
|
+
404: FlashStartErrorBody;
|
|
1707
|
+
/**
|
|
1708
|
+
* Invalid request
|
|
1709
|
+
*/
|
|
1710
|
+
422: FlashStartErrorBody;
|
|
1711
|
+
/**
|
|
1712
|
+
* Internal server error
|
|
1713
|
+
*/
|
|
1714
|
+
500: FlashStartErrorBody;
|
|
1715
|
+
};
|
|
1716
|
+
export type GetRouterError = GetRouterErrors[keyof GetRouterErrors];
|
|
1717
|
+
export type GetRouterResponses = {
|
|
1718
|
+
/**
|
|
1719
|
+
* Router
|
|
1720
|
+
*/
|
|
1721
|
+
200: {
|
|
1722
|
+
id: string;
|
|
1723
|
+
name: string;
|
|
1724
|
+
organizationId: string;
|
|
1725
|
+
physicalDeviceId: string;
|
|
1726
|
+
note?: string;
|
|
1727
|
+
networks: Array<{
|
|
1728
|
+
primaryNetwork: {
|
|
1729
|
+
id: string;
|
|
1730
|
+
type: 'STATIC_ENCRYPTED';
|
|
1731
|
+
name: string;
|
|
1732
|
+
note?: string;
|
|
1733
|
+
tag: string;
|
|
1734
|
+
} | {
|
|
1735
|
+
id: string;
|
|
1736
|
+
type: 'DYNAMIC_INTERNAL';
|
|
1737
|
+
name: string;
|
|
1738
|
+
note?: string;
|
|
1739
|
+
ddns: {
|
|
1740
|
+
id?: string;
|
|
1741
|
+
username: string;
|
|
1742
|
+
password?: string;
|
|
1743
|
+
domain: string;
|
|
1744
|
+
};
|
|
1745
|
+
dynamicIp: string;
|
|
1746
|
+
};
|
|
1747
|
+
secondaryNetworks: Array<{
|
|
1748
|
+
id: string;
|
|
1749
|
+
type: 'STATIC_ENCRYPTED';
|
|
1750
|
+
name: string;
|
|
1751
|
+
note?: string;
|
|
1752
|
+
tag: string;
|
|
1753
|
+
} | {
|
|
1754
|
+
id: string;
|
|
1755
|
+
type: 'DYNAMIC_INTERNAL';
|
|
1756
|
+
name: string;
|
|
1757
|
+
note?: string;
|
|
1758
|
+
ddns: {
|
|
1759
|
+
id?: string;
|
|
1760
|
+
username: string;
|
|
1761
|
+
password?: string;
|
|
1762
|
+
domain: string;
|
|
1763
|
+
};
|
|
1764
|
+
dynamicIp: string;
|
|
1765
|
+
}>;
|
|
1766
|
+
}>;
|
|
1767
|
+
};
|
|
1768
|
+
};
|
|
1769
|
+
export type GetRouterResponse = GetRouterResponses[keyof GetRouterResponses];
|
|
1770
|
+
export type UpdateRouterData = {
|
|
1771
|
+
body: {
|
|
1772
|
+
name?: string;
|
|
1773
|
+
note?: string | null;
|
|
1774
|
+
};
|
|
1775
|
+
path: {
|
|
1776
|
+
routerId: string;
|
|
1777
|
+
};
|
|
1778
|
+
query?: never;
|
|
1779
|
+
url: '/v1/routers/{routerId}';
|
|
1780
|
+
};
|
|
1781
|
+
export type UpdateRouterErrors = {
|
|
1782
|
+
/**
|
|
1783
|
+
* Unauthorized
|
|
1784
|
+
*/
|
|
1785
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1786
|
+
/**
|
|
1787
|
+
* Forbidden
|
|
1788
|
+
*/
|
|
1789
|
+
403: FlashStartErrorBody;
|
|
1790
|
+
/**
|
|
1791
|
+
* Not found
|
|
1792
|
+
*/
|
|
1793
|
+
404: FlashStartErrorBody;
|
|
1794
|
+
/**
|
|
1795
|
+
* Invalid request
|
|
1796
|
+
*/
|
|
1797
|
+
422: FlashStartErrorBody;
|
|
1798
|
+
/**
|
|
1799
|
+
* Internal server error
|
|
1800
|
+
*/
|
|
1801
|
+
500: FlashStartErrorBody;
|
|
1802
|
+
};
|
|
1803
|
+
export type UpdateRouterError = UpdateRouterErrors[keyof UpdateRouterErrors];
|
|
1804
|
+
export type UpdateRouterResponses = {
|
|
1805
|
+
/**
|
|
1806
|
+
* Updated router
|
|
1807
|
+
*/
|
|
1808
|
+
200: {
|
|
1809
|
+
id: string;
|
|
1810
|
+
name: string;
|
|
1811
|
+
organizationId: string;
|
|
1812
|
+
physicalDeviceId: string;
|
|
1813
|
+
note?: string;
|
|
1814
|
+
networks: Array<{
|
|
1815
|
+
primaryNetwork: {
|
|
1816
|
+
id: string;
|
|
1817
|
+
type: 'STATIC_ENCRYPTED';
|
|
1818
|
+
name: string;
|
|
1819
|
+
note?: string;
|
|
1820
|
+
tag: string;
|
|
1821
|
+
} | {
|
|
1822
|
+
id: string;
|
|
1823
|
+
type: 'DYNAMIC_INTERNAL';
|
|
1824
|
+
name: string;
|
|
1825
|
+
note?: string;
|
|
1826
|
+
ddns: {
|
|
1827
|
+
id?: string;
|
|
1828
|
+
username: string;
|
|
1829
|
+
password?: string;
|
|
1830
|
+
domain: string;
|
|
1831
|
+
};
|
|
1832
|
+
dynamicIp: string;
|
|
1833
|
+
};
|
|
1834
|
+
secondaryNetworks: Array<{
|
|
1835
|
+
id: string;
|
|
1836
|
+
type: 'STATIC_ENCRYPTED';
|
|
1837
|
+
name: string;
|
|
1838
|
+
note?: string;
|
|
1839
|
+
tag: string;
|
|
1840
|
+
} | {
|
|
1841
|
+
id: string;
|
|
1842
|
+
type: 'DYNAMIC_INTERNAL';
|
|
1843
|
+
name: string;
|
|
1844
|
+
note?: string;
|
|
1845
|
+
ddns: {
|
|
1846
|
+
id?: string;
|
|
1847
|
+
username: string;
|
|
1848
|
+
password?: string;
|
|
1849
|
+
domain: string;
|
|
1850
|
+
};
|
|
1851
|
+
dynamicIp: string;
|
|
1852
|
+
}>;
|
|
1853
|
+
}>;
|
|
1854
|
+
};
|
|
1855
|
+
};
|
|
1856
|
+
export type UpdateRouterResponse = UpdateRouterResponses[keyof UpdateRouterResponses];
|
|
1857
|
+
export type GetRouterNetworksData = {
|
|
1858
|
+
body?: never;
|
|
1859
|
+
path: {
|
|
1860
|
+
routerId: string;
|
|
1861
|
+
};
|
|
1862
|
+
query?: never;
|
|
1863
|
+
url: '/v1/routers/{routerId}/networks';
|
|
1864
|
+
};
|
|
1865
|
+
export type GetRouterNetworksErrors = {
|
|
1866
|
+
/**
|
|
1867
|
+
* Unauthorized
|
|
1868
|
+
*/
|
|
1869
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1870
|
+
/**
|
|
1871
|
+
* Forbidden
|
|
1872
|
+
*/
|
|
1873
|
+
403: FlashStartErrorBody;
|
|
1874
|
+
/**
|
|
1875
|
+
* Not found
|
|
1876
|
+
*/
|
|
1877
|
+
404: FlashStartErrorBody;
|
|
1878
|
+
/**
|
|
1879
|
+
* Invalid request
|
|
1880
|
+
*/
|
|
1881
|
+
422: FlashStartErrorBody;
|
|
1882
|
+
/**
|
|
1883
|
+
* Internal server error
|
|
1884
|
+
*/
|
|
1885
|
+
500: FlashStartErrorBody;
|
|
1886
|
+
};
|
|
1887
|
+
export type GetRouterNetworksError = GetRouterNetworksErrors[keyof GetRouterNetworksErrors];
|
|
1888
|
+
export type GetRouterNetworksResponses = {
|
|
1889
|
+
/**
|
|
1890
|
+
* Router networks
|
|
1891
|
+
*/
|
|
1892
|
+
200: Array<{
|
|
1893
|
+
id: string;
|
|
1894
|
+
type: 'STATIC_ENCRYPTED';
|
|
1895
|
+
name: string;
|
|
1896
|
+
note?: string;
|
|
1897
|
+
tag: string;
|
|
1898
|
+
} | {
|
|
1899
|
+
id: string;
|
|
1900
|
+
type: 'DYNAMIC_INTERNAL';
|
|
1901
|
+
name: string;
|
|
1902
|
+
note?: string;
|
|
1903
|
+
ddns: {
|
|
1904
|
+
id?: string;
|
|
1905
|
+
username: string;
|
|
1906
|
+
password?: string;
|
|
1907
|
+
domain: string;
|
|
1908
|
+
};
|
|
1909
|
+
dynamicIp: string;
|
|
1910
|
+
}>;
|
|
1911
|
+
};
|
|
1912
|
+
export type GetRouterNetworksResponse = GetRouterNetworksResponses[keyof GetRouterNetworksResponses];
|
|
1913
|
+
export type UpdateDynamicInternalRouterNetworkData = {
|
|
1914
|
+
body: {
|
|
1915
|
+
name?: string;
|
|
1916
|
+
note?: string;
|
|
1917
|
+
ddns?: {
|
|
1918
|
+
username?: string;
|
|
1919
|
+
password?: string;
|
|
1920
|
+
};
|
|
1921
|
+
};
|
|
1922
|
+
path: {
|
|
1923
|
+
routerId: string;
|
|
1924
|
+
networkId: string;
|
|
1925
|
+
};
|
|
1926
|
+
query?: never;
|
|
1927
|
+
url: '/v1/routers/{routerId}/networks/dynamic/internal/{networkId}';
|
|
1928
|
+
};
|
|
1929
|
+
export type UpdateDynamicInternalRouterNetworkErrors = {
|
|
1930
|
+
/**
|
|
1931
|
+
* Unauthorized
|
|
1932
|
+
*/
|
|
1933
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1934
|
+
/**
|
|
1935
|
+
* Forbidden
|
|
1936
|
+
*/
|
|
1937
|
+
403: FlashStartErrorBody;
|
|
1938
|
+
/**
|
|
1939
|
+
* Not found
|
|
1940
|
+
*/
|
|
1941
|
+
404: FlashStartErrorBody;
|
|
1942
|
+
/**
|
|
1943
|
+
* Invalid request
|
|
1944
|
+
*/
|
|
1945
|
+
422: FlashStartErrorBody;
|
|
1946
|
+
/**
|
|
1947
|
+
* Internal server error
|
|
1948
|
+
*/
|
|
1949
|
+
500: FlashStartErrorBody;
|
|
1950
|
+
};
|
|
1951
|
+
export type UpdateDynamicInternalRouterNetworkError = UpdateDynamicInternalRouterNetworkErrors[keyof UpdateDynamicInternalRouterNetworkErrors];
|
|
1952
|
+
export type UpdateDynamicInternalRouterNetworkResponses = {
|
|
1953
|
+
/**
|
|
1954
|
+
* Updated network
|
|
1955
|
+
*/
|
|
1956
|
+
200: {
|
|
1957
|
+
id: string;
|
|
1958
|
+
type: 'STATIC_ENCRYPTED';
|
|
1959
|
+
name: string;
|
|
1960
|
+
note?: string;
|
|
1961
|
+
tag: string;
|
|
1962
|
+
} | {
|
|
1963
|
+
id: string;
|
|
1964
|
+
type: 'DYNAMIC_INTERNAL';
|
|
1965
|
+
name: string;
|
|
1966
|
+
note?: string;
|
|
1967
|
+
ddns: {
|
|
1968
|
+
id?: string;
|
|
1969
|
+
username: string;
|
|
1970
|
+
password?: string;
|
|
1971
|
+
domain: string;
|
|
1972
|
+
};
|
|
1973
|
+
dynamicIp: string;
|
|
1974
|
+
};
|
|
1975
|
+
};
|
|
1976
|
+
export type UpdateDynamicInternalRouterNetworkResponse = UpdateDynamicInternalRouterNetworkResponses[keyof UpdateDynamicInternalRouterNetworkResponses];
|
|
1977
|
+
export type UpdateEncryptedRouterNetworkData = {
|
|
1978
|
+
body: {
|
|
1979
|
+
name?: string;
|
|
1980
|
+
note?: string;
|
|
1981
|
+
policyId?: string;
|
|
1982
|
+
};
|
|
1983
|
+
path: {
|
|
1984
|
+
routerId: string;
|
|
1985
|
+
networkId: string;
|
|
1986
|
+
};
|
|
1987
|
+
query?: never;
|
|
1988
|
+
url: '/v1/routers/{routerId}/networks/encrypted/{networkId}';
|
|
1989
|
+
};
|
|
1990
|
+
export type UpdateEncryptedRouterNetworkErrors = {
|
|
1991
|
+
/**
|
|
1992
|
+
* Unauthorized
|
|
1993
|
+
*/
|
|
1994
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1995
|
+
/**
|
|
1996
|
+
* Forbidden
|
|
1997
|
+
*/
|
|
1998
|
+
403: FlashStartErrorBody;
|
|
1999
|
+
/**
|
|
2000
|
+
* Not found
|
|
2001
|
+
*/
|
|
2002
|
+
404: FlashStartErrorBody;
|
|
2003
|
+
/**
|
|
2004
|
+
* Invalid request
|
|
2005
|
+
*/
|
|
2006
|
+
422: FlashStartErrorBody;
|
|
2007
|
+
/**
|
|
2008
|
+
* Internal server error
|
|
2009
|
+
*/
|
|
2010
|
+
500: FlashStartErrorBody;
|
|
2011
|
+
};
|
|
2012
|
+
export type UpdateEncryptedRouterNetworkError = UpdateEncryptedRouterNetworkErrors[keyof UpdateEncryptedRouterNetworkErrors];
|
|
2013
|
+
export type UpdateEncryptedRouterNetworkResponses = {
|
|
2014
|
+
/**
|
|
2015
|
+
* Updated network
|
|
2016
|
+
*/
|
|
2017
|
+
200: {
|
|
2018
|
+
id: string;
|
|
2019
|
+
type: 'STATIC_ENCRYPTED';
|
|
2020
|
+
name: string;
|
|
2021
|
+
note?: string;
|
|
2022
|
+
tag: string;
|
|
2023
|
+
} | {
|
|
2024
|
+
id: string;
|
|
2025
|
+
type: 'DYNAMIC_INTERNAL';
|
|
2026
|
+
name: string;
|
|
2027
|
+
note?: string;
|
|
2028
|
+
ddns: {
|
|
2029
|
+
id?: string;
|
|
2030
|
+
username: string;
|
|
2031
|
+
password?: string;
|
|
2032
|
+
domain: string;
|
|
2033
|
+
};
|
|
2034
|
+
dynamicIp: string;
|
|
2035
|
+
};
|
|
2036
|
+
};
|
|
2037
|
+
export type UpdateEncryptedRouterNetworkResponse = UpdateEncryptedRouterNetworkResponses[keyof UpdateEncryptedRouterNetworkResponses];
|
|
2038
|
+
export type GetRouterPoliciesData = {
|
|
2039
|
+
body?: never;
|
|
2040
|
+
path: {
|
|
2041
|
+
routerId: string;
|
|
2042
|
+
};
|
|
2043
|
+
query?: never;
|
|
2044
|
+
url: '/v1/routers/{routerId}/policies';
|
|
2045
|
+
};
|
|
2046
|
+
export type GetRouterPoliciesErrors = {
|
|
2047
|
+
/**
|
|
2048
|
+
* Unauthorized
|
|
2049
|
+
*/
|
|
2050
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
2051
|
+
/**
|
|
2052
|
+
* Forbidden
|
|
2053
|
+
*/
|
|
2054
|
+
403: FlashStartErrorBody;
|
|
2055
|
+
/**
|
|
2056
|
+
* Not found
|
|
2057
|
+
*/
|
|
2058
|
+
404: FlashStartErrorBody;
|
|
2059
|
+
/**
|
|
2060
|
+
* Invalid request
|
|
2061
|
+
*/
|
|
2062
|
+
422: FlashStartErrorBody;
|
|
2063
|
+
/**
|
|
2064
|
+
* Internal server error
|
|
2065
|
+
*/
|
|
2066
|
+
500: FlashStartErrorBody;
|
|
2067
|
+
};
|
|
2068
|
+
export type GetRouterPoliciesError = GetRouterPoliciesErrors[keyof GetRouterPoliciesErrors];
|
|
2069
|
+
export type GetRouterPoliciesResponses = {
|
|
2070
|
+
/**
|
|
2071
|
+
* Router policies
|
|
2072
|
+
*/
|
|
2073
|
+
200: Array<{
|
|
2074
|
+
routerId: string;
|
|
2075
|
+
networkId: string;
|
|
2076
|
+
policy: {
|
|
2077
|
+
id: string;
|
|
2078
|
+
isLimited: boolean;
|
|
2079
|
+
isShared: boolean;
|
|
2080
|
+
name: string;
|
|
2081
|
+
organizationId: string;
|
|
2082
|
+
};
|
|
2083
|
+
note?: string;
|
|
2084
|
+
dns?: {
|
|
2085
|
+
id: string;
|
|
2086
|
+
port: number;
|
|
2087
|
+
primaryDns: string;
|
|
2088
|
+
secondaryDns: string;
|
|
2089
|
+
};
|
|
2090
|
+
tag?: string;
|
|
2091
|
+
}>;
|
|
2092
|
+
};
|
|
2093
|
+
export type GetRouterPoliciesResponse = GetRouterPoliciesResponses[keyof GetRouterPoliciesResponses];
|
|
2094
|
+
export type AssociateRouterNetworkPolicyData = {
|
|
2095
|
+
body: {
|
|
2096
|
+
policyId: string;
|
|
2097
|
+
note?: string;
|
|
2098
|
+
dnsId: string;
|
|
2099
|
+
};
|
|
2100
|
+
path: {
|
|
2101
|
+
routerId: string;
|
|
2102
|
+
networkId: string;
|
|
2103
|
+
};
|
|
2104
|
+
query?: never;
|
|
2105
|
+
url: '/v1/routers/{routerId}/networks/{networkId}/policies';
|
|
2106
|
+
};
|
|
2107
|
+
export type AssociateRouterNetworkPolicyErrors = {
|
|
2108
|
+
/**
|
|
2109
|
+
* Unauthorized
|
|
2110
|
+
*/
|
|
2111
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
2112
|
+
/**
|
|
2113
|
+
* Forbidden
|
|
2114
|
+
*/
|
|
2115
|
+
403: FlashStartErrorBody;
|
|
2116
|
+
/**
|
|
2117
|
+
* Not found
|
|
2118
|
+
*/
|
|
2119
|
+
404: FlashStartErrorBody;
|
|
2120
|
+
/**
|
|
2121
|
+
* Invalid request
|
|
2122
|
+
*/
|
|
2123
|
+
422: FlashStartErrorBody;
|
|
2124
|
+
/**
|
|
2125
|
+
* Internal server error
|
|
2126
|
+
*/
|
|
2127
|
+
500: FlashStartErrorBody;
|
|
2128
|
+
};
|
|
2129
|
+
export type AssociateRouterNetworkPolicyError = AssociateRouterNetworkPolicyErrors[keyof AssociateRouterNetworkPolicyErrors];
|
|
2130
|
+
export type AssociateRouterNetworkPolicyResponses = {
|
|
2131
|
+
/**
|
|
2132
|
+
* Associated policy
|
|
2133
|
+
*/
|
|
2134
|
+
201: {
|
|
2135
|
+
routerId: string;
|
|
2136
|
+
networkId: string;
|
|
2137
|
+
policy: {
|
|
2138
|
+
id: string;
|
|
2139
|
+
isLimited: boolean;
|
|
2140
|
+
isShared: boolean;
|
|
2141
|
+
name: string;
|
|
2142
|
+
organizationId: string;
|
|
2143
|
+
};
|
|
2144
|
+
note?: string;
|
|
2145
|
+
dns?: {
|
|
2146
|
+
id: string;
|
|
2147
|
+
port: number;
|
|
2148
|
+
primaryDns: string;
|
|
2149
|
+
secondaryDns: string;
|
|
2150
|
+
};
|
|
2151
|
+
tag?: string;
|
|
2152
|
+
};
|
|
2153
|
+
};
|
|
2154
|
+
export type AssociateRouterNetworkPolicyResponse = AssociateRouterNetworkPolicyResponses[keyof AssociateRouterNetworkPolicyResponses];
|
|
2155
|
+
export type DissociateRouterNetworkPolicyData = {
|
|
2156
|
+
body?: never;
|
|
2157
|
+
path: {
|
|
2158
|
+
routerId: string;
|
|
2159
|
+
networkId: string;
|
|
2160
|
+
policyId: string;
|
|
2161
|
+
};
|
|
2162
|
+
query?: never;
|
|
2163
|
+
url: '/v1/routers/{routerId}/networks/{networkId}/policies/{policyId}';
|
|
2164
|
+
};
|
|
2165
|
+
export type DissociateRouterNetworkPolicyErrors = {
|
|
2166
|
+
/**
|
|
2167
|
+
* Unauthorized
|
|
2168
|
+
*/
|
|
2169
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
2170
|
+
/**
|
|
2171
|
+
* Forbidden
|
|
2172
|
+
*/
|
|
2173
|
+
403: FlashStartErrorBody;
|
|
2174
|
+
/**
|
|
2175
|
+
* Not found
|
|
2176
|
+
*/
|
|
2177
|
+
404: FlashStartErrorBody;
|
|
2178
|
+
/**
|
|
2179
|
+
* Invalid request
|
|
2180
|
+
*/
|
|
2181
|
+
422: FlashStartErrorBody;
|
|
2182
|
+
/**
|
|
2183
|
+
* Internal server error
|
|
2184
|
+
*/
|
|
2185
|
+
500: FlashStartErrorBody;
|
|
2186
|
+
};
|
|
2187
|
+
export type DissociateRouterNetworkPolicyError = DissociateRouterNetworkPolicyErrors[keyof DissociateRouterNetworkPolicyErrors];
|
|
2188
|
+
export type DissociateRouterNetworkPolicyResponses = {
|
|
2189
|
+
/**
|
|
2190
|
+
* Dissociated policy
|
|
2191
|
+
*/
|
|
2192
|
+
200: {
|
|
2193
|
+
routerId: string;
|
|
2194
|
+
networkId: string;
|
|
2195
|
+
policy: {
|
|
2196
|
+
id: string;
|
|
2197
|
+
isLimited: boolean;
|
|
2198
|
+
isShared: boolean;
|
|
2199
|
+
name: string;
|
|
2200
|
+
organizationId: string;
|
|
2201
|
+
};
|
|
2202
|
+
note?: string;
|
|
2203
|
+
dns?: {
|
|
2204
|
+
id: string;
|
|
2205
|
+
port: number;
|
|
2206
|
+
primaryDns: string;
|
|
2207
|
+
secondaryDns: string;
|
|
2208
|
+
};
|
|
2209
|
+
tag?: string;
|
|
2210
|
+
};
|
|
2211
|
+
};
|
|
2212
|
+
export type DissociateRouterNetworkPolicyResponse = DissociateRouterNetworkPolicyResponses[keyof DissociateRouterNetworkPolicyResponses];
|
|
2213
|
+
export type GetRouterConfigurationScriptParametersData = {
|
|
2214
|
+
body?: never;
|
|
2215
|
+
path: {
|
|
2216
|
+
routerId: string;
|
|
2217
|
+
};
|
|
2218
|
+
query?: never;
|
|
2219
|
+
url: '/v1/routers/{routerId}/configuration-script';
|
|
2220
|
+
};
|
|
2221
|
+
export type GetRouterConfigurationScriptParametersErrors = {
|
|
2222
|
+
/**
|
|
2223
|
+
* Unauthorized
|
|
2224
|
+
*/
|
|
2225
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
2226
|
+
/**
|
|
2227
|
+
* Forbidden
|
|
2228
|
+
*/
|
|
2229
|
+
403: FlashStartErrorBody;
|
|
2230
|
+
/**
|
|
2231
|
+
* Not found
|
|
2232
|
+
*/
|
|
2233
|
+
404: FlashStartErrorBody;
|
|
2234
|
+
/**
|
|
2235
|
+
* Invalid request
|
|
2236
|
+
*/
|
|
2237
|
+
422: FlashStartErrorBody;
|
|
2238
|
+
/**
|
|
2239
|
+
* Internal server error
|
|
2240
|
+
*/
|
|
2241
|
+
500: FlashStartErrorBody;
|
|
2242
|
+
};
|
|
2243
|
+
export type GetRouterConfigurationScriptParametersError = GetRouterConfigurationScriptParametersErrors[keyof GetRouterConfigurationScriptParametersErrors];
|
|
2244
|
+
export type GetRouterConfigurationScriptParametersResponses = {
|
|
2245
|
+
/**
|
|
2246
|
+
* Router configuration script parameters
|
|
2247
|
+
*/
|
|
2248
|
+
200: {
|
|
2249
|
+
routerCode: 'mikrotik';
|
|
2250
|
+
networkType: 'DYNAMIC_INTERNAL';
|
|
2251
|
+
ddnsCredentials: Array<{
|
|
2252
|
+
username: string;
|
|
2253
|
+
password: string;
|
|
2254
|
+
}>;
|
|
2255
|
+
policyConnections: Array<{
|
|
2256
|
+
policyName: string;
|
|
2257
|
+
dnsAddress: string;
|
|
2258
|
+
}>;
|
|
2259
|
+
} | {
|
|
2260
|
+
routerCode: 'mikrotik';
|
|
2261
|
+
networkType: 'STATIC_ENCRYPTED';
|
|
2262
|
+
tag: string;
|
|
2263
|
+
policyName: string;
|
|
2264
|
+
};
|
|
2265
|
+
};
|
|
2266
|
+
export type GetRouterConfigurationScriptParametersResponse = GetRouterConfigurationScriptParametersResponses[keyof GetRouterConfigurationScriptParametersResponses];
|
|
2267
|
+
export type GetEndpointPoliciesData = {
|
|
2268
|
+
body?: never;
|
|
2269
|
+
path?: never;
|
|
2270
|
+
query?: {
|
|
2271
|
+
organizationId?: string;
|
|
2272
|
+
};
|
|
2273
|
+
url: '/v1/endpoints/policies';
|
|
2274
|
+
};
|
|
2275
|
+
export type GetEndpointPoliciesErrors = {
|
|
2276
|
+
/**
|
|
2277
|
+
* Unauthorized
|
|
2278
|
+
*/
|
|
2279
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
2280
|
+
/**
|
|
2281
|
+
* Forbidden
|
|
2282
|
+
*/
|
|
2283
|
+
403: FlashStartErrorBody;
|
|
2284
|
+
/**
|
|
2285
|
+
* Not found
|
|
2286
|
+
*/
|
|
2287
|
+
404: FlashStartErrorBody;
|
|
2288
|
+
/**
|
|
2289
|
+
* Invalid request
|
|
2290
|
+
*/
|
|
2291
|
+
422: FlashStartErrorBody;
|
|
2292
|
+
/**
|
|
2293
|
+
* Internal server error
|
|
2294
|
+
*/
|
|
2295
|
+
500: FlashStartErrorBody;
|
|
2296
|
+
};
|
|
2297
|
+
export type GetEndpointPoliciesError = GetEndpointPoliciesErrors[keyof GetEndpointPoliciesErrors];
|
|
2298
|
+
export type GetEndpointPoliciesResponses = {
|
|
2299
|
+
/**
|
|
2300
|
+
* Endpoint policies
|
|
2301
|
+
*/
|
|
2302
|
+
200: Array<{
|
|
2303
|
+
id: string;
|
|
2304
|
+
policyId: string;
|
|
2305
|
+
policyKey: string;
|
|
2306
|
+
securePin: string;
|
|
2307
|
+
uninstallPin: string;
|
|
2308
|
+
uninstallPinRequired: boolean;
|
|
2309
|
+
officeStandupEnabled: boolean;
|
|
2310
|
+
importUserEnabled: boolean;
|
|
2311
|
+
createdAt: string | string;
|
|
2312
|
+
updatedAt: string | string;
|
|
2313
|
+
}>;
|
|
2314
|
+
};
|
|
2315
|
+
export type GetEndpointPoliciesResponse = GetEndpointPoliciesResponses[keyof GetEndpointPoliciesResponses];
|
|
2316
|
+
export type GetEndpointPolicyByIdData = {
|
|
2317
|
+
body?: never;
|
|
2318
|
+
path: {
|
|
2319
|
+
endpointPolicyId: string;
|
|
2320
|
+
};
|
|
2321
|
+
query?: never;
|
|
2322
|
+
url: '/v1/endpoints/policies/{endpointPolicyId}';
|
|
2323
|
+
};
|
|
2324
|
+
export type GetEndpointPolicyByIdErrors = {
|
|
2325
|
+
/**
|
|
2326
|
+
* Unauthorized
|
|
2327
|
+
*/
|
|
2328
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
2329
|
+
/**
|
|
2330
|
+
* Forbidden
|
|
2331
|
+
*/
|
|
2332
|
+
403: FlashStartErrorBody;
|
|
2333
|
+
/**
|
|
2334
|
+
* Not found
|
|
2335
|
+
*/
|
|
2336
|
+
404: FlashStartErrorBody;
|
|
2337
|
+
/**
|
|
2338
|
+
* Invalid request
|
|
2339
|
+
*/
|
|
2340
|
+
422: FlashStartErrorBody;
|
|
2341
|
+
/**
|
|
2342
|
+
* Internal server error
|
|
2343
|
+
*/
|
|
2344
|
+
500: FlashStartErrorBody;
|
|
2345
|
+
};
|
|
2346
|
+
export type GetEndpointPolicyByIdError = GetEndpointPolicyByIdErrors[keyof GetEndpointPolicyByIdErrors];
|
|
2347
|
+
export type GetEndpointPolicyByIdResponses = {
|
|
2348
|
+
/**
|
|
2349
|
+
* Endpoint policy
|
|
2350
|
+
*/
|
|
2351
|
+
200: {
|
|
2352
|
+
id: string;
|
|
2353
|
+
policyId: string;
|
|
2354
|
+
policyKey: string;
|
|
2355
|
+
securePin: string;
|
|
2356
|
+
uninstallPin: string;
|
|
2357
|
+
uninstallPinRequired: boolean;
|
|
2358
|
+
officeStandupEnabled: boolean;
|
|
2359
|
+
importUserEnabled: boolean;
|
|
2360
|
+
createdAt: string | string;
|
|
2361
|
+
updatedAt: string | string;
|
|
2362
|
+
};
|
|
2363
|
+
};
|
|
2364
|
+
export type GetEndpointPolicyByIdResponse = GetEndpointPolicyByIdResponses[keyof GetEndpointPolicyByIdResponses];
|
|
2365
|
+
export type UpdateEndpointPolicyData = {
|
|
2366
|
+
body: {
|
|
2367
|
+
officeStandupEnabled?: boolean;
|
|
2368
|
+
importUserEnabled?: boolean;
|
|
2369
|
+
uninstallPinRequired?: boolean;
|
|
2370
|
+
regenerateSecurePin?: boolean;
|
|
2371
|
+
regenerateUninstallPin?: boolean;
|
|
2372
|
+
};
|
|
2373
|
+
path: {
|
|
2374
|
+
endpointPolicyId: string;
|
|
2375
|
+
};
|
|
2376
|
+
query?: never;
|
|
2377
|
+
url: '/v1/endpoints/policies/{endpointPolicyId}';
|
|
2378
|
+
};
|
|
2379
|
+
export type UpdateEndpointPolicyErrors = {
|
|
2380
|
+
/**
|
|
2381
|
+
* Unauthorized
|
|
2382
|
+
*/
|
|
2383
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
2384
|
+
/**
|
|
2385
|
+
* Forbidden
|
|
2386
|
+
*/
|
|
2387
|
+
403: FlashStartErrorBody;
|
|
2388
|
+
/**
|
|
2389
|
+
* Not found
|
|
2390
|
+
*/
|
|
2391
|
+
404: FlashStartErrorBody;
|
|
2392
|
+
/**
|
|
2393
|
+
* Invalid request
|
|
2394
|
+
*/
|
|
2395
|
+
422: FlashStartErrorBody;
|
|
2396
|
+
/**
|
|
2397
|
+
* Internal server error
|
|
2398
|
+
*/
|
|
2399
|
+
500: FlashStartErrorBody;
|
|
2400
|
+
};
|
|
2401
|
+
export type UpdateEndpointPolicyError = UpdateEndpointPolicyErrors[keyof UpdateEndpointPolicyErrors];
|
|
2402
|
+
export type UpdateEndpointPolicyResponses = {
|
|
2403
|
+
/**
|
|
2404
|
+
* Updated endpoint policy
|
|
2405
|
+
*/
|
|
2406
|
+
200: {
|
|
2407
|
+
id: string;
|
|
2408
|
+
policyId: string;
|
|
2409
|
+
policyKey: string;
|
|
2410
|
+
securePin: string;
|
|
2411
|
+
uninstallPin: string;
|
|
2412
|
+
uninstallPinRequired: boolean;
|
|
2413
|
+
officeStandupEnabled: boolean;
|
|
2414
|
+
importUserEnabled: boolean;
|
|
2415
|
+
createdAt: string | string;
|
|
2416
|
+
updatedAt: string | string;
|
|
2417
|
+
};
|
|
2418
|
+
};
|
|
2419
|
+
export type UpdateEndpointPolicyResponse = UpdateEndpointPolicyResponses[keyof UpdateEndpointPolicyResponses];
|
|
2420
|
+
export type GetEndpointsData = {
|
|
2421
|
+
body?: never;
|
|
2422
|
+
path?: never;
|
|
2423
|
+
query?: {
|
|
2424
|
+
organizationId?: string;
|
|
2425
|
+
};
|
|
2426
|
+
url: '/v1/endpoints';
|
|
2427
|
+
};
|
|
2428
|
+
export type GetEndpointsErrors = {
|
|
2429
|
+
/**
|
|
2430
|
+
* Unauthorized
|
|
2431
|
+
*/
|
|
2432
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
2433
|
+
/**
|
|
2434
|
+
* Forbidden
|
|
2435
|
+
*/
|
|
2436
|
+
403: FlashStartErrorBody;
|
|
2437
|
+
/**
|
|
2438
|
+
* Not found
|
|
2439
|
+
*/
|
|
2440
|
+
404: FlashStartErrorBody;
|
|
2441
|
+
/**
|
|
2442
|
+
* Invalid request
|
|
2443
|
+
*/
|
|
2444
|
+
422: FlashStartErrorBody;
|
|
2445
|
+
/**
|
|
2446
|
+
* Internal server error
|
|
2447
|
+
*/
|
|
2448
|
+
500: FlashStartErrorBody;
|
|
2449
|
+
};
|
|
2450
|
+
export type GetEndpointsError = GetEndpointsErrors[keyof GetEndpointsErrors];
|
|
2451
|
+
export type GetEndpointsResponses = {
|
|
2452
|
+
/**
|
|
2453
|
+
* Endpoints
|
|
2454
|
+
*/
|
|
2455
|
+
200: Array<{
|
|
2456
|
+
id: string;
|
|
2457
|
+
clientId: string;
|
|
2458
|
+
ip: string;
|
|
2459
|
+
loggedUser?: string;
|
|
2460
|
+
organizationId: string;
|
|
2461
|
+
endPointPolicy: {
|
|
2462
|
+
id: string;
|
|
2463
|
+
policyId: string;
|
|
2464
|
+
policyKey: string;
|
|
2465
|
+
securePin: string;
|
|
2466
|
+
uninstallPin: string;
|
|
2467
|
+
uninstallPinRequired: boolean;
|
|
2468
|
+
officeStandupEnabled: boolean;
|
|
2469
|
+
importUserEnabled: boolean;
|
|
2470
|
+
createdAt: string | string;
|
|
2471
|
+
updatedAt: string | string;
|
|
2472
|
+
};
|
|
2473
|
+
networkId: string;
|
|
2474
|
+
name: string;
|
|
2475
|
+
platform: 'WINDOWS' | 'ANDROID' | 'IOS' | 'MACOS' | 'LINUX' | 'CHROMEBOOK';
|
|
2476
|
+
flow: 'VPN' | 'DOH';
|
|
2477
|
+
active: boolean;
|
|
2478
|
+
lockedMessage?: string;
|
|
2479
|
+
version?: string;
|
|
2480
|
+
runtimeStatus?: 'CREATING_VPN' | 'DISCONNECTED' | 'CONNECTED' | 'CREATING_DNS' | 'VALIDATION_FAILED' | 'INCORRECT_KEY' | 'NOT_CREATED' | 'NOT_REGISTERED' | 'NO_TAP' | 'FLASHSTART_NETWORK_DETECTED';
|
|
2481
|
+
createdAt: string | string;
|
|
2482
|
+
updatedAt: string | string;
|
|
2483
|
+
}>;
|
|
2484
|
+
};
|
|
2485
|
+
export type GetEndpointsResponse = GetEndpointsResponses[keyof GetEndpointsResponses];
|
|
2486
|
+
export type DeleteEndpointData = {
|
|
2487
|
+
body?: never;
|
|
2488
|
+
path: {
|
|
2489
|
+
endpointId: string;
|
|
2490
|
+
};
|
|
2491
|
+
query?: never;
|
|
2492
|
+
url: '/v1/endpoints/{endpointId}';
|
|
2493
|
+
};
|
|
2494
|
+
export type DeleteEndpointErrors = {
|
|
2495
|
+
/**
|
|
2496
|
+
* Unauthorized
|
|
2497
|
+
*/
|
|
2498
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
2499
|
+
/**
|
|
2500
|
+
* Forbidden
|
|
2501
|
+
*/
|
|
2502
|
+
403: FlashStartErrorBody;
|
|
2503
|
+
/**
|
|
2504
|
+
* Not found
|
|
2505
|
+
*/
|
|
2506
|
+
404: FlashStartErrorBody;
|
|
2507
|
+
/**
|
|
2508
|
+
* Invalid request
|
|
2509
|
+
*/
|
|
2510
|
+
422: FlashStartErrorBody;
|
|
2511
|
+
/**
|
|
2512
|
+
* Internal server error
|
|
2513
|
+
*/
|
|
2514
|
+
500: FlashStartErrorBody;
|
|
2515
|
+
};
|
|
2516
|
+
export type DeleteEndpointError = DeleteEndpointErrors[keyof DeleteEndpointErrors];
|
|
2517
|
+
export type DeleteEndpointResponses = {
|
|
2518
|
+
/**
|
|
2519
|
+
* Endpoint deleted
|
|
2520
|
+
*/
|
|
2521
|
+
204: void;
|
|
2522
|
+
};
|
|
2523
|
+
export type DeleteEndpointResponse = DeleteEndpointResponses[keyof DeleteEndpointResponses];
|
|
2524
|
+
export type GetEndpointByIdData = {
|
|
2525
|
+
body?: never;
|
|
2526
|
+
path: {
|
|
2527
|
+
endpointId: string;
|
|
2528
|
+
};
|
|
2529
|
+
query?: never;
|
|
2530
|
+
url: '/v1/endpoints/{endpointId}';
|
|
2531
|
+
};
|
|
2532
|
+
export type GetEndpointByIdErrors = {
|
|
2533
|
+
/**
|
|
2534
|
+
* Unauthorized
|
|
2535
|
+
*/
|
|
2536
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
2537
|
+
/**
|
|
2538
|
+
* Forbidden
|
|
2539
|
+
*/
|
|
2540
|
+
403: FlashStartErrorBody;
|
|
2541
|
+
/**
|
|
2542
|
+
* Not found
|
|
2543
|
+
*/
|
|
2544
|
+
404: FlashStartErrorBody;
|
|
2545
|
+
/**
|
|
2546
|
+
* Invalid request
|
|
2547
|
+
*/
|
|
2548
|
+
422: FlashStartErrorBody;
|
|
2549
|
+
/**
|
|
2550
|
+
* Internal server error
|
|
2551
|
+
*/
|
|
2552
|
+
500: FlashStartErrorBody;
|
|
2553
|
+
};
|
|
2554
|
+
export type GetEndpointByIdError = GetEndpointByIdErrors[keyof GetEndpointByIdErrors];
|
|
2555
|
+
export type GetEndpointByIdResponses = {
|
|
2556
|
+
/**
|
|
2557
|
+
* Endpoint
|
|
2558
|
+
*/
|
|
2559
|
+
200: {
|
|
2560
|
+
id: string;
|
|
2561
|
+
clientId: string;
|
|
2562
|
+
ip: string;
|
|
2563
|
+
loggedUser?: string;
|
|
2564
|
+
organizationId: string;
|
|
2565
|
+
endPointPolicy: {
|
|
2566
|
+
id: string;
|
|
2567
|
+
policyId: string;
|
|
2568
|
+
policyKey: string;
|
|
2569
|
+
securePin: string;
|
|
2570
|
+
uninstallPin: string;
|
|
2571
|
+
uninstallPinRequired: boolean;
|
|
2572
|
+
officeStandupEnabled: boolean;
|
|
2573
|
+
importUserEnabled: boolean;
|
|
2574
|
+
createdAt: string | string;
|
|
2575
|
+
updatedAt: string | string;
|
|
2576
|
+
};
|
|
2577
|
+
networkId: string;
|
|
2578
|
+
name: string;
|
|
2579
|
+
platform: 'WINDOWS' | 'ANDROID' | 'IOS' | 'MACOS' | 'LINUX' | 'CHROMEBOOK';
|
|
2580
|
+
flow: 'VPN' | 'DOH';
|
|
2581
|
+
active: boolean;
|
|
2582
|
+
lockedMessage?: string;
|
|
2583
|
+
version?: string;
|
|
2584
|
+
runtimeStatus?: 'CREATING_VPN' | 'DISCONNECTED' | 'CONNECTED' | 'CREATING_DNS' | 'VALIDATION_FAILED' | 'INCORRECT_KEY' | 'NOT_CREATED' | 'NOT_REGISTERED' | 'NO_TAP' | 'FLASHSTART_NETWORK_DETECTED';
|
|
2585
|
+
createdAt: string | string;
|
|
2586
|
+
updatedAt: string | string;
|
|
2587
|
+
};
|
|
2588
|
+
};
|
|
2589
|
+
export type GetEndpointByIdResponse = GetEndpointByIdResponses[keyof GetEndpointByIdResponses];
|
|
2590
|
+
export type UpdateEndpointData = {
|
|
2591
|
+
body: {
|
|
2592
|
+
name?: string;
|
|
2593
|
+
endpointPolicyId?: string;
|
|
2594
|
+
};
|
|
2595
|
+
path: {
|
|
2596
|
+
endpointId: string;
|
|
2597
|
+
};
|
|
2598
|
+
query?: never;
|
|
2599
|
+
url: '/v1/endpoints/{endpointId}';
|
|
2600
|
+
};
|
|
2601
|
+
export type UpdateEndpointErrors = {
|
|
2602
|
+
/**
|
|
2603
|
+
* Unauthorized
|
|
2604
|
+
*/
|
|
2605
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
2606
|
+
/**
|
|
2607
|
+
* Forbidden
|
|
2608
|
+
*/
|
|
2609
|
+
403: FlashStartErrorBody;
|
|
2610
|
+
/**
|
|
2611
|
+
* Not found
|
|
2612
|
+
*/
|
|
2613
|
+
404: FlashStartErrorBody;
|
|
2614
|
+
/**
|
|
2615
|
+
* Invalid request
|
|
2616
|
+
*/
|
|
2617
|
+
422: FlashStartErrorBody;
|
|
2618
|
+
/**
|
|
2619
|
+
* Internal server error
|
|
2620
|
+
*/
|
|
2621
|
+
500: FlashStartErrorBody;
|
|
2622
|
+
};
|
|
2623
|
+
export type UpdateEndpointError = UpdateEndpointErrors[keyof UpdateEndpointErrors];
|
|
2624
|
+
export type UpdateEndpointResponses = {
|
|
2625
|
+
/**
|
|
2626
|
+
* Updated endpoint
|
|
2627
|
+
*/
|
|
2628
|
+
200: {
|
|
2629
|
+
id: string;
|
|
2630
|
+
clientId: string;
|
|
2631
|
+
ip: string;
|
|
2632
|
+
loggedUser?: string;
|
|
2633
|
+
organizationId: string;
|
|
2634
|
+
endPointPolicy: {
|
|
2635
|
+
id: string;
|
|
2636
|
+
policyId: string;
|
|
2637
|
+
policyKey: string;
|
|
2638
|
+
securePin: string;
|
|
2639
|
+
uninstallPin: string;
|
|
2640
|
+
uninstallPinRequired: boolean;
|
|
2641
|
+
officeStandupEnabled: boolean;
|
|
2642
|
+
importUserEnabled: boolean;
|
|
2643
|
+
createdAt: string | string;
|
|
2644
|
+
updatedAt: string | string;
|
|
2645
|
+
};
|
|
2646
|
+
networkId: string;
|
|
2647
|
+
name: string;
|
|
2648
|
+
platform: 'WINDOWS' | 'ANDROID' | 'IOS' | 'MACOS' | 'LINUX' | 'CHROMEBOOK';
|
|
2649
|
+
flow: 'VPN' | 'DOH';
|
|
2650
|
+
active: boolean;
|
|
2651
|
+
lockedMessage?: string;
|
|
2652
|
+
version?: string;
|
|
2653
|
+
runtimeStatus?: 'CREATING_VPN' | 'DISCONNECTED' | 'CONNECTED' | 'CREATING_DNS' | 'VALIDATION_FAILED' | 'INCORRECT_KEY' | 'NOT_CREATED' | 'NOT_REGISTERED' | 'NO_TAP' | 'FLASHSTART_NETWORK_DETECTED';
|
|
2654
|
+
createdAt: string | string;
|
|
2655
|
+
updatedAt: string | string;
|
|
2656
|
+
};
|
|
2657
|
+
};
|
|
2658
|
+
export type UpdateEndpointResponse = UpdateEndpointResponses[keyof UpdateEndpointResponses];
|