@uipath/admin-tool 1.205.0-preview.281 → 1.206.0-preview.279
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/dist/{index-37jrt4wz.js → index-0tbanmrb.js} +79 -85
- package/dist/{index-3mgpezgw.js → index-h9t95d1v.js} +58 -64
- package/dist/{index-3v0kv44y.js → index-jd9v7pra.js} +207 -2986
- package/dist/{index-00ks13f2.js → index-s679w9k7.js} +2100 -40
- package/dist/{index-esy280as.js → index-x4997kvr.js} +2 -22
- package/dist/{index-6s9xyeev.js → index-x8zxgeh4.js} +22 -28
- package/dist/{jmespath-v0jttxep.js → jmespath-z30y456m.js} +1 -1
- package/dist/{js-yaml-qv0npwpc.js → js-yaml-cr6n3g9w.js} +1 -3
- package/dist/{tool-nwbftwhg.js → tool-1nnqcf86.js} +36 -21
- package/dist/{tool-x2rahref.js → tool-qqkhh98w.js} +36 -41
- package/dist/tool-vp6z9an2.js +867 -0
- package/dist/{tool-vwvd47vw.js → tool-y4t90j0d.js} +25 -33
- package/dist/{tool-2wtwtawb.js → tool-zg1at4tw.js} +1131 -594
- package/dist/tool.js +11 -13
- package/package.json +2 -2
- package/dist/tool-1yh8g550.js +0 -52
- package/dist/tool-hsqb6sve.js +0 -2859
|
@@ -0,0 +1,867 @@
|
|
|
1
|
+
import {
|
|
2
|
+
getAuthContext
|
|
3
|
+
} from "./tool-1nnqcf86.js";
|
|
4
|
+
import {
|
|
5
|
+
getSdkUserAgentToken,
|
|
6
|
+
addSdkUserAgentHeader,
|
|
7
|
+
installSdkUserAgentHeader
|
|
8
|
+
} from "./tool-zg1at4tw.js";
|
|
9
|
+
|
|
10
|
+
// ../identity-sdk/generated/src/runtime.ts
|
|
11
|
+
var BASE_PATH = "https://alpha.uipath.com/identity_".replace(/\/+$/, "");
|
|
12
|
+
|
|
13
|
+
class Configuration {
|
|
14
|
+
configuration;
|
|
15
|
+
constructor(configuration = {}) {
|
|
16
|
+
this.configuration = configuration;
|
|
17
|
+
}
|
|
18
|
+
set config(configuration) {
|
|
19
|
+
this.configuration = configuration;
|
|
20
|
+
}
|
|
21
|
+
get basePath() {
|
|
22
|
+
return this.configuration.basePath != null ? this.configuration.basePath : BASE_PATH;
|
|
23
|
+
}
|
|
24
|
+
get fetchApi() {
|
|
25
|
+
return this.configuration.fetchApi;
|
|
26
|
+
}
|
|
27
|
+
get middleware() {
|
|
28
|
+
return this.configuration.middleware || [];
|
|
29
|
+
}
|
|
30
|
+
get queryParamsStringify() {
|
|
31
|
+
return this.configuration.queryParamsStringify || querystring;
|
|
32
|
+
}
|
|
33
|
+
get username() {
|
|
34
|
+
return this.configuration.username;
|
|
35
|
+
}
|
|
36
|
+
get password() {
|
|
37
|
+
return this.configuration.password;
|
|
38
|
+
}
|
|
39
|
+
get apiKey() {
|
|
40
|
+
const apiKey = this.configuration.apiKey;
|
|
41
|
+
if (apiKey) {
|
|
42
|
+
return typeof apiKey === "function" ? apiKey : () => apiKey;
|
|
43
|
+
}
|
|
44
|
+
return;
|
|
45
|
+
}
|
|
46
|
+
get accessToken() {
|
|
47
|
+
const accessToken = this.configuration.accessToken;
|
|
48
|
+
if (accessToken) {
|
|
49
|
+
return typeof accessToken === "function" ? accessToken : async () => accessToken;
|
|
50
|
+
}
|
|
51
|
+
return;
|
|
52
|
+
}
|
|
53
|
+
get headers() {
|
|
54
|
+
return this.configuration.headers;
|
|
55
|
+
}
|
|
56
|
+
get credentials() {
|
|
57
|
+
return this.configuration.credentials;
|
|
58
|
+
}
|
|
59
|
+
}
|
|
60
|
+
var DefaultConfig = new Configuration;
|
|
61
|
+
|
|
62
|
+
class BaseAPI {
|
|
63
|
+
configuration;
|
|
64
|
+
static jsonRegex = new RegExp("^(:?application/json|[^;/ \t]+/[^;/ \t]+[+]json)[ \t]*(:?;.*)?$", "i");
|
|
65
|
+
middleware;
|
|
66
|
+
constructor(configuration = DefaultConfig) {
|
|
67
|
+
this.configuration = configuration;
|
|
68
|
+
this.middleware = configuration.middleware;
|
|
69
|
+
}
|
|
70
|
+
withMiddleware(...middlewares) {
|
|
71
|
+
const next = this.clone();
|
|
72
|
+
next.middleware = next.middleware.concat(...middlewares);
|
|
73
|
+
return next;
|
|
74
|
+
}
|
|
75
|
+
withPreMiddleware(...preMiddlewares) {
|
|
76
|
+
const middlewares = preMiddlewares.map((pre) => ({ pre }));
|
|
77
|
+
return this.withMiddleware(...middlewares);
|
|
78
|
+
}
|
|
79
|
+
withPostMiddleware(...postMiddlewares) {
|
|
80
|
+
const middlewares = postMiddlewares.map((post) => ({ post }));
|
|
81
|
+
return this.withMiddleware(...middlewares);
|
|
82
|
+
}
|
|
83
|
+
isJsonMime(mime) {
|
|
84
|
+
if (!mime) {
|
|
85
|
+
return false;
|
|
86
|
+
}
|
|
87
|
+
return BaseAPI.jsonRegex.test(mime);
|
|
88
|
+
}
|
|
89
|
+
async request(context, initOverrides) {
|
|
90
|
+
const { url, init } = await this.createFetchParams(context, initOverrides);
|
|
91
|
+
const response = await this.fetchApi(url, init);
|
|
92
|
+
if (response && (response.status >= 200 && response.status < 300)) {
|
|
93
|
+
return response;
|
|
94
|
+
}
|
|
95
|
+
throw new ResponseError(response, "Response returned an error code");
|
|
96
|
+
}
|
|
97
|
+
async createFetchParams(context, initOverrides) {
|
|
98
|
+
let url = this.configuration.basePath + context.path;
|
|
99
|
+
if (context.query !== undefined && Object.keys(context.query).length !== 0) {
|
|
100
|
+
url += "?" + this.configuration.queryParamsStringify(context.query);
|
|
101
|
+
}
|
|
102
|
+
const headers = Object.assign({}, this.configuration.headers, context.headers);
|
|
103
|
+
Object.keys(headers).forEach((key) => headers[key] === undefined ? delete headers[key] : {});
|
|
104
|
+
const initOverrideFn = typeof initOverrides === "function" ? initOverrides : async () => initOverrides;
|
|
105
|
+
const initParams = {
|
|
106
|
+
method: context.method,
|
|
107
|
+
headers,
|
|
108
|
+
body: context.body,
|
|
109
|
+
credentials: this.configuration.credentials
|
|
110
|
+
};
|
|
111
|
+
const overriddenInit = {
|
|
112
|
+
...initParams,
|
|
113
|
+
...await initOverrideFn({
|
|
114
|
+
init: initParams,
|
|
115
|
+
context
|
|
116
|
+
})
|
|
117
|
+
};
|
|
118
|
+
let body;
|
|
119
|
+
if (isFormData(overriddenInit.body) || overriddenInit.body instanceof URLSearchParams || isBlob(overriddenInit.body)) {
|
|
120
|
+
body = overriddenInit.body;
|
|
121
|
+
} else if (this.isJsonMime(headers["Content-Type"])) {
|
|
122
|
+
body = JSON.stringify(overriddenInit.body);
|
|
123
|
+
} else {
|
|
124
|
+
body = overriddenInit.body;
|
|
125
|
+
}
|
|
126
|
+
const init = {
|
|
127
|
+
...overriddenInit,
|
|
128
|
+
body
|
|
129
|
+
};
|
|
130
|
+
return { url, init };
|
|
131
|
+
}
|
|
132
|
+
fetchApi = async (url, init) => {
|
|
133
|
+
let fetchParams = { url, init };
|
|
134
|
+
for (const middleware of this.middleware) {
|
|
135
|
+
if (middleware.pre) {
|
|
136
|
+
fetchParams = await middleware.pre({
|
|
137
|
+
fetch: this.fetchApi,
|
|
138
|
+
...fetchParams
|
|
139
|
+
}) || fetchParams;
|
|
140
|
+
}
|
|
141
|
+
}
|
|
142
|
+
let response = undefined;
|
|
143
|
+
try {
|
|
144
|
+
response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
|
|
145
|
+
} catch (e) {
|
|
146
|
+
for (const middleware of this.middleware) {
|
|
147
|
+
if (middleware.onError) {
|
|
148
|
+
response = await middleware.onError({
|
|
149
|
+
fetch: this.fetchApi,
|
|
150
|
+
url: fetchParams.url,
|
|
151
|
+
init: fetchParams.init,
|
|
152
|
+
error: e,
|
|
153
|
+
response: response ? response.clone() : undefined
|
|
154
|
+
}) || response;
|
|
155
|
+
}
|
|
156
|
+
}
|
|
157
|
+
if (response === undefined) {
|
|
158
|
+
if (e instanceof Error) {
|
|
159
|
+
throw new FetchError(e, "The request failed and the interceptors did not return an alternative response");
|
|
160
|
+
} else {
|
|
161
|
+
throw e;
|
|
162
|
+
}
|
|
163
|
+
}
|
|
164
|
+
}
|
|
165
|
+
for (const middleware of this.middleware) {
|
|
166
|
+
if (middleware.post) {
|
|
167
|
+
response = await middleware.post({
|
|
168
|
+
fetch: this.fetchApi,
|
|
169
|
+
url: fetchParams.url,
|
|
170
|
+
init: fetchParams.init,
|
|
171
|
+
response: response.clone()
|
|
172
|
+
}) || response;
|
|
173
|
+
}
|
|
174
|
+
}
|
|
175
|
+
return response;
|
|
176
|
+
};
|
|
177
|
+
clone() {
|
|
178
|
+
const constructor = this.constructor;
|
|
179
|
+
const next = new constructor(this.configuration);
|
|
180
|
+
next.middleware = this.middleware.slice();
|
|
181
|
+
return next;
|
|
182
|
+
}
|
|
183
|
+
}
|
|
184
|
+
function isBlob(value) {
|
|
185
|
+
return typeof Blob !== "undefined" && value instanceof Blob;
|
|
186
|
+
}
|
|
187
|
+
function isFormData(value) {
|
|
188
|
+
return typeof FormData !== "undefined" && value instanceof FormData;
|
|
189
|
+
}
|
|
190
|
+
|
|
191
|
+
class ResponseError extends Error {
|
|
192
|
+
response;
|
|
193
|
+
name = "ResponseError";
|
|
194
|
+
constructor(response, msg) {
|
|
195
|
+
super(msg);
|
|
196
|
+
this.response = response;
|
|
197
|
+
}
|
|
198
|
+
}
|
|
199
|
+
|
|
200
|
+
class FetchError extends Error {
|
|
201
|
+
cause;
|
|
202
|
+
name = "FetchError";
|
|
203
|
+
constructor(cause, msg) {
|
|
204
|
+
super(msg);
|
|
205
|
+
this.cause = cause;
|
|
206
|
+
}
|
|
207
|
+
}
|
|
208
|
+
|
|
209
|
+
class RequiredError extends Error {
|
|
210
|
+
field;
|
|
211
|
+
name = "RequiredError";
|
|
212
|
+
constructor(field, msg) {
|
|
213
|
+
super(msg);
|
|
214
|
+
this.field = field;
|
|
215
|
+
}
|
|
216
|
+
}
|
|
217
|
+
function querystring(params, prefix = "") {
|
|
218
|
+
return Object.keys(params).map((key) => querystringSingleKey(key, params[key], prefix)).filter((part) => part.length > 0).join("&");
|
|
219
|
+
}
|
|
220
|
+
function querystringSingleKey(key, value, keyPrefix = "") {
|
|
221
|
+
const fullKey = keyPrefix + (keyPrefix.length ? `[${key}]` : key);
|
|
222
|
+
if (value instanceof Array) {
|
|
223
|
+
const multiValue = value.map((singleValue) => encodeURIComponent(String(singleValue))).join(`&${encodeURIComponent(fullKey)}=`);
|
|
224
|
+
return `${encodeURIComponent(fullKey)}=${multiValue}`;
|
|
225
|
+
}
|
|
226
|
+
if (value instanceof Set) {
|
|
227
|
+
const valueAsArray = Array.from(value);
|
|
228
|
+
return querystringSingleKey(key, valueAsArray, keyPrefix);
|
|
229
|
+
}
|
|
230
|
+
if (value instanceof Date) {
|
|
231
|
+
return `${encodeURIComponent(fullKey)}=${encodeURIComponent(value.toISOString())}`;
|
|
232
|
+
}
|
|
233
|
+
if (value instanceof Object) {
|
|
234
|
+
return querystring(value, fullKey);
|
|
235
|
+
}
|
|
236
|
+
return `${encodeURIComponent(fullKey)}=${encodeURIComponent(String(value))}`;
|
|
237
|
+
}
|
|
238
|
+
class JSONApiResponse {
|
|
239
|
+
raw;
|
|
240
|
+
transformer;
|
|
241
|
+
constructor(raw, transformer = (jsonValue) => jsonValue) {
|
|
242
|
+
this.raw = raw;
|
|
243
|
+
this.transformer = transformer;
|
|
244
|
+
}
|
|
245
|
+
async value() {
|
|
246
|
+
return this.transformer(await this.raw.json());
|
|
247
|
+
}
|
|
248
|
+
}
|
|
249
|
+
|
|
250
|
+
class VoidApiResponse {
|
|
251
|
+
raw;
|
|
252
|
+
constructor(raw) {
|
|
253
|
+
this.raw = raw;
|
|
254
|
+
}
|
|
255
|
+
async value() {
|
|
256
|
+
return;
|
|
257
|
+
}
|
|
258
|
+
}
|
|
259
|
+
class TextApiResponse {
|
|
260
|
+
raw;
|
|
261
|
+
constructor(raw) {
|
|
262
|
+
this.raw = raw;
|
|
263
|
+
}
|
|
264
|
+
async value() {
|
|
265
|
+
return await this.raw.text();
|
|
266
|
+
}
|
|
267
|
+
}
|
|
268
|
+
|
|
269
|
+
// ../identity-sdk/generated/src/models/BulkSoftDeleteCommand.ts
|
|
270
|
+
function BulkSoftDeleteCommandToJSON(json) {
|
|
271
|
+
return BulkSoftDeleteCommandToJSONTyped(json, false);
|
|
272
|
+
}
|
|
273
|
+
function BulkSoftDeleteCommandToJSONTyped(value, ignoreDiscriminator = false) {
|
|
274
|
+
if (value == null) {
|
|
275
|
+
return value;
|
|
276
|
+
}
|
|
277
|
+
return {
|
|
278
|
+
partitionGlobalId: value["partitionGlobalId"],
|
|
279
|
+
userIds: value["userIds"]
|
|
280
|
+
};
|
|
281
|
+
}
|
|
282
|
+
|
|
283
|
+
// ../identity-sdk/generated/src/models/ChangeUserPasswordCommand.ts
|
|
284
|
+
function ChangeUserPasswordCommandToJSON(json) {
|
|
285
|
+
return ChangeUserPasswordCommandToJSONTyped(json, false);
|
|
286
|
+
}
|
|
287
|
+
function ChangeUserPasswordCommandToJSONTyped(value, ignoreDiscriminator = false) {
|
|
288
|
+
if (value == null) {
|
|
289
|
+
return value;
|
|
290
|
+
}
|
|
291
|
+
return {
|
|
292
|
+
oldPassword: value["oldPassword"],
|
|
293
|
+
newPassword: value["newPassword"]
|
|
294
|
+
};
|
|
295
|
+
}
|
|
296
|
+
|
|
297
|
+
// ../identity-sdk/generated/src/models/CreateUserLoginCommand.ts
|
|
298
|
+
function CreateUserLoginCommandToJSON(json) {
|
|
299
|
+
return CreateUserLoginCommandToJSONTyped(json, false);
|
|
300
|
+
}
|
|
301
|
+
function CreateUserLoginCommandToJSONTyped(value, ignoreDiscriminator = false) {
|
|
302
|
+
if (value == null) {
|
|
303
|
+
return value;
|
|
304
|
+
}
|
|
305
|
+
return {
|
|
306
|
+
loginProvider: value["loginProvider"],
|
|
307
|
+
providerKey: value["providerKey"],
|
|
308
|
+
providerDisplayName: value["providerDisplayName"]
|
|
309
|
+
};
|
|
310
|
+
}
|
|
311
|
+
|
|
312
|
+
// ../identity-sdk/generated/src/models/UserType.ts
|
|
313
|
+
function UserTypeFromJSON(json) {
|
|
314
|
+
return UserTypeFromJSONTyped(json, false);
|
|
315
|
+
}
|
|
316
|
+
function UserTypeFromJSONTyped(json, ignoreDiscriminator) {
|
|
317
|
+
return json;
|
|
318
|
+
}
|
|
319
|
+
function UserTypeToJSON(value) {
|
|
320
|
+
return value;
|
|
321
|
+
}
|
|
322
|
+
|
|
323
|
+
// ../identity-sdk/generated/src/models/CreateUserCommand.ts
|
|
324
|
+
function CreateUserCommandToJSON(json) {
|
|
325
|
+
return CreateUserCommandToJSONTyped(json, false);
|
|
326
|
+
}
|
|
327
|
+
function CreateUserCommandToJSONTyped(value, ignoreDiscriminator = false) {
|
|
328
|
+
if (value == null) {
|
|
329
|
+
return value;
|
|
330
|
+
}
|
|
331
|
+
return {
|
|
332
|
+
id: value["id"],
|
|
333
|
+
userName: value["userName"],
|
|
334
|
+
email: value["email"],
|
|
335
|
+
name: value["name"],
|
|
336
|
+
surname: value["surname"],
|
|
337
|
+
displayName: value["displayName"],
|
|
338
|
+
type: UserTypeToJSON(value["type"]),
|
|
339
|
+
bypassBasicAuthRestriction: value["bypassBasicAuthRestriction"],
|
|
340
|
+
legacyId: value["legacyId"],
|
|
341
|
+
invitationAccepted: value["invitationAccepted"],
|
|
342
|
+
partitionGlobalId: value["partitionGlobalId"],
|
|
343
|
+
password: value["password"],
|
|
344
|
+
validatePassword: value["validatePassword"],
|
|
345
|
+
groupIDs: value["groupIDs"],
|
|
346
|
+
userLogins: value["userLogins"] == null ? undefined : value["userLogins"].map(CreateUserLoginCommandToJSON)
|
|
347
|
+
};
|
|
348
|
+
}
|
|
349
|
+
|
|
350
|
+
// ../identity-sdk/generated/src/models/CreateUserCommandBase.ts
|
|
351
|
+
function CreateUserCommandBaseToJSON(json) {
|
|
352
|
+
return CreateUserCommandBaseToJSONTyped(json, false);
|
|
353
|
+
}
|
|
354
|
+
function CreateUserCommandBaseToJSONTyped(value, ignoreDiscriminator = false) {
|
|
355
|
+
if (value == null) {
|
|
356
|
+
return value;
|
|
357
|
+
}
|
|
358
|
+
return {
|
|
359
|
+
id: value["id"],
|
|
360
|
+
userName: value["userName"],
|
|
361
|
+
email: value["email"],
|
|
362
|
+
name: value["name"],
|
|
363
|
+
surname: value["surname"],
|
|
364
|
+
displayName: value["displayName"],
|
|
365
|
+
type: UserTypeToJSON(value["type"]),
|
|
366
|
+
bypassBasicAuthRestriction: value["bypassBasicAuthRestriction"],
|
|
367
|
+
legacyId: value["legacyId"],
|
|
368
|
+
invitationAccepted: value["invitationAccepted"]
|
|
369
|
+
};
|
|
370
|
+
}
|
|
371
|
+
|
|
372
|
+
// ../identity-sdk/generated/src/models/CreateUsersCommand.ts
|
|
373
|
+
function CreateUsersCommandToJSON(json) {
|
|
374
|
+
return CreateUsersCommandToJSONTyped(json, false);
|
|
375
|
+
}
|
|
376
|
+
function CreateUsersCommandToJSONTyped(value, ignoreDiscriminator = false) {
|
|
377
|
+
if (value == null) {
|
|
378
|
+
return value;
|
|
379
|
+
}
|
|
380
|
+
return {
|
|
381
|
+
users: value["users"] == null ? undefined : value["users"].map(CreateUserCommandBaseToJSON),
|
|
382
|
+
partitionGlobalId: value["partitionGlobalId"],
|
|
383
|
+
groupIDs: value["groupIDs"]
|
|
384
|
+
};
|
|
385
|
+
}
|
|
386
|
+
|
|
387
|
+
// ../identity-sdk/generated/src/models/IdentityError.ts
|
|
388
|
+
function IdentityErrorFromJSON(json) {
|
|
389
|
+
return IdentityErrorFromJSONTyped(json, false);
|
|
390
|
+
}
|
|
391
|
+
function IdentityErrorFromJSONTyped(json, ignoreDiscriminator) {
|
|
392
|
+
if (json == null) {
|
|
393
|
+
return json;
|
|
394
|
+
}
|
|
395
|
+
return {
|
|
396
|
+
code: json["code"] == null ? undefined : json["code"],
|
|
397
|
+
description: json["description"] == null ? undefined : json["description"]
|
|
398
|
+
};
|
|
399
|
+
}
|
|
400
|
+
|
|
401
|
+
// ../identity-sdk/generated/src/models/IdentityResult.ts
|
|
402
|
+
function IdentityResultFromJSON(json) {
|
|
403
|
+
return IdentityResultFromJSONTyped(json, false);
|
|
404
|
+
}
|
|
405
|
+
function IdentityResultFromJSONTyped(json, ignoreDiscriminator) {
|
|
406
|
+
if (json == null) {
|
|
407
|
+
return json;
|
|
408
|
+
}
|
|
409
|
+
return {
|
|
410
|
+
succeeded: json["succeeded"] == null ? undefined : json["succeeded"],
|
|
411
|
+
errors: json["errors"] == null ? undefined : json["errors"].map(IdentityErrorFromJSON)
|
|
412
|
+
};
|
|
413
|
+
}
|
|
414
|
+
|
|
415
|
+
// ../identity-sdk/generated/src/models/InviteUserResult.ts
|
|
416
|
+
function InviteUserResultFromJSON(json) {
|
|
417
|
+
return InviteUserResultFromJSONTyped(json, false);
|
|
418
|
+
}
|
|
419
|
+
function InviteUserResultFromJSONTyped(json, ignoreDiscriminator) {
|
|
420
|
+
if (json == null) {
|
|
421
|
+
return json;
|
|
422
|
+
}
|
|
423
|
+
return {
|
|
424
|
+
email: json["email"] == null ? undefined : json["email"],
|
|
425
|
+
id: json["id"] == null ? undefined : json["id"],
|
|
426
|
+
errorMsg: json["errorMsg"] == null ? undefined : json["errorMsg"],
|
|
427
|
+
success: json["success"] == null ? undefined : json["success"]
|
|
428
|
+
};
|
|
429
|
+
}
|
|
430
|
+
|
|
431
|
+
// ../identity-sdk/generated/src/models/InviteUsersResult.ts
|
|
432
|
+
function InviteUsersResultFromJSON(json) {
|
|
433
|
+
return InviteUsersResultFromJSONTyped(json, false);
|
|
434
|
+
}
|
|
435
|
+
function InviteUsersResultFromJSONTyped(json, ignoreDiscriminator) {
|
|
436
|
+
if (json == null) {
|
|
437
|
+
return json;
|
|
438
|
+
}
|
|
439
|
+
return {
|
|
440
|
+
result: json["result"] == null ? undefined : IdentityResultFromJSON(json["result"]),
|
|
441
|
+
users: json["users"] == null ? undefined : json["users"].map(InviteUserResultFromJSON)
|
|
442
|
+
};
|
|
443
|
+
}
|
|
444
|
+
|
|
445
|
+
// ../identity-sdk/generated/src/models/InvitedUser.ts
|
|
446
|
+
function InvitedUserToJSON(json) {
|
|
447
|
+
return InvitedUserToJSONTyped(json, false);
|
|
448
|
+
}
|
|
449
|
+
function InvitedUserToJSONTyped(value, ignoreDiscriminator = false) {
|
|
450
|
+
if (value == null) {
|
|
451
|
+
return value;
|
|
452
|
+
}
|
|
453
|
+
return {
|
|
454
|
+
groupIDs: value["groupIDs"],
|
|
455
|
+
name: value["name"],
|
|
456
|
+
surname: value["surname"],
|
|
457
|
+
redirectUrl: value["redirectUrl"],
|
|
458
|
+
email: value["email"],
|
|
459
|
+
language: value["language"]
|
|
460
|
+
};
|
|
461
|
+
}
|
|
462
|
+
|
|
463
|
+
// ../identity-sdk/generated/src/models/UserDto.ts
|
|
464
|
+
function UserDtoFromJSON(json) {
|
|
465
|
+
return UserDtoFromJSONTyped(json, false);
|
|
466
|
+
}
|
|
467
|
+
function UserDtoFromJSONTyped(json, ignoreDiscriminator) {
|
|
468
|
+
if (json == null) {
|
|
469
|
+
return json;
|
|
470
|
+
}
|
|
471
|
+
return {
|
|
472
|
+
id: json["id"] == null ? undefined : json["id"],
|
|
473
|
+
userName: json["userName"] == null ? undefined : json["userName"],
|
|
474
|
+
email: json["email"] == null ? undefined : json["email"],
|
|
475
|
+
emailConfirmed: json["emailConfirmed"] == null ? undefined : json["emailConfirmed"],
|
|
476
|
+
name: json["name"] == null ? undefined : json["name"],
|
|
477
|
+
surname: json["surname"] == null ? undefined : json["surname"],
|
|
478
|
+
displayName: json["displayName"] == null ? undefined : json["displayName"],
|
|
479
|
+
creationTime: json["creationTime"] == null ? undefined : new Date(json["creationTime"]),
|
|
480
|
+
lastModificationTime: json["lastModificationTime"] == null ? undefined : new Date(json["lastModificationTime"]),
|
|
481
|
+
lastLoginTime: json["lastLoginTime"] == null ? undefined : new Date(json["lastLoginTime"]),
|
|
482
|
+
groupIDs: json["groupIDs"] == null ? undefined : json["groupIDs"],
|
|
483
|
+
legacyId: json["legacyId"] == null ? undefined : json["legacyId"],
|
|
484
|
+
isActive: json["isActive"] == null ? undefined : json["isActive"],
|
|
485
|
+
bypassBasicAuthRestriction: json["bypassBasicAuthRestriction"] == null ? undefined : json["bypassBasicAuthRestriction"],
|
|
486
|
+
type: json["type"] == null ? undefined : UserTypeFromJSON(json["type"]),
|
|
487
|
+
invitationAccepted: json["invitationAccepted"] == null ? undefined : json["invitationAccepted"]
|
|
488
|
+
};
|
|
489
|
+
}
|
|
490
|
+
|
|
491
|
+
// ../identity-sdk/generated/src/models/UpdateUserCommand.ts
|
|
492
|
+
function UpdateUserCommandToJSON(json) {
|
|
493
|
+
return UpdateUserCommandToJSONTyped(json, false);
|
|
494
|
+
}
|
|
495
|
+
function UpdateUserCommandToJSONTyped(value, ignoreDiscriminator = false) {
|
|
496
|
+
if (value == null) {
|
|
497
|
+
return value;
|
|
498
|
+
}
|
|
499
|
+
return {
|
|
500
|
+
name: value["name"],
|
|
501
|
+
surname: value["surname"],
|
|
502
|
+
displayName: value["displayName"],
|
|
503
|
+
email: value["email"],
|
|
504
|
+
isActive: value["isActive"],
|
|
505
|
+
password: value["password"],
|
|
506
|
+
groupIDsToAdd: value["groupIDsToAdd"],
|
|
507
|
+
groupIDsToRemove: value["groupIDsToRemove"],
|
|
508
|
+
bypassBasicAuthRestriction: value["bypassBasicAuthRestriction"],
|
|
509
|
+
invitationAccepted: value["invitationAccepted"],
|
|
510
|
+
extensionUserAttributesToAddOrUpdate: value["extensionUserAttributesToAddOrUpdate"],
|
|
511
|
+
extensionUserAttributesToRemove: value["extensionUserAttributesToRemove"]
|
|
512
|
+
};
|
|
513
|
+
}
|
|
514
|
+
|
|
515
|
+
// ../identity-sdk/generated/src/models/UserDtoPagedResultDto.ts
|
|
516
|
+
function UserDtoPagedResultDtoFromJSON(json) {
|
|
517
|
+
return UserDtoPagedResultDtoFromJSONTyped(json, false);
|
|
518
|
+
}
|
|
519
|
+
function UserDtoPagedResultDtoFromJSONTyped(json, ignoreDiscriminator) {
|
|
520
|
+
if (json == null) {
|
|
521
|
+
return json;
|
|
522
|
+
}
|
|
523
|
+
return {
|
|
524
|
+
totalCount: json["totalCount"] == null ? undefined : json["totalCount"],
|
|
525
|
+
results: json["results"] == null ? undefined : json["results"].map(UserDtoFromJSON)
|
|
526
|
+
};
|
|
527
|
+
}
|
|
528
|
+
|
|
529
|
+
// ../identity-sdk/generated/src/apis/UserApi.ts
|
|
530
|
+
class UserApi extends BaseAPI {
|
|
531
|
+
async userBulkDeleteRaw(requestParameters, initOverrides) {
|
|
532
|
+
const queryParameters = {};
|
|
533
|
+
const headerParameters = {};
|
|
534
|
+
headerParameters["Content-Type"] = "application/json";
|
|
535
|
+
if (this.configuration && this.configuration.accessToken) {
|
|
536
|
+
const token = this.configuration.accessToken;
|
|
537
|
+
const tokenString = await token("Bearer", []);
|
|
538
|
+
if (tokenString) {
|
|
539
|
+
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
|
540
|
+
}
|
|
541
|
+
}
|
|
542
|
+
let urlPath = `/api/User`;
|
|
543
|
+
const response = await this.request({
|
|
544
|
+
path: urlPath,
|
|
545
|
+
method: "DELETE",
|
|
546
|
+
headers: headerParameters,
|
|
547
|
+
query: queryParameters,
|
|
548
|
+
body: BulkSoftDeleteCommandToJSON(requestParameters["bulkSoftDeleteCommand"])
|
|
549
|
+
}, initOverrides);
|
|
550
|
+
return new VoidApiResponse(response);
|
|
551
|
+
}
|
|
552
|
+
async userBulkDelete(requestParameters = {}, initOverrides) {
|
|
553
|
+
await this.userBulkDeleteRaw(requestParameters, initOverrides);
|
|
554
|
+
}
|
|
555
|
+
async userChangePasswordRaw(requestParameters, initOverrides) {
|
|
556
|
+
if (requestParameters["userId"] == null) {
|
|
557
|
+
throw new RequiredError("userId", 'Required parameter "userId" was null or undefined when calling userChangePassword().');
|
|
558
|
+
}
|
|
559
|
+
const queryParameters = {};
|
|
560
|
+
const headerParameters = {};
|
|
561
|
+
headerParameters["Content-Type"] = "application/json";
|
|
562
|
+
if (this.configuration && this.configuration.accessToken) {
|
|
563
|
+
const token = this.configuration.accessToken;
|
|
564
|
+
const tokenString = await token("Bearer", []);
|
|
565
|
+
if (tokenString) {
|
|
566
|
+
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
|
567
|
+
}
|
|
568
|
+
}
|
|
569
|
+
let urlPath = `/api/User/{userId}/changepassword`;
|
|
570
|
+
urlPath = urlPath.replace(`{${"userId"}}`, encodeURIComponent(String(requestParameters["userId"])));
|
|
571
|
+
const response = await this.request({
|
|
572
|
+
path: urlPath,
|
|
573
|
+
method: "POST",
|
|
574
|
+
headers: headerParameters,
|
|
575
|
+
query: queryParameters,
|
|
576
|
+
body: ChangeUserPasswordCommandToJSON(requestParameters["changeUserPasswordCommand"])
|
|
577
|
+
}, initOverrides);
|
|
578
|
+
return new JSONApiResponse(response, (jsonValue) => IdentityResultFromJSON(jsonValue));
|
|
579
|
+
}
|
|
580
|
+
async userChangePassword(requestParameters, initOverrides) {
|
|
581
|
+
const response = await this.userChangePasswordRaw(requestParameters, initOverrides);
|
|
582
|
+
return await response.value();
|
|
583
|
+
}
|
|
584
|
+
async userCreateUserRaw(requestParameters, initOverrides) {
|
|
585
|
+
const queryParameters = {};
|
|
586
|
+
const headerParameters = {};
|
|
587
|
+
headerParameters["Content-Type"] = "application/json";
|
|
588
|
+
if (this.configuration && this.configuration.accessToken) {
|
|
589
|
+
const token = this.configuration.accessToken;
|
|
590
|
+
const tokenString = await token("Bearer", []);
|
|
591
|
+
if (tokenString) {
|
|
592
|
+
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
|
593
|
+
}
|
|
594
|
+
}
|
|
595
|
+
let urlPath = `/api/User`;
|
|
596
|
+
const response = await this.request({
|
|
597
|
+
path: urlPath,
|
|
598
|
+
method: "POST",
|
|
599
|
+
headers: headerParameters,
|
|
600
|
+
query: queryParameters,
|
|
601
|
+
body: CreateUserCommandToJSON(requestParameters["createUserCommand"])
|
|
602
|
+
}, initOverrides);
|
|
603
|
+
return new JSONApiResponse(response, (jsonValue) => IdentityResultFromJSON(jsonValue));
|
|
604
|
+
}
|
|
605
|
+
async userCreateUser(requestParameters = {}, initOverrides) {
|
|
606
|
+
const response = await this.userCreateUserRaw(requestParameters, initOverrides);
|
|
607
|
+
return await response.value();
|
|
608
|
+
}
|
|
609
|
+
async userCreateUsersRaw(requestParameters, initOverrides) {
|
|
610
|
+
const queryParameters = {};
|
|
611
|
+
const headerParameters = {};
|
|
612
|
+
headerParameters["Content-Type"] = "application/json";
|
|
613
|
+
if (this.configuration && this.configuration.accessToken) {
|
|
614
|
+
const token = this.configuration.accessToken;
|
|
615
|
+
const tokenString = await token("Bearer", []);
|
|
616
|
+
if (tokenString) {
|
|
617
|
+
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
|
618
|
+
}
|
|
619
|
+
}
|
|
620
|
+
let urlPath = `/api/User/BulkCreate`;
|
|
621
|
+
const response = await this.request({
|
|
622
|
+
path: urlPath,
|
|
623
|
+
method: "POST",
|
|
624
|
+
headers: headerParameters,
|
|
625
|
+
query: queryParameters,
|
|
626
|
+
body: CreateUsersCommandToJSON(requestParameters["createUsersCommand"])
|
|
627
|
+
}, initOverrides);
|
|
628
|
+
return new JSONApiResponse(response, (jsonValue) => IdentityResultFromJSON(jsonValue));
|
|
629
|
+
}
|
|
630
|
+
async userCreateUsers(requestParameters = {}, initOverrides) {
|
|
631
|
+
const response = await this.userCreateUsersRaw(requestParameters, initOverrides);
|
|
632
|
+
return await response.value();
|
|
633
|
+
}
|
|
634
|
+
async userDeleteRaw(requestParameters, initOverrides) {
|
|
635
|
+
if (requestParameters["userId"] == null) {
|
|
636
|
+
throw new RequiredError("userId", 'Required parameter "userId" was null or undefined when calling userDelete().');
|
|
637
|
+
}
|
|
638
|
+
const queryParameters = {};
|
|
639
|
+
const headerParameters = {};
|
|
640
|
+
if (this.configuration && this.configuration.accessToken) {
|
|
641
|
+
const token = this.configuration.accessToken;
|
|
642
|
+
const tokenString = await token("Bearer", []);
|
|
643
|
+
if (tokenString) {
|
|
644
|
+
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
|
645
|
+
}
|
|
646
|
+
}
|
|
647
|
+
let urlPath = `/api/User/{userId}`;
|
|
648
|
+
urlPath = urlPath.replace(`{${"userId"}}`, encodeURIComponent(String(requestParameters["userId"])));
|
|
649
|
+
const response = await this.request({
|
|
650
|
+
path: urlPath,
|
|
651
|
+
method: "DELETE",
|
|
652
|
+
headers: headerParameters,
|
|
653
|
+
query: queryParameters
|
|
654
|
+
}, initOverrides);
|
|
655
|
+
return new VoidApiResponse(response);
|
|
656
|
+
}
|
|
657
|
+
async userDelete(requestParameters, initOverrides) {
|
|
658
|
+
await this.userDeleteRaw(requestParameters, initOverrides);
|
|
659
|
+
}
|
|
660
|
+
async userGetUserRaw(requestParameters, initOverrides) {
|
|
661
|
+
if (requestParameters["userId"] == null) {
|
|
662
|
+
throw new RequiredError("userId", 'Required parameter "userId" was null or undefined when calling userGetUser().');
|
|
663
|
+
}
|
|
664
|
+
const queryParameters = {};
|
|
665
|
+
const headerParameters = {};
|
|
666
|
+
if (this.configuration && this.configuration.accessToken) {
|
|
667
|
+
const token = this.configuration.accessToken;
|
|
668
|
+
const tokenString = await token("Bearer", []);
|
|
669
|
+
if (tokenString) {
|
|
670
|
+
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
|
671
|
+
}
|
|
672
|
+
}
|
|
673
|
+
let urlPath = `/api/User/{userId}`;
|
|
674
|
+
urlPath = urlPath.replace(`{${"userId"}}`, encodeURIComponent(String(requestParameters["userId"])));
|
|
675
|
+
const response = await this.request({
|
|
676
|
+
path: urlPath,
|
|
677
|
+
method: "GET",
|
|
678
|
+
headers: headerParameters,
|
|
679
|
+
query: queryParameters
|
|
680
|
+
}, initOverrides);
|
|
681
|
+
return new JSONApiResponse(response, (jsonValue) => UserDtoFromJSON(jsonValue));
|
|
682
|
+
}
|
|
683
|
+
async userGetUser(requestParameters, initOverrides) {
|
|
684
|
+
const response = await this.userGetUserRaw(requestParameters, initOverrides);
|
|
685
|
+
return await response.value();
|
|
686
|
+
}
|
|
687
|
+
async userGetUsersRaw(requestParameters, initOverrides) {
|
|
688
|
+
if (requestParameters["partitionGlobalId"] == null) {
|
|
689
|
+
throw new RequiredError("partitionGlobalId", 'Required parameter "partitionGlobalId" was null or undefined when calling userGetUsers().');
|
|
690
|
+
}
|
|
691
|
+
const queryParameters = {};
|
|
692
|
+
if (requestParameters["searchTerm"] != null) {
|
|
693
|
+
queryParameters["searchTerm"] = requestParameters["searchTerm"];
|
|
694
|
+
}
|
|
695
|
+
if (requestParameters["top"] != null) {
|
|
696
|
+
queryParameters["top"] = requestParameters["top"];
|
|
697
|
+
}
|
|
698
|
+
if (requestParameters["skip"] != null) {
|
|
699
|
+
queryParameters["skip"] = requestParameters["skip"];
|
|
700
|
+
}
|
|
701
|
+
if (requestParameters["sortBy"] != null) {
|
|
702
|
+
queryParameters["sortBy"] = requestParameters["sortBy"];
|
|
703
|
+
}
|
|
704
|
+
if (requestParameters["sortOrder"] != null) {
|
|
705
|
+
queryParameters["sortOrder"] = requestParameters["sortOrder"];
|
|
706
|
+
}
|
|
707
|
+
const headerParameters = {};
|
|
708
|
+
if (this.configuration && this.configuration.accessToken) {
|
|
709
|
+
const token = this.configuration.accessToken;
|
|
710
|
+
const tokenString = await token("Bearer", []);
|
|
711
|
+
if (tokenString) {
|
|
712
|
+
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
|
713
|
+
}
|
|
714
|
+
}
|
|
715
|
+
let urlPath = `/api/User/users/{partitionGlobalId}`;
|
|
716
|
+
urlPath = urlPath.replace(`{${"partitionGlobalId"}}`, encodeURIComponent(String(requestParameters["partitionGlobalId"])));
|
|
717
|
+
const response = await this.request({
|
|
718
|
+
path: urlPath,
|
|
719
|
+
method: "GET",
|
|
720
|
+
headers: headerParameters,
|
|
721
|
+
query: queryParameters
|
|
722
|
+
}, initOverrides);
|
|
723
|
+
return new JSONApiResponse(response, (jsonValue) => UserDtoPagedResultDtoFromJSON(jsonValue));
|
|
724
|
+
}
|
|
725
|
+
async userGetUsers(requestParameters, initOverrides) {
|
|
726
|
+
const response = await this.userGetUsersRaw(requestParameters, initOverrides);
|
|
727
|
+
return await response.value();
|
|
728
|
+
}
|
|
729
|
+
async userInviteUsersRaw(requestParameters, initOverrides) {
|
|
730
|
+
const queryParameters = {};
|
|
731
|
+
const headerParameters = {};
|
|
732
|
+
headerParameters["Content-Type"] = "application/json";
|
|
733
|
+
if (this.configuration && this.configuration.accessToken) {
|
|
734
|
+
const token = this.configuration.accessToken;
|
|
735
|
+
const tokenString = await token("Bearer", []);
|
|
736
|
+
if (tokenString) {
|
|
737
|
+
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
|
738
|
+
}
|
|
739
|
+
}
|
|
740
|
+
let urlPath = `/api/User/InviteUsers`;
|
|
741
|
+
const response = await this.request({
|
|
742
|
+
path: urlPath,
|
|
743
|
+
method: "POST",
|
|
744
|
+
headers: headerParameters,
|
|
745
|
+
query: queryParameters,
|
|
746
|
+
body: requestParameters["invitedUser"].map(InvitedUserToJSON)
|
|
747
|
+
}, initOverrides);
|
|
748
|
+
return new JSONApiResponse(response, (jsonValue) => InviteUsersResultFromJSON(jsonValue));
|
|
749
|
+
}
|
|
750
|
+
async userInviteUsers(requestParameters = {}, initOverrides) {
|
|
751
|
+
const response = await this.userInviteUsersRaw(requestParameters, initOverrides);
|
|
752
|
+
return await response.value();
|
|
753
|
+
}
|
|
754
|
+
async userUpdateRaw(requestParameters, initOverrides) {
|
|
755
|
+
if (requestParameters["userId"] == null) {
|
|
756
|
+
throw new RequiredError("userId", 'Required parameter "userId" was null or undefined when calling userUpdate().');
|
|
757
|
+
}
|
|
758
|
+
const queryParameters = {};
|
|
759
|
+
const headerParameters = {};
|
|
760
|
+
headerParameters["Content-Type"] = "application/json";
|
|
761
|
+
if (this.configuration && this.configuration.accessToken) {
|
|
762
|
+
const token = this.configuration.accessToken;
|
|
763
|
+
const tokenString = await token("Bearer", []);
|
|
764
|
+
if (tokenString) {
|
|
765
|
+
headerParameters["Authorization"] = `Bearer ${tokenString}`;
|
|
766
|
+
}
|
|
767
|
+
}
|
|
768
|
+
let urlPath = `/api/User/{userId}`;
|
|
769
|
+
urlPath = urlPath.replace(`{${"userId"}}`, encodeURIComponent(String(requestParameters["userId"])));
|
|
770
|
+
const response = await this.request({
|
|
771
|
+
path: urlPath,
|
|
772
|
+
method: "PUT",
|
|
773
|
+
headers: headerParameters,
|
|
774
|
+
query: queryParameters,
|
|
775
|
+
body: UpdateUserCommandToJSON(requestParameters["updateUserCommand"])
|
|
776
|
+
}, initOverrides);
|
|
777
|
+
return new JSONApiResponse(response, (jsonValue) => IdentityResultFromJSON(jsonValue));
|
|
778
|
+
}
|
|
779
|
+
async userUpdate(requestParameters, initOverrides) {
|
|
780
|
+
const response = await this.userUpdateRaw(requestParameters, initOverrides);
|
|
781
|
+
return await response.value();
|
|
782
|
+
}
|
|
783
|
+
}
|
|
784
|
+
// ../identity-sdk/package.json
|
|
785
|
+
var package_default = {
|
|
786
|
+
name: "@uipath/identity-sdk",
|
|
787
|
+
author: "UiPath",
|
|
788
|
+
license: "SEE LICENSE IN LICENSE.txt",
|
|
789
|
+
version: "1.206.0",
|
|
790
|
+
repository: {
|
|
791
|
+
type: "git",
|
|
792
|
+
url: "https://github.com/UiPath/cli.git",
|
|
793
|
+
directory: "packages/admin/identity-sdk"
|
|
794
|
+
},
|
|
795
|
+
publishConfig: {
|
|
796
|
+
registry: "https://npm.pkg.github.com/@uipath"
|
|
797
|
+
},
|
|
798
|
+
keywords: [
|
|
799
|
+
"uipath",
|
|
800
|
+
"identity",
|
|
801
|
+
"sdk"
|
|
802
|
+
],
|
|
803
|
+
type: "module",
|
|
804
|
+
main: "./dist/index.js",
|
|
805
|
+
types: "./dist/src/index.d.ts",
|
|
806
|
+
exports: {
|
|
807
|
+
".": {
|
|
808
|
+
types: "./dist/src/index.d.ts",
|
|
809
|
+
default: "./dist/index.js"
|
|
810
|
+
}
|
|
811
|
+
},
|
|
812
|
+
files: [
|
|
813
|
+
"dist"
|
|
814
|
+
],
|
|
815
|
+
private: true,
|
|
816
|
+
scripts: {
|
|
817
|
+
build: "bun build ./src/index.ts --outdir dist --format esm --target node --sourcemap=linked && tsc -p tsconfig.build.json --noCheck",
|
|
818
|
+
typecheck: "tsc --noEmit",
|
|
819
|
+
generate: "bun run src/scripts/generate-sdk.ts",
|
|
820
|
+
lint: "biome check .",
|
|
821
|
+
test: "vitest run",
|
|
822
|
+
"test:coverage": "vitest run --coverage"
|
|
823
|
+
},
|
|
824
|
+
devDependencies: {
|
|
825
|
+
"@uipath/auth": "workspace:*",
|
|
826
|
+
"@uipath/common": "workspace:*",
|
|
827
|
+
"@uipath/filesystem": "workspace:*",
|
|
828
|
+
"@openapitools/openapi-generator-cli": "^2.31.1",
|
|
829
|
+
"@types/node": "^25.5.2",
|
|
830
|
+
typescript: "^7.0.2"
|
|
831
|
+
}
|
|
832
|
+
};
|
|
833
|
+
|
|
834
|
+
// ../identity-sdk/src/user-agent.ts
|
|
835
|
+
var SDK_USER_AGENT = getSdkUserAgentToken(package_default);
|
|
836
|
+
installSdkUserAgentHeader(BaseAPI, SDK_USER_AGENT);
|
|
837
|
+
|
|
838
|
+
// ../identity-sdk/src/client-factory.ts
|
|
839
|
+
async function createIdentityConfig(options) {
|
|
840
|
+
const ctx = await getAuthContext({
|
|
841
|
+
ensureTokenValidityMinutes: options?.loginValidity,
|
|
842
|
+
requireOrganizationId: options?.organization === undefined,
|
|
843
|
+
requireTenantName: true
|
|
844
|
+
});
|
|
845
|
+
const organizationId = options?.organization ?? ctx.organizationId;
|
|
846
|
+
if (organizationId === undefined || organizationId.length === 0) {
|
|
847
|
+
throw new Error("Organization ID not available. Provide --organization or log in with an organization context.");
|
|
848
|
+
}
|
|
849
|
+
const identityBasePath = `${ctx.baseUrl}/${organizationId}/identity_`;
|
|
850
|
+
const headers = addSdkUserAgentHeader({
|
|
851
|
+
Authorization: `Bearer ${ctx.accessToken}`
|
|
852
|
+
}, SDK_USER_AGENT);
|
|
853
|
+
return {
|
|
854
|
+
config: new Configuration({
|
|
855
|
+
basePath: identityBasePath,
|
|
856
|
+
headers
|
|
857
|
+
}),
|
|
858
|
+
organizationId
|
|
859
|
+
};
|
|
860
|
+
}
|
|
861
|
+
async function createApiClient(ApiClass, options) {
|
|
862
|
+
const { config, organizationId } = await createIdentityConfig(options);
|
|
863
|
+
return { api: new ApiClass(config), organizationId };
|
|
864
|
+
}
|
|
865
|
+
export { BaseAPI, RequiredError, JSONApiResponse, VoidApiResponse, TextApiResponse, UserTypeFromJSON, UserDtoFromJSON, UserApi, createIdentityConfig, createApiClient };
|
|
866
|
+
|
|
867
|
+
//# debugId=E2BE0258AC6D6A6164756E2164756E21
|