gatana-sdk 2.3.8 → 3.0.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/dist/api/index.cjs +159 -119
- package/dist/api/index.d.cts +2 -2
- package/dist/api/index.d.mts +2 -2
- package/dist/api/index.mjs +2 -2
- package/dist/apiv2/index.cjs +14 -11
- package/dist/apiv2/index.d.cts +2 -2
- package/dist/apiv2/index.d.mts +2 -2
- package/dist/apiv2/index.mjs +2 -2
- package/dist/index.cjs +14 -13
- package/dist/index.d.cts +4 -2
- package/dist/index.d.cts.map +1 -1
- package/dist/index.d.mts +4 -2
- package/dist/index.d.mts.map +1 -1
- package/dist/index.mjs +14 -13
- package/dist/index.mjs.map +1 -1
- package/dist/sdk.gen-C2b2ZNMj.d.mts +9639 -0
- package/dist/sdk.gen-C2b2ZNMj.d.mts.map +1 -0
- package/dist/{sdk.gen-DUNHa0uM.mjs → sdk.gen-CAAxLIvj.mjs} +85 -28
- package/dist/sdk.gen-CAAxLIvj.mjs.map +1 -0
- package/dist/{sdk.gen-BMl_z1y-.cjs → sdk.gen-Cdv7MDsj.cjs} +121 -46
- package/dist/sdk.gen-Crii0E1f.d.mts +2090 -0
- package/dist/sdk.gen-Crii0E1f.d.mts.map +1 -0
- package/dist/sdk.gen-CyOAEozT.cjs +4269 -0
- package/dist/sdk.gen-Do_HFvZj.d.cts +2090 -0
- package/dist/sdk.gen-Do_HFvZj.d.cts.map +1 -0
- package/dist/{sdk.gen-DncK4XW4.cjs → sdk.gen-OcCJ7VK7.mjs} +1183 -995
- package/dist/sdk.gen-OcCJ7VK7.mjs.map +1 -0
- package/dist/sdk.gen-aJw0bLkG.d.cts +9639 -0
- package/dist/sdk.gen-aJw0bLkG.d.cts.map +1 -0
- package/package.json +1 -1
- package/dist/sdk.gen-B9VM8vvh.d.mts +0 -919
- package/dist/sdk.gen-B9VM8vvh.d.mts.map +0 -1
- package/dist/sdk.gen-Bp6WOiGq.d.cts +0 -4229
- package/dist/sdk.gen-Bp6WOiGq.d.cts.map +0 -1
- package/dist/sdk.gen-BzFbgKkw.mjs +0 -2357
- package/dist/sdk.gen-BzFbgKkw.mjs.map +0 -1
- package/dist/sdk.gen-DUNHa0uM.mjs.map +0 -1
- package/dist/sdk.gen-DgXGgJek.d.mts +0 -4229
- package/dist/sdk.gen-DgXGgJek.d.mts.map +0 -1
- package/dist/sdk.gen-DjFHZqZ0.d.cts +0 -919
- package/dist/sdk.gen-DjFHZqZ0.d.cts.map +0 -1
|
@@ -0,0 +1,4269 @@
|
|
|
1
|
+
const require_chunk = require('./chunk-uaV2rQ02.cjs');
|
|
2
|
+
|
|
3
|
+
//#region src/api/core/bodySerializer.gen.ts
|
|
4
|
+
const serializeFormDataPair = (data, key, value) => {
|
|
5
|
+
if (typeof value === "string" || value instanceof Blob) data.append(key, value);
|
|
6
|
+
else if (value instanceof Date) data.append(key, value.toISOString());
|
|
7
|
+
else data.append(key, JSON.stringify(value));
|
|
8
|
+
};
|
|
9
|
+
const formDataBodySerializer = { bodySerializer: (body) => {
|
|
10
|
+
const data = new FormData();
|
|
11
|
+
Object.entries(body).forEach(([key, value]) => {
|
|
12
|
+
if (value === void 0 || value === null) return;
|
|
13
|
+
if (Array.isArray(value)) value.forEach((v) => serializeFormDataPair(data, key, v));
|
|
14
|
+
else serializeFormDataPair(data, key, value);
|
|
15
|
+
});
|
|
16
|
+
return data;
|
|
17
|
+
} };
|
|
18
|
+
const jsonBodySerializer = { bodySerializer: (body) => JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : value) };
|
|
19
|
+
|
|
20
|
+
//#endregion
|
|
21
|
+
//#region src/api/core/params.gen.ts
|
|
22
|
+
const extraPrefixes = Object.entries({
|
|
23
|
+
$body_: "body",
|
|
24
|
+
$headers_: "headers",
|
|
25
|
+
$path_: "path",
|
|
26
|
+
$query_: "query"
|
|
27
|
+
});
|
|
28
|
+
|
|
29
|
+
//#endregion
|
|
30
|
+
//#region src/api/core/serverSentEvents.gen.ts
|
|
31
|
+
function createSseClient({ onRequest, onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }) {
|
|
32
|
+
let lastEventId;
|
|
33
|
+
const sleep = sseSleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
|
|
34
|
+
const createStream = async function* () {
|
|
35
|
+
let retryDelay = sseDefaultRetryDelay ?? 3e3;
|
|
36
|
+
let attempt = 0;
|
|
37
|
+
const signal = options.signal ?? new AbortController().signal;
|
|
38
|
+
while (true) {
|
|
39
|
+
if (signal.aborted) break;
|
|
40
|
+
attempt++;
|
|
41
|
+
const headers = options.headers instanceof Headers ? options.headers : new Headers(options.headers);
|
|
42
|
+
if (lastEventId !== void 0) headers.set("Last-Event-ID", lastEventId);
|
|
43
|
+
try {
|
|
44
|
+
const requestInit = {
|
|
45
|
+
redirect: "follow",
|
|
46
|
+
...options,
|
|
47
|
+
body: options.serializedBody,
|
|
48
|
+
headers,
|
|
49
|
+
signal
|
|
50
|
+
};
|
|
51
|
+
let request = new Request(url, requestInit);
|
|
52
|
+
if (onRequest) request = await onRequest(url, requestInit);
|
|
53
|
+
const response = await (options.fetch ?? globalThis.fetch)(request);
|
|
54
|
+
if (!response.ok) throw new Error(`SSE failed: ${response.status} ${response.statusText}`);
|
|
55
|
+
if (!response.body) throw new Error("No body in SSE response");
|
|
56
|
+
const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
|
|
57
|
+
let buffer = "";
|
|
58
|
+
const abortHandler = () => {
|
|
59
|
+
try {
|
|
60
|
+
reader.cancel();
|
|
61
|
+
} catch {}
|
|
62
|
+
};
|
|
63
|
+
signal.addEventListener("abort", abortHandler);
|
|
64
|
+
try {
|
|
65
|
+
while (true) {
|
|
66
|
+
const { done, value } = await reader.read();
|
|
67
|
+
if (done) break;
|
|
68
|
+
buffer += value;
|
|
69
|
+
buffer = buffer.replace(/\r\n?/g, "\n");
|
|
70
|
+
const chunks = buffer.split("\n\n");
|
|
71
|
+
buffer = chunks.pop() ?? "";
|
|
72
|
+
for (const chunk of chunks) {
|
|
73
|
+
const lines = chunk.split("\n");
|
|
74
|
+
const dataLines = [];
|
|
75
|
+
let eventName;
|
|
76
|
+
for (const line of lines) if (line.startsWith("data:")) dataLines.push(line.replace(/^data:\s*/, ""));
|
|
77
|
+
else if (line.startsWith("event:")) eventName = line.replace(/^event:\s*/, "");
|
|
78
|
+
else if (line.startsWith("id:")) lastEventId = line.replace(/^id:\s*/, "");
|
|
79
|
+
else if (line.startsWith("retry:")) {
|
|
80
|
+
const parsed = Number.parseInt(line.replace(/^retry:\s*/, ""), 10);
|
|
81
|
+
if (!Number.isNaN(parsed)) retryDelay = parsed;
|
|
82
|
+
}
|
|
83
|
+
let data;
|
|
84
|
+
let parsedJson = false;
|
|
85
|
+
if (dataLines.length) {
|
|
86
|
+
const rawData = dataLines.join("\n");
|
|
87
|
+
try {
|
|
88
|
+
data = JSON.parse(rawData);
|
|
89
|
+
parsedJson = true;
|
|
90
|
+
} catch {
|
|
91
|
+
data = rawData;
|
|
92
|
+
}
|
|
93
|
+
}
|
|
94
|
+
if (parsedJson) {
|
|
95
|
+
if (responseValidator) await responseValidator(data);
|
|
96
|
+
if (responseTransformer) data = await responseTransformer(data);
|
|
97
|
+
}
|
|
98
|
+
onSseEvent?.({
|
|
99
|
+
data,
|
|
100
|
+
event: eventName,
|
|
101
|
+
id: lastEventId,
|
|
102
|
+
retry: retryDelay
|
|
103
|
+
});
|
|
104
|
+
if (dataLines.length) yield data;
|
|
105
|
+
}
|
|
106
|
+
}
|
|
107
|
+
} finally {
|
|
108
|
+
signal.removeEventListener("abort", abortHandler);
|
|
109
|
+
reader.releaseLock();
|
|
110
|
+
}
|
|
111
|
+
break;
|
|
112
|
+
} catch (error) {
|
|
113
|
+
onSseError?.(error);
|
|
114
|
+
if (sseMaxRetryAttempts !== void 0 && attempt >= sseMaxRetryAttempts) break;
|
|
115
|
+
await sleep(Math.min(retryDelay * 2 ** (attempt - 1), sseMaxRetryDelay ?? 3e4));
|
|
116
|
+
}
|
|
117
|
+
}
|
|
118
|
+
};
|
|
119
|
+
return { stream: createStream() };
|
|
120
|
+
}
|
|
121
|
+
|
|
122
|
+
//#endregion
|
|
123
|
+
//#region src/api/core/pathSerializer.gen.ts
|
|
124
|
+
const separatorArrayExplode = (style) => {
|
|
125
|
+
switch (style) {
|
|
126
|
+
case "label": return ".";
|
|
127
|
+
case "matrix": return ";";
|
|
128
|
+
case "simple": return ",";
|
|
129
|
+
default: return "&";
|
|
130
|
+
}
|
|
131
|
+
};
|
|
132
|
+
const separatorArrayNoExplode = (style) => {
|
|
133
|
+
switch (style) {
|
|
134
|
+
case "form": return ",";
|
|
135
|
+
case "pipeDelimited": return "|";
|
|
136
|
+
case "spaceDelimited": return "%20";
|
|
137
|
+
default: return ",";
|
|
138
|
+
}
|
|
139
|
+
};
|
|
140
|
+
const separatorObjectExplode = (style) => {
|
|
141
|
+
switch (style) {
|
|
142
|
+
case "label": return ".";
|
|
143
|
+
case "matrix": return ";";
|
|
144
|
+
case "simple": return ",";
|
|
145
|
+
default: return "&";
|
|
146
|
+
}
|
|
147
|
+
};
|
|
148
|
+
const serializeArrayParam = ({ allowReserved, explode, name, style, value }) => {
|
|
149
|
+
if (!explode) {
|
|
150
|
+
const joinedValues = (allowReserved ? value : value.map((v) => encodeURIComponent(v))).join(separatorArrayNoExplode(style));
|
|
151
|
+
switch (style) {
|
|
152
|
+
case "label": return `.${joinedValues}`;
|
|
153
|
+
case "matrix": return `;${name}=${joinedValues}`;
|
|
154
|
+
case "simple": return joinedValues;
|
|
155
|
+
default: return `${name}=${joinedValues}`;
|
|
156
|
+
}
|
|
157
|
+
}
|
|
158
|
+
const separator = separatorArrayExplode(style);
|
|
159
|
+
const joinedValues = value.map((v) => {
|
|
160
|
+
if (style === "label" || style === "simple") return allowReserved ? v : encodeURIComponent(v);
|
|
161
|
+
return serializePrimitiveParam({
|
|
162
|
+
allowReserved,
|
|
163
|
+
name,
|
|
164
|
+
value: v
|
|
165
|
+
});
|
|
166
|
+
}).join(separator);
|
|
167
|
+
return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
|
|
168
|
+
};
|
|
169
|
+
const serializePrimitiveParam = ({ allowReserved, name, value }) => {
|
|
170
|
+
if (value === void 0 || value === null) return "";
|
|
171
|
+
if (typeof value === "object") throw new Error("Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these.");
|
|
172
|
+
return `${name}=${allowReserved ? value : encodeURIComponent(value)}`;
|
|
173
|
+
};
|
|
174
|
+
const serializeObjectParam = ({ allowReserved, explode, name, style, value, valueOnly }) => {
|
|
175
|
+
if (value instanceof Date) return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`;
|
|
176
|
+
if (style !== "deepObject" && !explode) {
|
|
177
|
+
let values = [];
|
|
178
|
+
Object.entries(value).forEach(([key, v]) => {
|
|
179
|
+
values = [
|
|
180
|
+
...values,
|
|
181
|
+
key,
|
|
182
|
+
allowReserved ? v : encodeURIComponent(v)
|
|
183
|
+
];
|
|
184
|
+
});
|
|
185
|
+
const joinedValues = values.join(",");
|
|
186
|
+
switch (style) {
|
|
187
|
+
case "form": return `${name}=${joinedValues}`;
|
|
188
|
+
case "label": return `.${joinedValues}`;
|
|
189
|
+
case "matrix": return `;${name}=${joinedValues}`;
|
|
190
|
+
default: return joinedValues;
|
|
191
|
+
}
|
|
192
|
+
}
|
|
193
|
+
const separator = separatorObjectExplode(style);
|
|
194
|
+
const joinedValues = Object.entries(value).map(([key, v]) => serializePrimitiveParam({
|
|
195
|
+
allowReserved,
|
|
196
|
+
name: style === "deepObject" ? `${name}[${key}]` : key,
|
|
197
|
+
value: v
|
|
198
|
+
})).join(separator);
|
|
199
|
+
return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
|
|
200
|
+
};
|
|
201
|
+
|
|
202
|
+
//#endregion
|
|
203
|
+
//#region src/api/core/utils.gen.ts
|
|
204
|
+
const PATH_PARAM_RE = /\{[^{}]+\}/g;
|
|
205
|
+
const defaultPathSerializer = ({ path, url: _url }) => {
|
|
206
|
+
let url = _url;
|
|
207
|
+
const matches = _url.match(PATH_PARAM_RE);
|
|
208
|
+
if (matches) for (const match of matches) {
|
|
209
|
+
let explode = false;
|
|
210
|
+
let name = match.substring(1, match.length - 1);
|
|
211
|
+
let style = "simple";
|
|
212
|
+
if (name.endsWith("*")) {
|
|
213
|
+
explode = true;
|
|
214
|
+
name = name.substring(0, name.length - 1);
|
|
215
|
+
}
|
|
216
|
+
if (name.startsWith(".")) {
|
|
217
|
+
name = name.substring(1);
|
|
218
|
+
style = "label";
|
|
219
|
+
} else if (name.startsWith(";")) {
|
|
220
|
+
name = name.substring(1);
|
|
221
|
+
style = "matrix";
|
|
222
|
+
}
|
|
223
|
+
const value = path[name];
|
|
224
|
+
if (value === void 0 || value === null) continue;
|
|
225
|
+
if (Array.isArray(value)) {
|
|
226
|
+
url = url.replace(match, serializeArrayParam({
|
|
227
|
+
explode,
|
|
228
|
+
name,
|
|
229
|
+
style,
|
|
230
|
+
value
|
|
231
|
+
}));
|
|
232
|
+
continue;
|
|
233
|
+
}
|
|
234
|
+
if (typeof value === "object") {
|
|
235
|
+
url = url.replace(match, serializeObjectParam({
|
|
236
|
+
explode,
|
|
237
|
+
name,
|
|
238
|
+
style,
|
|
239
|
+
value,
|
|
240
|
+
valueOnly: true
|
|
241
|
+
}));
|
|
242
|
+
continue;
|
|
243
|
+
}
|
|
244
|
+
if (style === "matrix") {
|
|
245
|
+
url = url.replace(match, `;${serializePrimitiveParam({
|
|
246
|
+
name,
|
|
247
|
+
value
|
|
248
|
+
})}`);
|
|
249
|
+
continue;
|
|
250
|
+
}
|
|
251
|
+
const replaceValue = encodeURIComponent(style === "label" ? `.${value}` : value);
|
|
252
|
+
url = url.replace(match, replaceValue);
|
|
253
|
+
}
|
|
254
|
+
return url;
|
|
255
|
+
};
|
|
256
|
+
const getUrl = ({ baseUrl, path, query, querySerializer, url: _url }) => {
|
|
257
|
+
const pathUrl = _url.startsWith("/") ? _url : `/${_url}`;
|
|
258
|
+
let url = (baseUrl ?? "") + pathUrl;
|
|
259
|
+
if (path) url = defaultPathSerializer({
|
|
260
|
+
path,
|
|
261
|
+
url
|
|
262
|
+
});
|
|
263
|
+
let search = query ? querySerializer(query) : "";
|
|
264
|
+
if (search.startsWith("?")) search = search.substring(1);
|
|
265
|
+
if (search) url += `?${search}`;
|
|
266
|
+
return url;
|
|
267
|
+
};
|
|
268
|
+
function getValidRequestBody(options) {
|
|
269
|
+
const hasBody = options.body !== void 0;
|
|
270
|
+
if (hasBody && options.bodySerializer) {
|
|
271
|
+
if ("serializedBody" in options) return options.serializedBody !== void 0 && options.serializedBody !== "" ? options.serializedBody : null;
|
|
272
|
+
return options.body !== "" ? options.body : null;
|
|
273
|
+
}
|
|
274
|
+
if (hasBody) return options.body;
|
|
275
|
+
}
|
|
276
|
+
|
|
277
|
+
//#endregion
|
|
278
|
+
//#region src/api/core/auth.gen.ts
|
|
279
|
+
const getAuthToken = async (auth, callback) => {
|
|
280
|
+
const token = typeof callback === "function" ? await callback(auth) : callback;
|
|
281
|
+
if (!token) return;
|
|
282
|
+
if (auth.scheme === "bearer") return `Bearer ${token}`;
|
|
283
|
+
if (auth.scheme === "basic") return `Basic ${btoa(token)}`;
|
|
284
|
+
return token;
|
|
285
|
+
};
|
|
286
|
+
|
|
287
|
+
//#endregion
|
|
288
|
+
//#region src/api/client/utils.gen.ts
|
|
289
|
+
const createQuerySerializer = ({ parameters = {}, ...args } = {}) => {
|
|
290
|
+
const querySerializer = (queryParams) => {
|
|
291
|
+
const search = [];
|
|
292
|
+
if (queryParams && typeof queryParams === "object") for (const name in queryParams) {
|
|
293
|
+
const value = queryParams[name];
|
|
294
|
+
if (value === void 0 || value === null) continue;
|
|
295
|
+
const options = parameters[name] || args;
|
|
296
|
+
if (Array.isArray(value)) {
|
|
297
|
+
const serializedArray = serializeArrayParam({
|
|
298
|
+
allowReserved: options.allowReserved,
|
|
299
|
+
explode: true,
|
|
300
|
+
name,
|
|
301
|
+
style: "form",
|
|
302
|
+
value,
|
|
303
|
+
...options.array
|
|
304
|
+
});
|
|
305
|
+
if (serializedArray) search.push(serializedArray);
|
|
306
|
+
} else if (typeof value === "object") {
|
|
307
|
+
const serializedObject = serializeObjectParam({
|
|
308
|
+
allowReserved: options.allowReserved,
|
|
309
|
+
explode: true,
|
|
310
|
+
name,
|
|
311
|
+
style: "deepObject",
|
|
312
|
+
value,
|
|
313
|
+
...options.object
|
|
314
|
+
});
|
|
315
|
+
if (serializedObject) search.push(serializedObject);
|
|
316
|
+
} else {
|
|
317
|
+
const serializedPrimitive = serializePrimitiveParam({
|
|
318
|
+
allowReserved: options.allowReserved,
|
|
319
|
+
name,
|
|
320
|
+
value
|
|
321
|
+
});
|
|
322
|
+
if (serializedPrimitive) search.push(serializedPrimitive);
|
|
323
|
+
}
|
|
324
|
+
}
|
|
325
|
+
return search.join("&");
|
|
326
|
+
};
|
|
327
|
+
return querySerializer;
|
|
328
|
+
};
|
|
329
|
+
/**
|
|
330
|
+
* Infers parseAs value from provided Content-Type header.
|
|
331
|
+
*/
|
|
332
|
+
const getParseAs = (contentType) => {
|
|
333
|
+
if (!contentType) return "stream";
|
|
334
|
+
const cleanContent = contentType.split(";")[0]?.trim();
|
|
335
|
+
if (!cleanContent) return;
|
|
336
|
+
if (cleanContent.startsWith("application/json") || cleanContent.endsWith("+json")) return "json";
|
|
337
|
+
if (cleanContent === "multipart/form-data") return "formData";
|
|
338
|
+
if ([
|
|
339
|
+
"application/",
|
|
340
|
+
"audio/",
|
|
341
|
+
"image/",
|
|
342
|
+
"video/"
|
|
343
|
+
].some((type) => cleanContent.startsWith(type))) return "blob";
|
|
344
|
+
if (cleanContent.startsWith("text/")) return "text";
|
|
345
|
+
};
|
|
346
|
+
const checkForExistence = (options, name) => {
|
|
347
|
+
if (!name) return false;
|
|
348
|
+
if (options.headers.has(name) || options.query?.[name] || options.headers.get("Cookie")?.includes(`${name}=`)) return true;
|
|
349
|
+
return false;
|
|
350
|
+
};
|
|
351
|
+
const setAuthParams = async ({ security, ...options }) => {
|
|
352
|
+
for (const auth of security) {
|
|
353
|
+
if (checkForExistence(options, auth.name)) continue;
|
|
354
|
+
const token = await getAuthToken(auth, options.auth);
|
|
355
|
+
if (!token) continue;
|
|
356
|
+
const name = auth.name ?? "Authorization";
|
|
357
|
+
switch (auth.in) {
|
|
358
|
+
case "query":
|
|
359
|
+
if (!options.query) options.query = {};
|
|
360
|
+
options.query[name] = token;
|
|
361
|
+
break;
|
|
362
|
+
case "cookie":
|
|
363
|
+
options.headers.append("Cookie", `${name}=${token}`);
|
|
364
|
+
break;
|
|
365
|
+
default:
|
|
366
|
+
options.headers.set(name, token);
|
|
367
|
+
break;
|
|
368
|
+
}
|
|
369
|
+
}
|
|
370
|
+
};
|
|
371
|
+
const buildUrl = (options) => getUrl({
|
|
372
|
+
baseUrl: options.baseUrl,
|
|
373
|
+
path: options.path,
|
|
374
|
+
query: options.query,
|
|
375
|
+
querySerializer: typeof options.querySerializer === "function" ? options.querySerializer : createQuerySerializer(options.querySerializer),
|
|
376
|
+
url: options.url
|
|
377
|
+
});
|
|
378
|
+
const mergeConfigs = (a, b) => {
|
|
379
|
+
const config = {
|
|
380
|
+
...a,
|
|
381
|
+
...b
|
|
382
|
+
};
|
|
383
|
+
if (config.baseUrl?.endsWith("/")) config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1);
|
|
384
|
+
config.headers = mergeHeaders(a.headers, b.headers);
|
|
385
|
+
return config;
|
|
386
|
+
};
|
|
387
|
+
const headersEntries = (headers) => {
|
|
388
|
+
const entries = [];
|
|
389
|
+
headers.forEach((value, key) => {
|
|
390
|
+
entries.push([key, value]);
|
|
391
|
+
});
|
|
392
|
+
return entries;
|
|
393
|
+
};
|
|
394
|
+
const mergeHeaders = (...headers) => {
|
|
395
|
+
const mergedHeaders = new Headers();
|
|
396
|
+
for (const header of headers) {
|
|
397
|
+
if (!header) continue;
|
|
398
|
+
const iterator = header instanceof Headers ? headersEntries(header) : Object.entries(header);
|
|
399
|
+
for (const [key, value] of iterator) if (value === null) mergedHeaders.delete(key);
|
|
400
|
+
else if (Array.isArray(value)) for (const v of value) mergedHeaders.append(key, v);
|
|
401
|
+
else if (value !== void 0) mergedHeaders.set(key, typeof value === "object" ? JSON.stringify(value) : value);
|
|
402
|
+
}
|
|
403
|
+
return mergedHeaders;
|
|
404
|
+
};
|
|
405
|
+
var Interceptors = class {
|
|
406
|
+
fns = [];
|
|
407
|
+
clear() {
|
|
408
|
+
this.fns = [];
|
|
409
|
+
}
|
|
410
|
+
eject(id) {
|
|
411
|
+
const index = this.getInterceptorIndex(id);
|
|
412
|
+
if (this.fns[index]) this.fns[index] = null;
|
|
413
|
+
}
|
|
414
|
+
exists(id) {
|
|
415
|
+
const index = this.getInterceptorIndex(id);
|
|
416
|
+
return Boolean(this.fns[index]);
|
|
417
|
+
}
|
|
418
|
+
getInterceptorIndex(id) {
|
|
419
|
+
if (typeof id === "number") return this.fns[id] ? id : -1;
|
|
420
|
+
return this.fns.indexOf(id);
|
|
421
|
+
}
|
|
422
|
+
update(id, fn) {
|
|
423
|
+
const index = this.getInterceptorIndex(id);
|
|
424
|
+
if (this.fns[index]) {
|
|
425
|
+
this.fns[index] = fn;
|
|
426
|
+
return id;
|
|
427
|
+
}
|
|
428
|
+
return false;
|
|
429
|
+
}
|
|
430
|
+
use(fn) {
|
|
431
|
+
this.fns.push(fn);
|
|
432
|
+
return this.fns.length - 1;
|
|
433
|
+
}
|
|
434
|
+
};
|
|
435
|
+
const createInterceptors = () => ({
|
|
436
|
+
error: new Interceptors(),
|
|
437
|
+
request: new Interceptors(),
|
|
438
|
+
response: new Interceptors()
|
|
439
|
+
});
|
|
440
|
+
const defaultQuerySerializer = createQuerySerializer({
|
|
441
|
+
allowReserved: false,
|
|
442
|
+
array: {
|
|
443
|
+
explode: true,
|
|
444
|
+
style: "form"
|
|
445
|
+
},
|
|
446
|
+
object: {
|
|
447
|
+
explode: true,
|
|
448
|
+
style: "deepObject"
|
|
449
|
+
}
|
|
450
|
+
});
|
|
451
|
+
const defaultHeaders = { "Content-Type": "application/json" };
|
|
452
|
+
const createConfig = (override = {}) => ({
|
|
453
|
+
...jsonBodySerializer,
|
|
454
|
+
headers: defaultHeaders,
|
|
455
|
+
parseAs: "auto",
|
|
456
|
+
querySerializer: defaultQuerySerializer,
|
|
457
|
+
...override
|
|
458
|
+
});
|
|
459
|
+
|
|
460
|
+
//#endregion
|
|
461
|
+
//#region src/api/client/client.gen.ts
|
|
462
|
+
const createClient = (config = {}) => {
|
|
463
|
+
let _config = mergeConfigs(createConfig(), config);
|
|
464
|
+
const getConfig = () => ({ ..._config });
|
|
465
|
+
const setConfig = (config) => {
|
|
466
|
+
_config = mergeConfigs(_config, config);
|
|
467
|
+
return getConfig();
|
|
468
|
+
};
|
|
469
|
+
const interceptors = createInterceptors();
|
|
470
|
+
const beforeRequest = async (options) => {
|
|
471
|
+
const opts = {
|
|
472
|
+
..._config,
|
|
473
|
+
...options,
|
|
474
|
+
fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
|
|
475
|
+
headers: mergeHeaders(_config.headers, options.headers),
|
|
476
|
+
serializedBody: void 0
|
|
477
|
+
};
|
|
478
|
+
if (opts.security) await setAuthParams({
|
|
479
|
+
...opts,
|
|
480
|
+
security: opts.security
|
|
481
|
+
});
|
|
482
|
+
if (opts.requestValidator) await opts.requestValidator(opts);
|
|
483
|
+
if (opts.body !== void 0 && opts.bodySerializer) opts.serializedBody = opts.bodySerializer(opts.body);
|
|
484
|
+
if (opts.body === void 0 || opts.serializedBody === "") opts.headers.delete("Content-Type");
|
|
485
|
+
const resolvedOpts = opts;
|
|
486
|
+
return {
|
|
487
|
+
opts: resolvedOpts,
|
|
488
|
+
url: buildUrl(resolvedOpts)
|
|
489
|
+
};
|
|
490
|
+
};
|
|
491
|
+
const request = async (options) => {
|
|
492
|
+
const { opts, url } = await beforeRequest(options);
|
|
493
|
+
const requestInit = {
|
|
494
|
+
redirect: "follow",
|
|
495
|
+
...opts,
|
|
496
|
+
body: getValidRequestBody(opts)
|
|
497
|
+
};
|
|
498
|
+
let request = new Request(url, requestInit);
|
|
499
|
+
for (const fn of interceptors.request.fns) if (fn) request = await fn(request, opts);
|
|
500
|
+
const _fetch = opts.fetch;
|
|
501
|
+
let response;
|
|
502
|
+
try {
|
|
503
|
+
response = await _fetch(request);
|
|
504
|
+
} catch (error) {
|
|
505
|
+
let finalError = error;
|
|
506
|
+
for (const fn of interceptors.error.fns) if (fn) finalError = await fn(error, void 0, request, opts);
|
|
507
|
+
finalError = finalError || {};
|
|
508
|
+
if (opts.throwOnError) throw finalError;
|
|
509
|
+
return opts.responseStyle === "data" ? void 0 : {
|
|
510
|
+
error: finalError,
|
|
511
|
+
request,
|
|
512
|
+
response: void 0
|
|
513
|
+
};
|
|
514
|
+
}
|
|
515
|
+
for (const fn of interceptors.response.fns) if (fn) response = await fn(response, request, opts);
|
|
516
|
+
const result = {
|
|
517
|
+
request,
|
|
518
|
+
response
|
|
519
|
+
};
|
|
520
|
+
if (response.ok) {
|
|
521
|
+
const parseAs = (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
|
|
522
|
+
if (response.status === 204 || response.headers.get("Content-Length") === "0") {
|
|
523
|
+
let emptyData;
|
|
524
|
+
switch (parseAs) {
|
|
525
|
+
case "arrayBuffer":
|
|
526
|
+
case "blob":
|
|
527
|
+
case "text":
|
|
528
|
+
emptyData = await response[parseAs]();
|
|
529
|
+
break;
|
|
530
|
+
case "formData":
|
|
531
|
+
emptyData = new FormData();
|
|
532
|
+
break;
|
|
533
|
+
case "stream":
|
|
534
|
+
emptyData = response.body;
|
|
535
|
+
break;
|
|
536
|
+
default:
|
|
537
|
+
emptyData = {};
|
|
538
|
+
break;
|
|
539
|
+
}
|
|
540
|
+
return opts.responseStyle === "data" ? emptyData : {
|
|
541
|
+
data: emptyData,
|
|
542
|
+
...result
|
|
543
|
+
};
|
|
544
|
+
}
|
|
545
|
+
let data;
|
|
546
|
+
switch (parseAs) {
|
|
547
|
+
case "arrayBuffer":
|
|
548
|
+
case "blob":
|
|
549
|
+
case "formData":
|
|
550
|
+
case "text":
|
|
551
|
+
data = await response[parseAs]();
|
|
552
|
+
break;
|
|
553
|
+
case "json": {
|
|
554
|
+
const text = await response.text();
|
|
555
|
+
data = text ? JSON.parse(text) : {};
|
|
556
|
+
break;
|
|
557
|
+
}
|
|
558
|
+
case "stream": return opts.responseStyle === "data" ? response.body : {
|
|
559
|
+
data: response.body,
|
|
560
|
+
...result
|
|
561
|
+
};
|
|
562
|
+
}
|
|
563
|
+
if (parseAs === "json") {
|
|
564
|
+
if (opts.responseValidator) await opts.responseValidator(data);
|
|
565
|
+
if (opts.responseTransformer) data = await opts.responseTransformer(data);
|
|
566
|
+
}
|
|
567
|
+
return opts.responseStyle === "data" ? data : {
|
|
568
|
+
data,
|
|
569
|
+
...result
|
|
570
|
+
};
|
|
571
|
+
}
|
|
572
|
+
const textError = await response.text();
|
|
573
|
+
let jsonError;
|
|
574
|
+
try {
|
|
575
|
+
jsonError = JSON.parse(textError);
|
|
576
|
+
} catch {}
|
|
577
|
+
const error = jsonError ?? textError;
|
|
578
|
+
let finalError = error;
|
|
579
|
+
for (const fn of interceptors.error.fns) if (fn) finalError = await fn(error, response, request, opts);
|
|
580
|
+
finalError = finalError || {};
|
|
581
|
+
if (opts.throwOnError) throw finalError;
|
|
582
|
+
return opts.responseStyle === "data" ? void 0 : {
|
|
583
|
+
error: finalError,
|
|
584
|
+
...result
|
|
585
|
+
};
|
|
586
|
+
};
|
|
587
|
+
const makeMethodFn = (method) => (options) => request({
|
|
588
|
+
...options,
|
|
589
|
+
method
|
|
590
|
+
});
|
|
591
|
+
const makeSseFn = (method) => async (options) => {
|
|
592
|
+
const { opts, url } = await beforeRequest(options);
|
|
593
|
+
return createSseClient({
|
|
594
|
+
...opts,
|
|
595
|
+
body: opts.body,
|
|
596
|
+
headers: opts.headers,
|
|
597
|
+
method,
|
|
598
|
+
onRequest: async (url, init) => {
|
|
599
|
+
let request = new Request(url, init);
|
|
600
|
+
for (const fn of interceptors.request.fns) if (fn) request = await fn(request, opts);
|
|
601
|
+
return request;
|
|
602
|
+
},
|
|
603
|
+
serializedBody: getValidRequestBody(opts),
|
|
604
|
+
url
|
|
605
|
+
});
|
|
606
|
+
};
|
|
607
|
+
const _buildUrl = (options) => buildUrl({
|
|
608
|
+
..._config,
|
|
609
|
+
...options
|
|
610
|
+
});
|
|
611
|
+
return {
|
|
612
|
+
buildUrl: _buildUrl,
|
|
613
|
+
connect: makeMethodFn("CONNECT"),
|
|
614
|
+
delete: makeMethodFn("DELETE"),
|
|
615
|
+
get: makeMethodFn("GET"),
|
|
616
|
+
getConfig,
|
|
617
|
+
head: makeMethodFn("HEAD"),
|
|
618
|
+
interceptors,
|
|
619
|
+
options: makeMethodFn("OPTIONS"),
|
|
620
|
+
patch: makeMethodFn("PATCH"),
|
|
621
|
+
post: makeMethodFn("POST"),
|
|
622
|
+
put: makeMethodFn("PUT"),
|
|
623
|
+
request,
|
|
624
|
+
setConfig,
|
|
625
|
+
sse: {
|
|
626
|
+
connect: makeSseFn("CONNECT"),
|
|
627
|
+
delete: makeSseFn("DELETE"),
|
|
628
|
+
get: makeSseFn("GET"),
|
|
629
|
+
head: makeSseFn("HEAD"),
|
|
630
|
+
options: makeSseFn("OPTIONS"),
|
|
631
|
+
patch: makeSseFn("PATCH"),
|
|
632
|
+
post: makeSseFn("POST"),
|
|
633
|
+
put: makeSseFn("PUT"),
|
|
634
|
+
trace: makeSseFn("TRACE")
|
|
635
|
+
},
|
|
636
|
+
trace: makeMethodFn("TRACE")
|
|
637
|
+
};
|
|
638
|
+
};
|
|
639
|
+
|
|
640
|
+
//#endregion
|
|
641
|
+
//#region src/api/client.gen.ts
|
|
642
|
+
const client = createClient(createConfig({ throwOnError: true }));
|
|
643
|
+
|
|
644
|
+
//#endregion
|
|
645
|
+
//#region src/api/sdk.gen.ts
|
|
646
|
+
var sdk_gen_exports = /* @__PURE__ */ require_chunk.__exportAll({
|
|
647
|
+
callMcpServerTool: () => callMcpServerTool,
|
|
648
|
+
copyMcpServerCredentials: () => copyMcpServerCredentials,
|
|
649
|
+
createArtifact: () => createArtifact,
|
|
650
|
+
createMcpServer: () => createMcpServer,
|
|
651
|
+
createMcpServerFile: () => createMcpServerFile,
|
|
652
|
+
createProfile: () => createProfile,
|
|
653
|
+
createProfileClaimMapping: () => createProfileClaimMapping,
|
|
654
|
+
createProfileMaintainer: () => createProfileMaintainer,
|
|
655
|
+
createSandbox: () => createSandbox,
|
|
656
|
+
createSandboxReadFile: () => createSandboxReadFile,
|
|
657
|
+
createSandboxSshSession: () => createSandboxSshSession,
|
|
658
|
+
createSandboxWriteFile: () => createSandboxWriteFile,
|
|
659
|
+
createScimConfigToken: () => createScimConfigToken,
|
|
660
|
+
createSecretStore: () => createSecretStore,
|
|
661
|
+
createSecretStoreMapping: () => createSecretStoreMapping,
|
|
662
|
+
createSiemDestination: () => createSiemDestination,
|
|
663
|
+
createSkill: () => createSkill,
|
|
664
|
+
createTeam: () => createTeam,
|
|
665
|
+
createTeamClaimMapping: () => createTeamClaimMapping,
|
|
666
|
+
createTeamInvitation: () => createTeamInvitation,
|
|
667
|
+
createTeamMember: () => createTeamMember,
|
|
668
|
+
createTeamProfile: () => createTeamProfile,
|
|
669
|
+
createUser: () => createUser,
|
|
670
|
+
createUserPersonalAccessToken: () => createUserPersonalAccessToken,
|
|
671
|
+
createUserProfile: () => createUserProfile,
|
|
672
|
+
deleteArtifact: () => deleteArtifact,
|
|
673
|
+
deleteConnectedClient: () => deleteConnectedClient,
|
|
674
|
+
deleteMcpServer: () => deleteMcpServer,
|
|
675
|
+
deleteMcpServerCredential: () => deleteMcpServerCredential,
|
|
676
|
+
deleteMcpServerCredentialsProfile: () => deleteMcpServerCredentialsProfile,
|
|
677
|
+
deleteMcpServerCredentialsServer: () => deleteMcpServerCredentialsServer,
|
|
678
|
+
deleteMcpServerCredentialsUser: () => deleteMcpServerCredentialsUser,
|
|
679
|
+
deleteMcpServerFile: () => deleteMcpServerFile,
|
|
680
|
+
deleteMcpServerMember: () => deleteMcpServerMember,
|
|
681
|
+
deleteProfile: () => deleteProfile,
|
|
682
|
+
deleteProfileClaimMapping: () => deleteProfileClaimMapping,
|
|
683
|
+
deleteProfileMaintainer: () => deleteProfileMaintainer,
|
|
684
|
+
deleteSandbox: () => deleteSandbox,
|
|
685
|
+
deleteScimConfigToken: () => deleteScimConfigToken,
|
|
686
|
+
deleteSecretStore: () => deleteSecretStore,
|
|
687
|
+
deleteSecretStoreMapping: () => deleteSecretStoreMapping,
|
|
688
|
+
deleteSiemDestination: () => deleteSiemDestination,
|
|
689
|
+
deleteSkill: () => deleteSkill,
|
|
690
|
+
deleteTeam: () => deleteTeam,
|
|
691
|
+
deleteTeamClaimMapping: () => deleteTeamClaimMapping,
|
|
692
|
+
deleteTeamInvitation: () => deleteTeamInvitation,
|
|
693
|
+
deleteTeamMember: () => deleteTeamMember,
|
|
694
|
+
deleteTeamProfile: () => deleteTeamProfile,
|
|
695
|
+
deleteUser: () => deleteUser,
|
|
696
|
+
deleteUserPersonalAccessToken: () => deleteUserPersonalAccessToken,
|
|
697
|
+
deleteUserProfile: () => deleteUserProfile,
|
|
698
|
+
discoverMcpServerOauth: () => discoverMcpServerOauth,
|
|
699
|
+
execSandbox: () => execSandbox,
|
|
700
|
+
getArtifact: () => getArtifact,
|
|
701
|
+
getArtifactContent: () => getArtifactContent,
|
|
702
|
+
getAuditLog: () => getAuditLog,
|
|
703
|
+
getAuditLogsSummary: () => getAuditLogsSummary,
|
|
704
|
+
getAuthMe: () => getAuthMe,
|
|
705
|
+
getDeploymentsStatus: () => getDeploymentsStatus,
|
|
706
|
+
getMcpServer: () => getMcpServer,
|
|
707
|
+
getMcpServerCredentialsAuthorizeUrl: () => getMcpServerCredentialsAuthorizeUrl,
|
|
708
|
+
getMcpServerCredentialsProfile: () => getMcpServerCredentialsProfile,
|
|
709
|
+
getMcpServerCredentialsServer: () => getMcpServerCredentialsServer,
|
|
710
|
+
getMcpServerCredentialsToken: () => getMcpServerCredentialsToken,
|
|
711
|
+
getMcpServerCredentialsUser: () => getMcpServerCredentialsUser,
|
|
712
|
+
getMcpServerFile: () => getMcpServerFile,
|
|
713
|
+
getMcpServerRunningStatus: () => getMcpServerRunningStatus,
|
|
714
|
+
getMcpServerSourceCode: () => getMcpServerSourceCode,
|
|
715
|
+
getMcpServerTool: () => getMcpServerTool,
|
|
716
|
+
getMcpServersAccessPreview: () => getMcpServersAccessPreview,
|
|
717
|
+
getProfile: () => getProfile,
|
|
718
|
+
getSandbox: () => getSandbox,
|
|
719
|
+
getSandboxAuditLog: () => getSandboxAuditLog,
|
|
720
|
+
getScimConfigTokenSecret: () => getScimConfigTokenSecret,
|
|
721
|
+
getSecretStore: () => getSecretStore,
|
|
722
|
+
getSiemDestination: () => getSiemDestination,
|
|
723
|
+
getSiemDestinationSecret: () => getSiemDestinationSecret,
|
|
724
|
+
getSkill: () => getSkill,
|
|
725
|
+
getTeam: () => getTeam,
|
|
726
|
+
getTenant: () => getTenant,
|
|
727
|
+
getTenantSubscription: () => getTenantSubscription,
|
|
728
|
+
getToolsSearch: () => getToolsSearch,
|
|
729
|
+
getUser: () => getUser,
|
|
730
|
+
getUsersMe: () => getUsersMe,
|
|
731
|
+
installPredefinedBuiltInServer: () => installPredefinedBuiltInServer,
|
|
732
|
+
listArtifactShares: () => listArtifactShares,
|
|
733
|
+
listArtifacts: () => listArtifacts,
|
|
734
|
+
listAuditLogs: () => listAuditLogs,
|
|
735
|
+
listAuditLogsFilterOptions: () => listAuditLogsFilterOptions,
|
|
736
|
+
listConnectedClients: () => listConnectedClients,
|
|
737
|
+
listDeploymentsDeploymentLogs: () => listDeploymentsDeploymentLogs,
|
|
738
|
+
listDeploymentsLogs: () => listDeploymentsLogs,
|
|
739
|
+
listDeploymentsMetrics: () => listDeploymentsMetrics,
|
|
740
|
+
listMcpServerCredentialsProfileApikeys: () => listMcpServerCredentialsProfileApikeys,
|
|
741
|
+
listMcpServerCredentialsServerApikeys: () => listMcpServerCredentialsServerApikeys,
|
|
742
|
+
listMcpServerCredentialsUserApikeys: () => listMcpServerCredentialsUserApikeys,
|
|
743
|
+
listMcpServerFiles: () => listMcpServerFiles,
|
|
744
|
+
listMcpServerMembers: () => listMcpServerMembers,
|
|
745
|
+
listMcpServerTools: () => listMcpServerTools,
|
|
746
|
+
listMcpServers: () => listMcpServers,
|
|
747
|
+
listProfileClaimMappings: () => listProfileClaimMappings,
|
|
748
|
+
listProfileDirectAssignments: () => listProfileDirectAssignments,
|
|
749
|
+
listProfileMaintainers: () => listProfileMaintainers,
|
|
750
|
+
listProfileTools: () => listProfileTools,
|
|
751
|
+
listProfiles: () => listProfiles,
|
|
752
|
+
listSandboxAuditLogs: () => listSandboxAuditLogs,
|
|
753
|
+
listSandboxes: () => listSandboxes,
|
|
754
|
+
listScimConfigTokens: () => listScimConfigTokens,
|
|
755
|
+
listSecretStoreMappings: () => listSecretStoreMappings,
|
|
756
|
+
listSecretStores: () => listSecretStores,
|
|
757
|
+
listSkillShares: () => listSkillShares,
|
|
758
|
+
listSkills: () => listSkills,
|
|
759
|
+
listTeamClaimMappings: () => listTeamClaimMappings,
|
|
760
|
+
listTeamInvitations: () => listTeamInvitations,
|
|
761
|
+
listTeamMembers: () => listTeamMembers,
|
|
762
|
+
listTeamProfiles: () => listTeamProfiles,
|
|
763
|
+
listTeamServers: () => listTeamServers,
|
|
764
|
+
listTeams: () => listTeams,
|
|
765
|
+
listTools: () => listTools,
|
|
766
|
+
listUserPersonalAccessTokens: () => listUserPersonalAccessTokens,
|
|
767
|
+
listUserProfiles: () => listUserProfiles,
|
|
768
|
+
listUsers: () => listUsers,
|
|
769
|
+
patchArtifact: () => patchArtifact,
|
|
770
|
+
patchConnectedClient: () => patchConnectedClient,
|
|
771
|
+
patchMcpServerTool: () => patchMcpServerTool,
|
|
772
|
+
patchSecretStore: () => patchSecretStore,
|
|
773
|
+
patchSecretStoreMapping: () => patchSecretStoreMapping,
|
|
774
|
+
patchSiemDestination: () => patchSiemDestination,
|
|
775
|
+
patchUserPersonalAccessToken: () => patchUserPersonalAccessToken,
|
|
776
|
+
patchUserProfile: () => patchUserProfile,
|
|
777
|
+
refreshTools: () => refreshTools,
|
|
778
|
+
requestOwnEmailVerification: () => requestOwnEmailVerification,
|
|
779
|
+
rotateSiemDestinationSecret: () => rotateSiemDestinationSecret,
|
|
780
|
+
sendEmailVerificationCode: () => sendEmailVerificationCode,
|
|
781
|
+
shareArtifact: () => shareArtifact,
|
|
782
|
+
shareSkill: () => shareSkill,
|
|
783
|
+
startMcpServer: () => startMcpServer,
|
|
784
|
+
stopMcpServer: () => stopMcpServer,
|
|
785
|
+
testMcpServerOpenapi: () => testMcpServerOpenapi,
|
|
786
|
+
testSecretStore: () => testSecretStore,
|
|
787
|
+
testSiemDestination: () => testSiemDestination,
|
|
788
|
+
unshareArtifact: () => unshareArtifact,
|
|
789
|
+
unshareSkill: () => unshareSkill,
|
|
790
|
+
updateArtifact: () => updateArtifact,
|
|
791
|
+
updateMcpServer: () => updateMcpServer,
|
|
792
|
+
updateMcpServerAllToolsIsEnabled: () => updateMcpServerAllToolsIsEnabled,
|
|
793
|
+
updateMcpServerCredentialsProfile: () => updateMcpServerCredentialsProfile,
|
|
794
|
+
updateMcpServerCredentialsServer: () => updateMcpServerCredentialsServer,
|
|
795
|
+
updateMcpServerCredentialsUser: () => updateMcpServerCredentialsUser,
|
|
796
|
+
updateMcpServerFile: () => updateMcpServerFile,
|
|
797
|
+
updateMcpServerFileName: () => updateMcpServerFileName,
|
|
798
|
+
updateMcpServerIsEnabled: () => updateMcpServerIsEnabled,
|
|
799
|
+
updateMcpServerMember: () => updateMcpServerMember,
|
|
800
|
+
updateMcpServerSourceCode: () => updateMcpServerSourceCode,
|
|
801
|
+
updateMcpServerToolIsEnabled: () => updateMcpServerToolIsEnabled,
|
|
802
|
+
updateProfile: () => updateProfile,
|
|
803
|
+
updateProfileServerTools: () => updateProfileServerTools,
|
|
804
|
+
updateSkill: () => updateSkill,
|
|
805
|
+
updateTeam: () => updateTeam,
|
|
806
|
+
updateTeamMember: () => updateTeamMember,
|
|
807
|
+
updateUser: () => updateUser,
|
|
808
|
+
updateUsersMe: () => updateUsersMe
|
|
809
|
+
});
|
|
810
|
+
/**
|
|
811
|
+
* Get metadata about the authenticated user
|
|
812
|
+
*/
|
|
813
|
+
const getAuthMe = (options) => (options?.client ?? client).get({
|
|
814
|
+
security: [{
|
|
815
|
+
scheme: "bearer",
|
|
816
|
+
type: "http"
|
|
817
|
+
}, {
|
|
818
|
+
scheme: "bearer",
|
|
819
|
+
type: "http"
|
|
820
|
+
}],
|
|
821
|
+
url: "/auth/me",
|
|
822
|
+
...options
|
|
823
|
+
});
|
|
824
|
+
/**
|
|
825
|
+
* List the values a caller may filter the audit log by, for each field that has a known set
|
|
826
|
+
*/
|
|
827
|
+
const listAuditLogsFilterOptions = (options) => (options?.client ?? client).get({
|
|
828
|
+
security: [{
|
|
829
|
+
scheme: "bearer",
|
|
830
|
+
type: "http"
|
|
831
|
+
}, {
|
|
832
|
+
scheme: "bearer",
|
|
833
|
+
type: "http"
|
|
834
|
+
}],
|
|
835
|
+
url: "/audit-logs/filter-options",
|
|
836
|
+
...options
|
|
837
|
+
});
|
|
838
|
+
/**
|
|
839
|
+
* Summarize the tool calls the caller made over a recent window, as a count per day plus the servers and clients they went through
|
|
840
|
+
*/
|
|
841
|
+
const getAuditLogsSummary = (options) => (options?.client ?? client).get({
|
|
842
|
+
security: [{
|
|
843
|
+
scheme: "bearer",
|
|
844
|
+
type: "http"
|
|
845
|
+
}, {
|
|
846
|
+
scheme: "bearer",
|
|
847
|
+
type: "http"
|
|
848
|
+
}],
|
|
849
|
+
url: "/audit-logs/summary",
|
|
850
|
+
...options
|
|
851
|
+
});
|
|
852
|
+
/**
|
|
853
|
+
* Get a single audit log entry. Callers without full access can only read their own entries
|
|
854
|
+
*/
|
|
855
|
+
const getAuditLog = (options) => (options.client ?? client).get({
|
|
856
|
+
security: [{
|
|
857
|
+
scheme: "bearer",
|
|
858
|
+
type: "http"
|
|
859
|
+
}, {
|
|
860
|
+
scheme: "bearer",
|
|
861
|
+
type: "http"
|
|
862
|
+
}],
|
|
863
|
+
url: "/audit-logs/{id}",
|
|
864
|
+
...options
|
|
865
|
+
});
|
|
866
|
+
/**
|
|
867
|
+
* List audit log entries page by page. Callers without full access only see their own entries
|
|
868
|
+
*/
|
|
869
|
+
const listAuditLogs = (options) => (options?.client ?? client).get({
|
|
870
|
+
security: [{
|
|
871
|
+
scheme: "bearer",
|
|
872
|
+
type: "http"
|
|
873
|
+
}, {
|
|
874
|
+
scheme: "bearer",
|
|
875
|
+
type: "http"
|
|
876
|
+
}],
|
|
877
|
+
url: "/audit-logs",
|
|
878
|
+
...options
|
|
879
|
+
});
|
|
880
|
+
/**
|
|
881
|
+
* Get the current authenticated user
|
|
882
|
+
*/
|
|
883
|
+
const getUsersMe = (options) => (options?.client ?? client).get({
|
|
884
|
+
security: [{
|
|
885
|
+
scheme: "bearer",
|
|
886
|
+
type: "http"
|
|
887
|
+
}, {
|
|
888
|
+
scheme: "bearer",
|
|
889
|
+
type: "http"
|
|
890
|
+
}],
|
|
891
|
+
url: "/users/me",
|
|
892
|
+
...options
|
|
893
|
+
});
|
|
894
|
+
/**
|
|
895
|
+
* Update the current authenticated user
|
|
896
|
+
*/
|
|
897
|
+
const updateUsersMe = (options) => (options?.client ?? client).put({
|
|
898
|
+
security: [{
|
|
899
|
+
scheme: "bearer",
|
|
900
|
+
type: "http"
|
|
901
|
+
}, {
|
|
902
|
+
scheme: "bearer",
|
|
903
|
+
type: "http"
|
|
904
|
+
}],
|
|
905
|
+
url: "/users/me",
|
|
906
|
+
...options,
|
|
907
|
+
headers: {
|
|
908
|
+
"Content-Type": "application/json",
|
|
909
|
+
...options?.headers
|
|
910
|
+
}
|
|
911
|
+
});
|
|
912
|
+
/**
|
|
913
|
+
* Send a verification code to a new email address before changing it
|
|
914
|
+
*/
|
|
915
|
+
const requestOwnEmailVerification = (options) => (options?.client ?? client).post({
|
|
916
|
+
security: [{
|
|
917
|
+
scheme: "bearer",
|
|
918
|
+
type: "http"
|
|
919
|
+
}, {
|
|
920
|
+
scheme: "bearer",
|
|
921
|
+
type: "http"
|
|
922
|
+
}],
|
|
923
|
+
url: "/users/me/request-email-verification",
|
|
924
|
+
...options,
|
|
925
|
+
headers: {
|
|
926
|
+
"Content-Type": "application/json",
|
|
927
|
+
...options?.headers
|
|
928
|
+
}
|
|
929
|
+
});
|
|
930
|
+
/**
|
|
931
|
+
* List the users and service accounts the caller can read, optionally filtered by type
|
|
932
|
+
*/
|
|
933
|
+
const listUsers = (options) => (options?.client ?? client).get({
|
|
934
|
+
security: [{
|
|
935
|
+
scheme: "bearer",
|
|
936
|
+
type: "http"
|
|
937
|
+
}, {
|
|
938
|
+
scheme: "bearer",
|
|
939
|
+
type: "http"
|
|
940
|
+
}],
|
|
941
|
+
url: "/users",
|
|
942
|
+
...options
|
|
943
|
+
});
|
|
944
|
+
/**
|
|
945
|
+
* Invite a new user by email, or create a service account
|
|
946
|
+
*/
|
|
947
|
+
const createUser = (options) => (options?.client ?? client).post({
|
|
948
|
+
security: [{
|
|
949
|
+
scheme: "bearer",
|
|
950
|
+
type: "http"
|
|
951
|
+
}, {
|
|
952
|
+
scheme: "bearer",
|
|
953
|
+
type: "http"
|
|
954
|
+
}],
|
|
955
|
+
url: "/users",
|
|
956
|
+
...options,
|
|
957
|
+
headers: {
|
|
958
|
+
"Content-Type": "application/json",
|
|
959
|
+
...options?.headers
|
|
960
|
+
}
|
|
961
|
+
});
|
|
962
|
+
/**
|
|
963
|
+
* Delete a user permanently
|
|
964
|
+
*/
|
|
965
|
+
const deleteUser = (options) => (options.client ?? client).delete({
|
|
966
|
+
security: [{
|
|
967
|
+
scheme: "bearer",
|
|
968
|
+
type: "http"
|
|
969
|
+
}, {
|
|
970
|
+
scheme: "bearer",
|
|
971
|
+
type: "http"
|
|
972
|
+
}],
|
|
973
|
+
url: "/users/{userId}",
|
|
974
|
+
...options
|
|
975
|
+
});
|
|
976
|
+
/**
|
|
977
|
+
* Get one user by ID
|
|
978
|
+
*/
|
|
979
|
+
const getUser = (options) => (options.client ?? client).get({
|
|
980
|
+
security: [{
|
|
981
|
+
scheme: "bearer",
|
|
982
|
+
type: "http"
|
|
983
|
+
}, {
|
|
984
|
+
scheme: "bearer",
|
|
985
|
+
type: "http"
|
|
986
|
+
}],
|
|
987
|
+
url: "/users/{userId}",
|
|
988
|
+
...options
|
|
989
|
+
});
|
|
990
|
+
/**
|
|
991
|
+
* Update a user; callers who are not the organization owner can change only the name
|
|
992
|
+
*/
|
|
993
|
+
const updateUser = (options) => (options.client ?? client).put({
|
|
994
|
+
security: [{
|
|
995
|
+
scheme: "bearer",
|
|
996
|
+
type: "http"
|
|
997
|
+
}, {
|
|
998
|
+
scheme: "bearer",
|
|
999
|
+
type: "http"
|
|
1000
|
+
}],
|
|
1001
|
+
url: "/users/{userId}",
|
|
1002
|
+
...options,
|
|
1003
|
+
headers: {
|
|
1004
|
+
"Content-Type": "application/json",
|
|
1005
|
+
...options.headers
|
|
1006
|
+
}
|
|
1007
|
+
});
|
|
1008
|
+
/**
|
|
1009
|
+
* List the profiles assigned to a user
|
|
1010
|
+
*/
|
|
1011
|
+
const listUserProfiles = (options) => (options.client ?? client).get({
|
|
1012
|
+
security: [{
|
|
1013
|
+
scheme: "bearer",
|
|
1014
|
+
type: "http"
|
|
1015
|
+
}, {
|
|
1016
|
+
scheme: "bearer",
|
|
1017
|
+
type: "http"
|
|
1018
|
+
}],
|
|
1019
|
+
url: "/users/{userId}/profiles",
|
|
1020
|
+
...options
|
|
1021
|
+
});
|
|
1022
|
+
/**
|
|
1023
|
+
* Assign a profile to a user; only organization owners can lock the assignment
|
|
1024
|
+
*/
|
|
1025
|
+
const createUserProfile = (options) => (options.client ?? client).post({
|
|
1026
|
+
security: [{
|
|
1027
|
+
scheme: "bearer",
|
|
1028
|
+
type: "http"
|
|
1029
|
+
}, {
|
|
1030
|
+
scheme: "bearer",
|
|
1031
|
+
type: "http"
|
|
1032
|
+
}],
|
|
1033
|
+
url: "/users/{userId}/profiles",
|
|
1034
|
+
...options,
|
|
1035
|
+
headers: {
|
|
1036
|
+
"Content-Type": "application/json",
|
|
1037
|
+
...options.headers
|
|
1038
|
+
}
|
|
1039
|
+
});
|
|
1040
|
+
/**
|
|
1041
|
+
* Remove a profile assignment; only organization owners can remove locked assignments
|
|
1042
|
+
*/
|
|
1043
|
+
const deleteUserProfile = (options) => (options.client ?? client).delete({
|
|
1044
|
+
security: [{
|
|
1045
|
+
scheme: "bearer",
|
|
1046
|
+
type: "http"
|
|
1047
|
+
}, {
|
|
1048
|
+
scheme: "bearer",
|
|
1049
|
+
type: "http"
|
|
1050
|
+
}],
|
|
1051
|
+
url: "/users/{userId}/profiles/{profileId}",
|
|
1052
|
+
...options
|
|
1053
|
+
});
|
|
1054
|
+
/**
|
|
1055
|
+
* Change the lock status of a profile assignment; organization owners only
|
|
1056
|
+
*/
|
|
1057
|
+
const patchUserProfile = (options) => (options.client ?? client).patch({
|
|
1058
|
+
security: [{
|
|
1059
|
+
scheme: "bearer",
|
|
1060
|
+
type: "http"
|
|
1061
|
+
}, {
|
|
1062
|
+
scheme: "bearer",
|
|
1063
|
+
type: "http"
|
|
1064
|
+
}],
|
|
1065
|
+
url: "/users/{userId}/profiles/{profileId}",
|
|
1066
|
+
...options,
|
|
1067
|
+
headers: {
|
|
1068
|
+
"Content-Type": "application/json",
|
|
1069
|
+
...options.headers
|
|
1070
|
+
}
|
|
1071
|
+
});
|
|
1072
|
+
/**
|
|
1073
|
+
* List the personal access tokens of the user; allowed for yourself or a managed service account
|
|
1074
|
+
*/
|
|
1075
|
+
const listUserPersonalAccessTokens = (options) => (options.client ?? client).get({
|
|
1076
|
+
security: [{
|
|
1077
|
+
scheme: "bearer",
|
|
1078
|
+
type: "http"
|
|
1079
|
+
}, {
|
|
1080
|
+
scheme: "bearer",
|
|
1081
|
+
type: "http"
|
|
1082
|
+
}],
|
|
1083
|
+
url: "/users/{userId}/personal-access-tokens",
|
|
1084
|
+
...options
|
|
1085
|
+
});
|
|
1086
|
+
/**
|
|
1087
|
+
* Create a personal access token for the user and return its API key
|
|
1088
|
+
*/
|
|
1089
|
+
const createUserPersonalAccessToken = (options) => (options.client ?? client).post({
|
|
1090
|
+
security: [{
|
|
1091
|
+
scheme: "bearer",
|
|
1092
|
+
type: "http"
|
|
1093
|
+
}, {
|
|
1094
|
+
scheme: "bearer",
|
|
1095
|
+
type: "http"
|
|
1096
|
+
}],
|
|
1097
|
+
url: "/users/{userId}/personal-access-tokens",
|
|
1098
|
+
...options,
|
|
1099
|
+
headers: {
|
|
1100
|
+
"Content-Type": "application/json",
|
|
1101
|
+
...options.headers
|
|
1102
|
+
}
|
|
1103
|
+
});
|
|
1104
|
+
/**
|
|
1105
|
+
* Delete a personal access token
|
|
1106
|
+
*/
|
|
1107
|
+
const deleteUserPersonalAccessToken = (options) => (options.client ?? client).delete({
|
|
1108
|
+
security: [{
|
|
1109
|
+
scheme: "bearer",
|
|
1110
|
+
type: "http"
|
|
1111
|
+
}, {
|
|
1112
|
+
scheme: "bearer",
|
|
1113
|
+
type: "http"
|
|
1114
|
+
}],
|
|
1115
|
+
url: "/users/{userId}/personal-access-tokens/{patId}",
|
|
1116
|
+
...options
|
|
1117
|
+
});
|
|
1118
|
+
/**
|
|
1119
|
+
* Update the name or the assigned profiles of a personal access token
|
|
1120
|
+
*/
|
|
1121
|
+
const patchUserPersonalAccessToken = (options) => (options.client ?? client).patch({
|
|
1122
|
+
security: [{
|
|
1123
|
+
scheme: "bearer",
|
|
1124
|
+
type: "http"
|
|
1125
|
+
}, {
|
|
1126
|
+
scheme: "bearer",
|
|
1127
|
+
type: "http"
|
|
1128
|
+
}],
|
|
1129
|
+
url: "/users/{userId}/personal-access-tokens/{patId}",
|
|
1130
|
+
...options,
|
|
1131
|
+
headers: {
|
|
1132
|
+
"Content-Type": "application/json",
|
|
1133
|
+
...options.headers
|
|
1134
|
+
}
|
|
1135
|
+
});
|
|
1136
|
+
/**
|
|
1137
|
+
* Preview which servers a specific user or team can access
|
|
1138
|
+
*/
|
|
1139
|
+
const getMcpServersAccessPreview = (options) => (options?.client ?? client).get({
|
|
1140
|
+
security: [{
|
|
1141
|
+
scheme: "bearer",
|
|
1142
|
+
type: "http"
|
|
1143
|
+
}, {
|
|
1144
|
+
scheme: "bearer",
|
|
1145
|
+
type: "http"
|
|
1146
|
+
}],
|
|
1147
|
+
url: "/mcp-servers/access-preview",
|
|
1148
|
+
...options
|
|
1149
|
+
});
|
|
1150
|
+
/**
|
|
1151
|
+
* List all MCP servers the caller has access to
|
|
1152
|
+
*/
|
|
1153
|
+
const listMcpServers = (options) => (options?.client ?? client).get({
|
|
1154
|
+
security: [{
|
|
1155
|
+
scheme: "bearer",
|
|
1156
|
+
type: "http"
|
|
1157
|
+
}, {
|
|
1158
|
+
scheme: "bearer",
|
|
1159
|
+
type: "http"
|
|
1160
|
+
}],
|
|
1161
|
+
url: "/mcp-servers",
|
|
1162
|
+
...options
|
|
1163
|
+
});
|
|
1164
|
+
/**
|
|
1165
|
+
* Create a new MCP server
|
|
1166
|
+
*/
|
|
1167
|
+
const createMcpServer = (options) => (options?.client ?? client).post({
|
|
1168
|
+
security: [{
|
|
1169
|
+
scheme: "bearer",
|
|
1170
|
+
type: "http"
|
|
1171
|
+
}, {
|
|
1172
|
+
scheme: "bearer",
|
|
1173
|
+
type: "http"
|
|
1174
|
+
}],
|
|
1175
|
+
url: "/mcp-servers",
|
|
1176
|
+
...options,
|
|
1177
|
+
headers: {
|
|
1178
|
+
"Content-Type": "application/json",
|
|
1179
|
+
...options?.headers
|
|
1180
|
+
}
|
|
1181
|
+
});
|
|
1182
|
+
/**
|
|
1183
|
+
* Delete an MCP server
|
|
1184
|
+
*/
|
|
1185
|
+
const deleteMcpServer = (options) => (options.client ?? client).delete({
|
|
1186
|
+
security: [{
|
|
1187
|
+
scheme: "bearer",
|
|
1188
|
+
type: "http"
|
|
1189
|
+
}, {
|
|
1190
|
+
scheme: "bearer",
|
|
1191
|
+
type: "http"
|
|
1192
|
+
}],
|
|
1193
|
+
url: "/mcp-servers/{serverSlug}",
|
|
1194
|
+
...options
|
|
1195
|
+
});
|
|
1196
|
+
/**
|
|
1197
|
+
* Get a single MCP server together with its files
|
|
1198
|
+
*/
|
|
1199
|
+
const getMcpServer = (options) => (options.client ?? client).get({
|
|
1200
|
+
security: [{
|
|
1201
|
+
scheme: "bearer",
|
|
1202
|
+
type: "http"
|
|
1203
|
+
}, {
|
|
1204
|
+
scheme: "bearer",
|
|
1205
|
+
type: "http"
|
|
1206
|
+
}],
|
|
1207
|
+
url: "/mcp-servers/{serverSlug}",
|
|
1208
|
+
...options
|
|
1209
|
+
});
|
|
1210
|
+
/**
|
|
1211
|
+
* Update an MCP server. The slug can be changed, which also changes the URL of the server
|
|
1212
|
+
*/
|
|
1213
|
+
const updateMcpServer = (options) => (options.client ?? client).put({
|
|
1214
|
+
security: [{
|
|
1215
|
+
scheme: "bearer",
|
|
1216
|
+
type: "http"
|
|
1217
|
+
}, {
|
|
1218
|
+
scheme: "bearer",
|
|
1219
|
+
type: "http"
|
|
1220
|
+
}],
|
|
1221
|
+
url: "/mcp-servers/{serverSlug}",
|
|
1222
|
+
...options,
|
|
1223
|
+
headers: {
|
|
1224
|
+
"Content-Type": "application/json",
|
|
1225
|
+
...options.headers
|
|
1226
|
+
}
|
|
1227
|
+
});
|
|
1228
|
+
/**
|
|
1229
|
+
* Get the running status of an MCP server. Servers with transport type "stdio" or "hosted" report the status of their containers. All other servers always report as running
|
|
1230
|
+
*/
|
|
1231
|
+
const getMcpServerRunningStatus = (options) => (options.client ?? client).get({
|
|
1232
|
+
security: [{
|
|
1233
|
+
scheme: "bearer",
|
|
1234
|
+
type: "http"
|
|
1235
|
+
}, {
|
|
1236
|
+
scheme: "bearer",
|
|
1237
|
+
type: "http"
|
|
1238
|
+
}],
|
|
1239
|
+
url: "/mcp-servers/{serverSlug}/running-status",
|
|
1240
|
+
...options
|
|
1241
|
+
});
|
|
1242
|
+
/**
|
|
1243
|
+
* Starts a stopped MCP server. Only usable if the server has transport type "stdio" or "hosted"
|
|
1244
|
+
*/
|
|
1245
|
+
const startMcpServer = (options) => (options.client ?? client).post({
|
|
1246
|
+
security: [{
|
|
1247
|
+
scheme: "bearer",
|
|
1248
|
+
type: "http"
|
|
1249
|
+
}, {
|
|
1250
|
+
scheme: "bearer",
|
|
1251
|
+
type: "http"
|
|
1252
|
+
}],
|
|
1253
|
+
url: "/mcp-servers/{serverSlug}/start",
|
|
1254
|
+
...options
|
|
1255
|
+
});
|
|
1256
|
+
/**
|
|
1257
|
+
* Stops a running MCP server. Only usable if the server has transport type "stdio" or "hosted"
|
|
1258
|
+
*/
|
|
1259
|
+
const stopMcpServer = (options) => (options.client ?? client).post({
|
|
1260
|
+
security: [{
|
|
1261
|
+
scheme: "bearer",
|
|
1262
|
+
type: "http"
|
|
1263
|
+
}, {
|
|
1264
|
+
scheme: "bearer",
|
|
1265
|
+
type: "http"
|
|
1266
|
+
}],
|
|
1267
|
+
url: "/mcp-servers/{serverSlug}/stop",
|
|
1268
|
+
...options
|
|
1269
|
+
});
|
|
1270
|
+
/**
|
|
1271
|
+
* Enable or disable an MCP server. Enabling fails if the organization has no subscription which permits more enabled servers
|
|
1272
|
+
*/
|
|
1273
|
+
const updateMcpServerIsEnabled = (options) => (options.client ?? client).put({
|
|
1274
|
+
security: [{
|
|
1275
|
+
scheme: "bearer",
|
|
1276
|
+
type: "http"
|
|
1277
|
+
}, {
|
|
1278
|
+
scheme: "bearer",
|
|
1279
|
+
type: "http"
|
|
1280
|
+
}],
|
|
1281
|
+
url: "/mcp-servers/{serverSlug}/isEnabled",
|
|
1282
|
+
...options,
|
|
1283
|
+
headers: {
|
|
1284
|
+
"Content-Type": "application/json",
|
|
1285
|
+
...options.headers
|
|
1286
|
+
}
|
|
1287
|
+
});
|
|
1288
|
+
/**
|
|
1289
|
+
* Discover OAuth metadata from the given URL or from the remote MCP server URL
|
|
1290
|
+
*/
|
|
1291
|
+
const discoverMcpServerOauth = (options) => (options.client ?? client).get({
|
|
1292
|
+
security: [{
|
|
1293
|
+
scheme: "bearer",
|
|
1294
|
+
type: "http"
|
|
1295
|
+
}, {
|
|
1296
|
+
scheme: "bearer",
|
|
1297
|
+
type: "http"
|
|
1298
|
+
}],
|
|
1299
|
+
url: "/mcp-servers/{serverSlug}/oauth/discover",
|
|
1300
|
+
...options
|
|
1301
|
+
});
|
|
1302
|
+
/**
|
|
1303
|
+
* Fetch a remote OpenAPI/Swagger specification from the given URL and validate that it is a valid spec
|
|
1304
|
+
*/
|
|
1305
|
+
const testMcpServerOpenapi = (options) => (options.client ?? client).post({
|
|
1306
|
+
security: [{
|
|
1307
|
+
scheme: "bearer",
|
|
1308
|
+
type: "http"
|
|
1309
|
+
}, {
|
|
1310
|
+
scheme: "bearer",
|
|
1311
|
+
type: "http"
|
|
1312
|
+
}],
|
|
1313
|
+
url: "/mcp-servers/{serverSlug}/openapi/test",
|
|
1314
|
+
...options,
|
|
1315
|
+
headers: {
|
|
1316
|
+
"Content-Type": "application/json",
|
|
1317
|
+
...options.headers
|
|
1318
|
+
}
|
|
1319
|
+
});
|
|
1320
|
+
/**
|
|
1321
|
+
* List all cached tools of an MCP server, including the disabled ones
|
|
1322
|
+
*/
|
|
1323
|
+
const listMcpServerTools = (options) => (options.client ?? client).get({
|
|
1324
|
+
security: [{
|
|
1325
|
+
scheme: "bearer",
|
|
1326
|
+
type: "http"
|
|
1327
|
+
}, {
|
|
1328
|
+
scheme: "bearer",
|
|
1329
|
+
type: "http"
|
|
1330
|
+
}],
|
|
1331
|
+
url: "/mcp-servers/{serverSlug}/tools",
|
|
1332
|
+
...options
|
|
1333
|
+
});
|
|
1334
|
+
/**
|
|
1335
|
+
* Get a single tool of an MCP server
|
|
1336
|
+
*/
|
|
1337
|
+
const getMcpServerTool = (options) => (options.client ?? client).get({
|
|
1338
|
+
security: [{
|
|
1339
|
+
scheme: "bearer",
|
|
1340
|
+
type: "http"
|
|
1341
|
+
}, {
|
|
1342
|
+
scheme: "bearer",
|
|
1343
|
+
type: "http"
|
|
1344
|
+
}],
|
|
1345
|
+
url: "/mcp-servers/{serverSlug}/tools/{toolName}",
|
|
1346
|
+
...options
|
|
1347
|
+
});
|
|
1348
|
+
/**
|
|
1349
|
+
* Update a single tool of an MCP server
|
|
1350
|
+
*/
|
|
1351
|
+
const patchMcpServerTool = (options) => (options.client ?? client).patch({
|
|
1352
|
+
security: [{
|
|
1353
|
+
scheme: "bearer",
|
|
1354
|
+
type: "http"
|
|
1355
|
+
}, {
|
|
1356
|
+
scheme: "bearer",
|
|
1357
|
+
type: "http"
|
|
1358
|
+
}],
|
|
1359
|
+
url: "/mcp-servers/{serverSlug}/tools/{toolName}",
|
|
1360
|
+
...options,
|
|
1361
|
+
headers: {
|
|
1362
|
+
"Content-Type": "application/json",
|
|
1363
|
+
...options.headers
|
|
1364
|
+
}
|
|
1365
|
+
});
|
|
1366
|
+
/**
|
|
1367
|
+
* Enable or disable all tools of an MCP server. Tells the connected MCP clients that the tool list changed
|
|
1368
|
+
*/
|
|
1369
|
+
const updateMcpServerAllToolsIsEnabled = (options) => (options.client ?? client).put({
|
|
1370
|
+
security: [{
|
|
1371
|
+
scheme: "bearer",
|
|
1372
|
+
type: "http"
|
|
1373
|
+
}, {
|
|
1374
|
+
scheme: "bearer",
|
|
1375
|
+
type: "http"
|
|
1376
|
+
}],
|
|
1377
|
+
url: "/mcp-servers/{serverSlug}/all-tools-isEnabled",
|
|
1378
|
+
...options,
|
|
1379
|
+
headers: {
|
|
1380
|
+
"Content-Type": "application/json",
|
|
1381
|
+
...options.headers
|
|
1382
|
+
}
|
|
1383
|
+
});
|
|
1384
|
+
/**
|
|
1385
|
+
* Enable or disable a single tool of an MCP server. Tells the connected MCP clients that the tool list changed
|
|
1386
|
+
*/
|
|
1387
|
+
const updateMcpServerToolIsEnabled = (options) => (options.client ?? client).put({
|
|
1388
|
+
security: [{
|
|
1389
|
+
scheme: "bearer",
|
|
1390
|
+
type: "http"
|
|
1391
|
+
}, {
|
|
1392
|
+
scheme: "bearer",
|
|
1393
|
+
type: "http"
|
|
1394
|
+
}],
|
|
1395
|
+
url: "/mcp-servers/{serverSlug}/tools/{toolName}/isEnabled",
|
|
1396
|
+
...options,
|
|
1397
|
+
headers: {
|
|
1398
|
+
"Content-Type": "application/json",
|
|
1399
|
+
...options.headers
|
|
1400
|
+
}
|
|
1401
|
+
});
|
|
1402
|
+
/**
|
|
1403
|
+
* Call a tool on an MCP server. The tool must be enabled, the arguments are validated against the tool schema, and the call is written to the audit log
|
|
1404
|
+
*/
|
|
1405
|
+
const callMcpServerTool = (options) => (options.client ?? client).post({
|
|
1406
|
+
security: [{
|
|
1407
|
+
scheme: "bearer",
|
|
1408
|
+
type: "http"
|
|
1409
|
+
}, {
|
|
1410
|
+
scheme: "bearer",
|
|
1411
|
+
type: "http"
|
|
1412
|
+
}],
|
|
1413
|
+
url: "/mcp-servers/{serverSlug}/tools/{toolName}/call",
|
|
1414
|
+
...options,
|
|
1415
|
+
headers: {
|
|
1416
|
+
"Content-Type": "application/json",
|
|
1417
|
+
...options.headers
|
|
1418
|
+
}
|
|
1419
|
+
});
|
|
1420
|
+
/**
|
|
1421
|
+
* List all cached tools of every MCP server the caller has access to, including the disabled ones
|
|
1422
|
+
*/
|
|
1423
|
+
const listTools = (options) => (options?.client ?? client).get({
|
|
1424
|
+
security: [{
|
|
1425
|
+
scheme: "bearer",
|
|
1426
|
+
type: "http"
|
|
1427
|
+
}, {
|
|
1428
|
+
scheme: "bearer",
|
|
1429
|
+
type: "http"
|
|
1430
|
+
}],
|
|
1431
|
+
url: "/tools",
|
|
1432
|
+
...options
|
|
1433
|
+
});
|
|
1434
|
+
/**
|
|
1435
|
+
* Search the cached tools of every MCP server the caller has access to, page by page, including the disabled ones. Returns a list of tools paginated.
|
|
1436
|
+
*/
|
|
1437
|
+
const getToolsSearch = (options) => (options?.client ?? client).get({
|
|
1438
|
+
security: [{
|
|
1439
|
+
scheme: "bearer",
|
|
1440
|
+
type: "http"
|
|
1441
|
+
}, {
|
|
1442
|
+
scheme: "bearer",
|
|
1443
|
+
type: "http"
|
|
1444
|
+
}],
|
|
1445
|
+
url: "/tools/search",
|
|
1446
|
+
...options
|
|
1447
|
+
});
|
|
1448
|
+
/**
|
|
1449
|
+
* Refresh the tool cache of one MCP server, or of all enabled servers when serverSlug is omitted. Streams the progress as server-sent events, so the Accept header must be text/event-stream
|
|
1450
|
+
*/
|
|
1451
|
+
const refreshTools = (options) => (options?.client ?? client).post({
|
|
1452
|
+
security: [{
|
|
1453
|
+
scheme: "bearer",
|
|
1454
|
+
type: "http"
|
|
1455
|
+
}, {
|
|
1456
|
+
scheme: "bearer",
|
|
1457
|
+
type: "http"
|
|
1458
|
+
}],
|
|
1459
|
+
url: "/tools/refresh",
|
|
1460
|
+
...options
|
|
1461
|
+
});
|
|
1462
|
+
/**
|
|
1463
|
+
* List the users and teams which are members of an MCP server, with their roles
|
|
1464
|
+
*/
|
|
1465
|
+
const listMcpServerMembers = (options) => (options.client ?? client).get({
|
|
1466
|
+
security: [{
|
|
1467
|
+
scheme: "bearer",
|
|
1468
|
+
type: "http"
|
|
1469
|
+
}, {
|
|
1470
|
+
scheme: "bearer",
|
|
1471
|
+
type: "http"
|
|
1472
|
+
}],
|
|
1473
|
+
url: "/mcp-servers/{serverSlug}/members/",
|
|
1474
|
+
...options
|
|
1475
|
+
});
|
|
1476
|
+
/**
|
|
1477
|
+
* Remove a user or a team from the members of an MCP server
|
|
1478
|
+
*/
|
|
1479
|
+
const deleteMcpServerMember = (options) => (options.client ?? client).delete({
|
|
1480
|
+
security: [{
|
|
1481
|
+
scheme: "bearer",
|
|
1482
|
+
type: "http"
|
|
1483
|
+
}, {
|
|
1484
|
+
scheme: "bearer",
|
|
1485
|
+
type: "http"
|
|
1486
|
+
}],
|
|
1487
|
+
url: "/mcp-servers/{serverSlug}/members/{memberType}/{memberId}",
|
|
1488
|
+
...options
|
|
1489
|
+
});
|
|
1490
|
+
/**
|
|
1491
|
+
* Add a user or a team as a member of an MCP server, or change the role of an existing member
|
|
1492
|
+
*/
|
|
1493
|
+
const updateMcpServerMember = (options) => (options.client ?? client).put({
|
|
1494
|
+
security: [{
|
|
1495
|
+
scheme: "bearer",
|
|
1496
|
+
type: "http"
|
|
1497
|
+
}, {
|
|
1498
|
+
scheme: "bearer",
|
|
1499
|
+
type: "http"
|
|
1500
|
+
}],
|
|
1501
|
+
url: "/mcp-servers/{serverSlug}/members/{memberType}/{memberId}",
|
|
1502
|
+
...options,
|
|
1503
|
+
headers: {
|
|
1504
|
+
"Content-Type": "application/json",
|
|
1505
|
+
...options.headers
|
|
1506
|
+
}
|
|
1507
|
+
});
|
|
1508
|
+
/**
|
|
1509
|
+
* Delete the credentials of the authenticated user for an MCP server
|
|
1510
|
+
*/
|
|
1511
|
+
const deleteMcpServerCredentialsUser = (options) => (options.client ?? client).delete({
|
|
1512
|
+
security: [{
|
|
1513
|
+
scheme: "bearer",
|
|
1514
|
+
type: "http"
|
|
1515
|
+
}, {
|
|
1516
|
+
scheme: "bearer",
|
|
1517
|
+
type: "http"
|
|
1518
|
+
}],
|
|
1519
|
+
url: "/mcp-servers/{serverSlug}/credentials/user",
|
|
1520
|
+
...options
|
|
1521
|
+
});
|
|
1522
|
+
/**
|
|
1523
|
+
* Get the user-scoped credentials of the authenticated user for an MCP server. Secret values are not included
|
|
1524
|
+
*/
|
|
1525
|
+
const getMcpServerCredentialsUser = (options) => (options.client ?? client).get({
|
|
1526
|
+
security: [{
|
|
1527
|
+
scheme: "bearer",
|
|
1528
|
+
type: "http"
|
|
1529
|
+
}, {
|
|
1530
|
+
scheme: "bearer",
|
|
1531
|
+
type: "http"
|
|
1532
|
+
}],
|
|
1533
|
+
url: "/mcp-servers/{serverSlug}/credentials/user",
|
|
1534
|
+
...options
|
|
1535
|
+
});
|
|
1536
|
+
/**
|
|
1537
|
+
* Create or replace the credentials of the authenticated user for an MCP server. The credential type must match the authorization method of the server. Servers with transport type "stdio" or "hosted" are restarted to apply the new credentials
|
|
1538
|
+
*/
|
|
1539
|
+
const updateMcpServerCredentialsUser = (options) => (options.client ?? client).put({
|
|
1540
|
+
security: [{
|
|
1541
|
+
scheme: "bearer",
|
|
1542
|
+
type: "http"
|
|
1543
|
+
}, {
|
|
1544
|
+
scheme: "bearer",
|
|
1545
|
+
type: "http"
|
|
1546
|
+
}],
|
|
1547
|
+
url: "/mcp-servers/{serverSlug}/credentials/user",
|
|
1548
|
+
...options,
|
|
1549
|
+
headers: {
|
|
1550
|
+
"Content-Type": "application/json",
|
|
1551
|
+
...options.headers
|
|
1552
|
+
}
|
|
1553
|
+
});
|
|
1554
|
+
/**
|
|
1555
|
+
* Delete the server-scoped credentials of an MCP server
|
|
1556
|
+
*/
|
|
1557
|
+
const deleteMcpServerCredentialsServer = (options) => (options.client ?? client).delete({
|
|
1558
|
+
security: [{
|
|
1559
|
+
scheme: "bearer",
|
|
1560
|
+
type: "http"
|
|
1561
|
+
}, {
|
|
1562
|
+
scheme: "bearer",
|
|
1563
|
+
type: "http"
|
|
1564
|
+
}],
|
|
1565
|
+
url: "/mcp-servers/{serverSlug}/credentials/server",
|
|
1566
|
+
...options
|
|
1567
|
+
});
|
|
1568
|
+
/**
|
|
1569
|
+
* Get the server-scoped credentials of an MCP server. Secret values are not included
|
|
1570
|
+
*/
|
|
1571
|
+
const getMcpServerCredentialsServer = (options) => (options.client ?? client).get({
|
|
1572
|
+
security: [{
|
|
1573
|
+
scheme: "bearer",
|
|
1574
|
+
type: "http"
|
|
1575
|
+
}, {
|
|
1576
|
+
scheme: "bearer",
|
|
1577
|
+
type: "http"
|
|
1578
|
+
}],
|
|
1579
|
+
url: "/mcp-servers/{serverSlug}/credentials/server",
|
|
1580
|
+
...options
|
|
1581
|
+
});
|
|
1582
|
+
/**
|
|
1583
|
+
* Create or replace the server-scoped credentials of an MCP server. The credential type must match the authorization method of the server. Servers with transport type "stdio" or "hosted" are restarted to apply the new credentials
|
|
1584
|
+
*/
|
|
1585
|
+
const updateMcpServerCredentialsServer = (options) => (options.client ?? client).put({
|
|
1586
|
+
security: [{
|
|
1587
|
+
scheme: "bearer",
|
|
1588
|
+
type: "http"
|
|
1589
|
+
}, {
|
|
1590
|
+
scheme: "bearer",
|
|
1591
|
+
type: "http"
|
|
1592
|
+
}],
|
|
1593
|
+
url: "/mcp-servers/{serverSlug}/credentials/server",
|
|
1594
|
+
...options,
|
|
1595
|
+
headers: {
|
|
1596
|
+
"Content-Type": "application/json",
|
|
1597
|
+
...options.headers
|
|
1598
|
+
}
|
|
1599
|
+
});
|
|
1600
|
+
/**
|
|
1601
|
+
* Get the credentials of an MCP server which are scoped to the profile given in the profileId query parameter. Secret values are not included
|
|
1602
|
+
*/
|
|
1603
|
+
const getMcpServerCredentialsProfile = (options) => (options.client ?? client).get({
|
|
1604
|
+
security: [{
|
|
1605
|
+
scheme: "bearer",
|
|
1606
|
+
type: "http"
|
|
1607
|
+
}, {
|
|
1608
|
+
scheme: "bearer",
|
|
1609
|
+
type: "http"
|
|
1610
|
+
}],
|
|
1611
|
+
url: "/mcp-servers/{serverSlug}/credentials/profile",
|
|
1612
|
+
...options
|
|
1613
|
+
});
|
|
1614
|
+
/**
|
|
1615
|
+
* Get the plaintext API keys of the authenticated user for an MCP server. Only usable if the server uses API key authorization
|
|
1616
|
+
*/
|
|
1617
|
+
const listMcpServerCredentialsUserApikeys = (options) => (options.client ?? client).get({
|
|
1618
|
+
security: [{
|
|
1619
|
+
scheme: "bearer",
|
|
1620
|
+
type: "http"
|
|
1621
|
+
}, {
|
|
1622
|
+
scheme: "bearer",
|
|
1623
|
+
type: "http"
|
|
1624
|
+
}],
|
|
1625
|
+
url: "/mcp-servers/{serverSlug}/credentials/user/apikeys",
|
|
1626
|
+
...options
|
|
1627
|
+
});
|
|
1628
|
+
/**
|
|
1629
|
+
* Get the plaintext API keys of the server-scoped credentials of an MCP server. Only usable if the server uses API key authorization
|
|
1630
|
+
*/
|
|
1631
|
+
const listMcpServerCredentialsServerApikeys = (options) => (options.client ?? client).get({
|
|
1632
|
+
security: [{
|
|
1633
|
+
scheme: "bearer",
|
|
1634
|
+
type: "http"
|
|
1635
|
+
}, {
|
|
1636
|
+
scheme: "bearer",
|
|
1637
|
+
type: "http"
|
|
1638
|
+
}],
|
|
1639
|
+
url: "/mcp-servers/{serverSlug}/credentials/server/apikeys",
|
|
1640
|
+
...options
|
|
1641
|
+
});
|
|
1642
|
+
/**
|
|
1643
|
+
* Get the plaintext API keys of the profile-scoped credentials of an MCP server. Only usable if the server uses API key authorization
|
|
1644
|
+
*/
|
|
1645
|
+
const listMcpServerCredentialsProfileApikeys = (options) => (options.client ?? client).get({
|
|
1646
|
+
security: [{
|
|
1647
|
+
scheme: "bearer",
|
|
1648
|
+
type: "http"
|
|
1649
|
+
}, {
|
|
1650
|
+
scheme: "bearer",
|
|
1651
|
+
type: "http"
|
|
1652
|
+
}],
|
|
1653
|
+
url: "/mcp-servers/{serverSlug}/credentials/profile/{profileId}/apikeys",
|
|
1654
|
+
...options
|
|
1655
|
+
});
|
|
1656
|
+
/**
|
|
1657
|
+
* Delete the profile-scoped credentials of an MCP server for the given profile
|
|
1658
|
+
*/
|
|
1659
|
+
const deleteMcpServerCredentialsProfile = (options) => (options.client ?? client).delete({
|
|
1660
|
+
security: [{
|
|
1661
|
+
scheme: "bearer",
|
|
1662
|
+
type: "http"
|
|
1663
|
+
}, {
|
|
1664
|
+
scheme: "bearer",
|
|
1665
|
+
type: "http"
|
|
1666
|
+
}],
|
|
1667
|
+
url: "/mcp-servers/{serverSlug}/credentials/profiles/{profileId}",
|
|
1668
|
+
...options
|
|
1669
|
+
});
|
|
1670
|
+
/**
|
|
1671
|
+
* Create or replace the profile-scoped credentials of an MCP server. The credential type must match the authorization method of the server. Servers with transport type "stdio" or "hosted" are restarted to apply the new credentials
|
|
1672
|
+
*/
|
|
1673
|
+
const updateMcpServerCredentialsProfile = (options) => (options.client ?? client).put({
|
|
1674
|
+
security: [{
|
|
1675
|
+
scheme: "bearer",
|
|
1676
|
+
type: "http"
|
|
1677
|
+
}, {
|
|
1678
|
+
scheme: "bearer",
|
|
1679
|
+
type: "http"
|
|
1680
|
+
}],
|
|
1681
|
+
url: "/mcp-servers/{serverSlug}/credentials/profiles/{profileId}",
|
|
1682
|
+
...options,
|
|
1683
|
+
headers: {
|
|
1684
|
+
"Content-Type": "application/json",
|
|
1685
|
+
...options.headers
|
|
1686
|
+
}
|
|
1687
|
+
});
|
|
1688
|
+
/**
|
|
1689
|
+
* Copy credentials to another scope
|
|
1690
|
+
*/
|
|
1691
|
+
const copyMcpServerCredentials = (options) => (options.client ?? client).post({
|
|
1692
|
+
security: [{
|
|
1693
|
+
scheme: "bearer",
|
|
1694
|
+
type: "http"
|
|
1695
|
+
}, {
|
|
1696
|
+
scheme: "bearer",
|
|
1697
|
+
type: "http"
|
|
1698
|
+
}],
|
|
1699
|
+
url: "/mcp-servers/{serverSlug}/credentials/copy",
|
|
1700
|
+
...options
|
|
1701
|
+
});
|
|
1702
|
+
/**
|
|
1703
|
+
* Get an out-of-band OAuth URL which can be opened in any browser on any device to provide authorization credentials for this request's authenticated user. The generated URL will not require user to sign-in to Gatana; instead it will directly start the OAuth authorization flow with the remote MCP server.
|
|
1704
|
+
*/
|
|
1705
|
+
const getMcpServerCredentialsAuthorizeUrl = (options) => (options.client ?? client).get({
|
|
1706
|
+
security: [{
|
|
1707
|
+
scheme: "bearer",
|
|
1708
|
+
type: "http"
|
|
1709
|
+
}, {
|
|
1710
|
+
scheme: "bearer",
|
|
1711
|
+
type: "http"
|
|
1712
|
+
}],
|
|
1713
|
+
url: "/mcp-servers/{serverSlug}/credentials/authorize-url",
|
|
1714
|
+
...options
|
|
1715
|
+
});
|
|
1716
|
+
/**
|
|
1717
|
+
* Delete one specific credential of an MCP server by its ID, whatever its scope is
|
|
1718
|
+
*/
|
|
1719
|
+
const deleteMcpServerCredential = (options) => (options.client ?? client).delete({
|
|
1720
|
+
security: [{
|
|
1721
|
+
scheme: "bearer",
|
|
1722
|
+
type: "http"
|
|
1723
|
+
}, {
|
|
1724
|
+
scheme: "bearer",
|
|
1725
|
+
type: "http"
|
|
1726
|
+
}],
|
|
1727
|
+
url: "/mcp-servers/{serverSlug}/credentials/{credentialsId}",
|
|
1728
|
+
...options
|
|
1729
|
+
});
|
|
1730
|
+
/**
|
|
1731
|
+
* Get the usable token for a credential. For API key credentials, returns the API keys. For OAuth credentials, returns the access token, refreshing it first if possible and necessary. When credentialsId is omitted, resolves the effective credentials for the current user
|
|
1732
|
+
*/
|
|
1733
|
+
const getMcpServerCredentialsToken = (options) => (options.client ?? client).get({
|
|
1734
|
+
security: [{
|
|
1735
|
+
scheme: "bearer",
|
|
1736
|
+
type: "http"
|
|
1737
|
+
}, {
|
|
1738
|
+
scheme: "bearer",
|
|
1739
|
+
type: "http"
|
|
1740
|
+
}],
|
|
1741
|
+
url: "/mcp-servers/{serverSlug}/credentials/token",
|
|
1742
|
+
...options
|
|
1743
|
+
});
|
|
1744
|
+
/**
|
|
1745
|
+
* Download the source code of the MCP server as a zip file
|
|
1746
|
+
*/
|
|
1747
|
+
const getMcpServerSourceCode = (options) => (options.client ?? client).get({
|
|
1748
|
+
security: [{
|
|
1749
|
+
scheme: "bearer",
|
|
1750
|
+
type: "http"
|
|
1751
|
+
}, {
|
|
1752
|
+
scheme: "bearer",
|
|
1753
|
+
type: "http"
|
|
1754
|
+
}],
|
|
1755
|
+
url: "/mcp-servers/{serverSlug}/source-code",
|
|
1756
|
+
...options
|
|
1757
|
+
});
|
|
1758
|
+
/**
|
|
1759
|
+
* Upload source code zip file to update the MCP server source code
|
|
1760
|
+
*/
|
|
1761
|
+
const updateMcpServerSourceCode = (options) => (options.client ?? client).put({
|
|
1762
|
+
...formDataBodySerializer,
|
|
1763
|
+
security: [{
|
|
1764
|
+
scheme: "bearer",
|
|
1765
|
+
type: "http"
|
|
1766
|
+
}, {
|
|
1767
|
+
scheme: "bearer",
|
|
1768
|
+
type: "http"
|
|
1769
|
+
}],
|
|
1770
|
+
url: "/mcp-servers/{serverSlug}/source-code",
|
|
1771
|
+
...options,
|
|
1772
|
+
headers: {
|
|
1773
|
+
"Content-Type": null,
|
|
1774
|
+
...options.headers
|
|
1775
|
+
}
|
|
1776
|
+
});
|
|
1777
|
+
/**
|
|
1778
|
+
* List the files of an MCP server. Only usable if the server has transport type "stdio" or "hosted"
|
|
1779
|
+
*/
|
|
1780
|
+
const listMcpServerFiles = (options) => (options.client ?? client).get({
|
|
1781
|
+
security: [{
|
|
1782
|
+
scheme: "bearer",
|
|
1783
|
+
type: "http"
|
|
1784
|
+
}, {
|
|
1785
|
+
scheme: "bearer",
|
|
1786
|
+
type: "http"
|
|
1787
|
+
}],
|
|
1788
|
+
url: "/mcp-servers/{serverSlug}/files",
|
|
1789
|
+
...options
|
|
1790
|
+
});
|
|
1791
|
+
/**
|
|
1792
|
+
* Upload a new file for an MCP server. Only usable if the server has transport type "stdio" or "hosted"
|
|
1793
|
+
*/
|
|
1794
|
+
const createMcpServerFile = (options) => (options.client ?? client).post({
|
|
1795
|
+
security: [{
|
|
1796
|
+
scheme: "bearer",
|
|
1797
|
+
type: "http"
|
|
1798
|
+
}, {
|
|
1799
|
+
scheme: "bearer",
|
|
1800
|
+
type: "http"
|
|
1801
|
+
}],
|
|
1802
|
+
url: "/mcp-servers/{serverSlug}/files",
|
|
1803
|
+
...options
|
|
1804
|
+
});
|
|
1805
|
+
/**
|
|
1806
|
+
* Rename a file of an MCP server
|
|
1807
|
+
*/
|
|
1808
|
+
const updateMcpServerFileName = (options) => (options.client ?? client).put({
|
|
1809
|
+
security: [{
|
|
1810
|
+
scheme: "bearer",
|
|
1811
|
+
type: "http"
|
|
1812
|
+
}, {
|
|
1813
|
+
scheme: "bearer",
|
|
1814
|
+
type: "http"
|
|
1815
|
+
}],
|
|
1816
|
+
url: "/mcp-servers/{serverSlug}/files/{fileId}/name",
|
|
1817
|
+
...options,
|
|
1818
|
+
headers: {
|
|
1819
|
+
"Content-Type": "application/json",
|
|
1820
|
+
...options.headers
|
|
1821
|
+
}
|
|
1822
|
+
});
|
|
1823
|
+
/**
|
|
1824
|
+
* Delete a file of an MCP server. The file is also removed from the storage bucket
|
|
1825
|
+
*/
|
|
1826
|
+
const deleteMcpServerFile = (options) => (options.client ?? client).delete({
|
|
1827
|
+
security: [{
|
|
1828
|
+
scheme: "bearer",
|
|
1829
|
+
type: "http"
|
|
1830
|
+
}, {
|
|
1831
|
+
scheme: "bearer",
|
|
1832
|
+
type: "http"
|
|
1833
|
+
}],
|
|
1834
|
+
url: "/mcp-servers/{serverSlug}/files/{fileId}",
|
|
1835
|
+
...options
|
|
1836
|
+
});
|
|
1837
|
+
/**
|
|
1838
|
+
* Download the content of a file
|
|
1839
|
+
*/
|
|
1840
|
+
const getMcpServerFile = (options) => (options.client ?? client).get({
|
|
1841
|
+
security: [{
|
|
1842
|
+
scheme: "bearer",
|
|
1843
|
+
type: "http"
|
|
1844
|
+
}, {
|
|
1845
|
+
scheme: "bearer",
|
|
1846
|
+
type: "http"
|
|
1847
|
+
}],
|
|
1848
|
+
url: "/mcp-servers/{serverSlug}/files/{fileId}",
|
|
1849
|
+
...options
|
|
1850
|
+
});
|
|
1851
|
+
/**
|
|
1852
|
+
* Replace the contents of an existing file of an MCP server with the uploaded file
|
|
1853
|
+
*/
|
|
1854
|
+
const updateMcpServerFile = (options) => (options.client ?? client).put({
|
|
1855
|
+
security: [{
|
|
1856
|
+
scheme: "bearer",
|
|
1857
|
+
type: "http"
|
|
1858
|
+
}, {
|
|
1859
|
+
scheme: "bearer",
|
|
1860
|
+
type: "http"
|
|
1861
|
+
}],
|
|
1862
|
+
url: "/mcp-servers/{serverSlug}/files/{fileId}",
|
|
1863
|
+
...options
|
|
1864
|
+
});
|
|
1865
|
+
/**
|
|
1866
|
+
* Get tenant details
|
|
1867
|
+
*/
|
|
1868
|
+
const getTenant = (options) => (options.client ?? client).get({
|
|
1869
|
+
security: [{
|
|
1870
|
+
scheme: "bearer",
|
|
1871
|
+
type: "http"
|
|
1872
|
+
}, {
|
|
1873
|
+
scheme: "bearer",
|
|
1874
|
+
type: "http"
|
|
1875
|
+
}],
|
|
1876
|
+
url: "/tenants/{tenantId}",
|
|
1877
|
+
...options
|
|
1878
|
+
});
|
|
1879
|
+
/**
|
|
1880
|
+
* Get tenant subscription details
|
|
1881
|
+
*/
|
|
1882
|
+
const getTenantSubscription = (options) => (options.client ?? client).get({
|
|
1883
|
+
security: [{
|
|
1884
|
+
scheme: "bearer",
|
|
1885
|
+
type: "http"
|
|
1886
|
+
}, {
|
|
1887
|
+
scheme: "bearer",
|
|
1888
|
+
type: "http"
|
|
1889
|
+
}],
|
|
1890
|
+
url: "/tenants/{tenantId}/subscription",
|
|
1891
|
+
...options
|
|
1892
|
+
});
|
|
1893
|
+
/**
|
|
1894
|
+
* Install a predefined built-in MCP server for the current tenant and refresh its tool cache. Fails if the server is already installed. Requires manage permission on the tenant
|
|
1895
|
+
*/
|
|
1896
|
+
const installPredefinedBuiltInServer = (options) => (options.client ?? client).post({
|
|
1897
|
+
security: [{
|
|
1898
|
+
scheme: "bearer",
|
|
1899
|
+
type: "http"
|
|
1900
|
+
}, {
|
|
1901
|
+
scheme: "bearer",
|
|
1902
|
+
type: "http"
|
|
1903
|
+
}],
|
|
1904
|
+
url: "/install-predefined/{id}",
|
|
1905
|
+
...options
|
|
1906
|
+
});
|
|
1907
|
+
/**
|
|
1908
|
+
* Get the deployment status of an MCP server or a sandbox. Provide either serverSlug or sandboxId; requires read permission on the server
|
|
1909
|
+
*/
|
|
1910
|
+
const getDeploymentsStatus = (options) => (options?.client ?? client).get({
|
|
1911
|
+
security: [{
|
|
1912
|
+
scheme: "bearer",
|
|
1913
|
+
type: "http"
|
|
1914
|
+
}, {
|
|
1915
|
+
scheme: "bearer",
|
|
1916
|
+
type: "http"
|
|
1917
|
+
}],
|
|
1918
|
+
url: "/deployments/status",
|
|
1919
|
+
...options
|
|
1920
|
+
});
|
|
1921
|
+
/**
|
|
1922
|
+
* Get the logs of a container of a pod, or stream them when the Accept header is text/event-stream. Defaults to the server container; set previous=true for the logs of the previous container instance
|
|
1923
|
+
*/
|
|
1924
|
+
const listDeploymentsLogs = (options) => (options.client ?? client).get({
|
|
1925
|
+
security: [{
|
|
1926
|
+
scheme: "bearer",
|
|
1927
|
+
type: "http"
|
|
1928
|
+
}, {
|
|
1929
|
+
scheme: "bearer",
|
|
1930
|
+
type: "http"
|
|
1931
|
+
}],
|
|
1932
|
+
url: "/deployments/logs",
|
|
1933
|
+
...options
|
|
1934
|
+
});
|
|
1935
|
+
/**
|
|
1936
|
+
* Get historical CPU, memory and storage usage metrics for a deployment. Provide either serverSlug or sandboxId; requires read permission on the server
|
|
1937
|
+
*/
|
|
1938
|
+
const listDeploymentsMetrics = (options) => (options?.client ?? client).get({
|
|
1939
|
+
security: [{
|
|
1940
|
+
scheme: "bearer",
|
|
1941
|
+
type: "http"
|
|
1942
|
+
}, {
|
|
1943
|
+
scheme: "bearer",
|
|
1944
|
+
type: "http"
|
|
1945
|
+
}],
|
|
1946
|
+
url: "/deployments/metrics",
|
|
1947
|
+
...options
|
|
1948
|
+
});
|
|
1949
|
+
/**
|
|
1950
|
+
* Stream the deployment and pod events of an MCP server as server-sent events. Requires read permission on the server and the Accept header text/event-stream; hostedFunctionId is no longer supported
|
|
1951
|
+
*/
|
|
1952
|
+
const listDeploymentsDeploymentLogs = (options) => (options?.client ?? client).sse.get({
|
|
1953
|
+
security: [{
|
|
1954
|
+
scheme: "bearer",
|
|
1955
|
+
type: "http"
|
|
1956
|
+
}, {
|
|
1957
|
+
scheme: "bearer",
|
|
1958
|
+
type: "http"
|
|
1959
|
+
}],
|
|
1960
|
+
url: "/deployments/deployment-logs",
|
|
1961
|
+
...options
|
|
1962
|
+
});
|
|
1963
|
+
/**
|
|
1964
|
+
* List the teams the caller can read, optionally only those a given user is a member of
|
|
1965
|
+
*/
|
|
1966
|
+
const listTeams = (options) => (options?.client ?? client).get({
|
|
1967
|
+
security: [{
|
|
1968
|
+
scheme: "bearer",
|
|
1969
|
+
type: "http"
|
|
1970
|
+
}, {
|
|
1971
|
+
scheme: "bearer",
|
|
1972
|
+
type: "http"
|
|
1973
|
+
}],
|
|
1974
|
+
url: "/teams",
|
|
1975
|
+
...options
|
|
1976
|
+
});
|
|
1977
|
+
/**
|
|
1978
|
+
* Create a new team. The name must be unique in the organization
|
|
1979
|
+
*/
|
|
1980
|
+
const createTeam = (options) => (options?.client ?? client).post({
|
|
1981
|
+
security: [{
|
|
1982
|
+
scheme: "bearer",
|
|
1983
|
+
type: "http"
|
|
1984
|
+
}, {
|
|
1985
|
+
scheme: "bearer",
|
|
1986
|
+
type: "http"
|
|
1987
|
+
}],
|
|
1988
|
+
url: "/teams",
|
|
1989
|
+
...options,
|
|
1990
|
+
headers: {
|
|
1991
|
+
"Content-Type": "application/json",
|
|
1992
|
+
...options?.headers
|
|
1993
|
+
}
|
|
1994
|
+
});
|
|
1995
|
+
/**
|
|
1996
|
+
* Delete a team
|
|
1997
|
+
*/
|
|
1998
|
+
const deleteTeam = (options) => (options.client ?? client).delete({
|
|
1999
|
+
security: [{
|
|
2000
|
+
scheme: "bearer",
|
|
2001
|
+
type: "http"
|
|
2002
|
+
}, {
|
|
2003
|
+
scheme: "bearer",
|
|
2004
|
+
type: "http"
|
|
2005
|
+
}],
|
|
2006
|
+
url: "/teams/{teamId}",
|
|
2007
|
+
...options
|
|
2008
|
+
});
|
|
2009
|
+
/**
|
|
2010
|
+
* Get a single team
|
|
2011
|
+
*/
|
|
2012
|
+
const getTeam = (options) => (options.client ?? client).get({
|
|
2013
|
+
security: [{
|
|
2014
|
+
scheme: "bearer",
|
|
2015
|
+
type: "http"
|
|
2016
|
+
}, {
|
|
2017
|
+
scheme: "bearer",
|
|
2018
|
+
type: "http"
|
|
2019
|
+
}],
|
|
2020
|
+
url: "/teams/{teamId}",
|
|
2021
|
+
...options
|
|
2022
|
+
});
|
|
2023
|
+
/**
|
|
2024
|
+
* Update a team
|
|
2025
|
+
*/
|
|
2026
|
+
const updateTeam = (options) => (options.client ?? client).put({
|
|
2027
|
+
security: [{
|
|
2028
|
+
scheme: "bearer",
|
|
2029
|
+
type: "http"
|
|
2030
|
+
}, {
|
|
2031
|
+
scheme: "bearer",
|
|
2032
|
+
type: "http"
|
|
2033
|
+
}],
|
|
2034
|
+
url: "/teams/{teamId}",
|
|
2035
|
+
...options,
|
|
2036
|
+
headers: {
|
|
2037
|
+
"Content-Type": "application/json",
|
|
2038
|
+
...options.headers
|
|
2039
|
+
}
|
|
2040
|
+
});
|
|
2041
|
+
/**
|
|
2042
|
+
* List the members of a team with their user records. Only organization owners and members of the team can read this
|
|
2043
|
+
*/
|
|
2044
|
+
const listTeamMembers = (options) => (options.client ?? client).get({
|
|
2045
|
+
security: [{
|
|
2046
|
+
scheme: "bearer",
|
|
2047
|
+
type: "http"
|
|
2048
|
+
}, {
|
|
2049
|
+
scheme: "bearer",
|
|
2050
|
+
type: "http"
|
|
2051
|
+
}],
|
|
2052
|
+
url: "/teams/{teamId}/members",
|
|
2053
|
+
...options
|
|
2054
|
+
});
|
|
2055
|
+
/**
|
|
2056
|
+
* Add a user to a team with the given role
|
|
2057
|
+
*/
|
|
2058
|
+
const createTeamMember = (options) => (options.client ?? client).post({
|
|
2059
|
+
security: [{
|
|
2060
|
+
scheme: "bearer",
|
|
2061
|
+
type: "http"
|
|
2062
|
+
}, {
|
|
2063
|
+
scheme: "bearer",
|
|
2064
|
+
type: "http"
|
|
2065
|
+
}],
|
|
2066
|
+
url: "/teams/{teamId}/members",
|
|
2067
|
+
...options,
|
|
2068
|
+
headers: {
|
|
2069
|
+
"Content-Type": "application/json",
|
|
2070
|
+
...options.headers
|
|
2071
|
+
}
|
|
2072
|
+
});
|
|
2073
|
+
/**
|
|
2074
|
+
* Remove a member from a team
|
|
2075
|
+
*/
|
|
2076
|
+
const deleteTeamMember = (options) => (options.client ?? client).delete({
|
|
2077
|
+
security: [{
|
|
2078
|
+
scheme: "bearer",
|
|
2079
|
+
type: "http"
|
|
2080
|
+
}, {
|
|
2081
|
+
scheme: "bearer",
|
|
2082
|
+
type: "http"
|
|
2083
|
+
}],
|
|
2084
|
+
url: "/teams/{teamId}/members/{userId}",
|
|
2085
|
+
...options
|
|
2086
|
+
});
|
|
2087
|
+
/**
|
|
2088
|
+
* Change the role of a team member
|
|
2089
|
+
*/
|
|
2090
|
+
const updateTeamMember = (options) => (options.client ?? client).put({
|
|
2091
|
+
security: [{
|
|
2092
|
+
scheme: "bearer",
|
|
2093
|
+
type: "http"
|
|
2094
|
+
}, {
|
|
2095
|
+
scheme: "bearer",
|
|
2096
|
+
type: "http"
|
|
2097
|
+
}],
|
|
2098
|
+
url: "/teams/{teamId}/members/{userId}",
|
|
2099
|
+
...options,
|
|
2100
|
+
headers: {
|
|
2101
|
+
"Content-Type": "application/json",
|
|
2102
|
+
...options.headers
|
|
2103
|
+
}
|
|
2104
|
+
});
|
|
2105
|
+
/**
|
|
2106
|
+
* List the invitations of a team
|
|
2107
|
+
*/
|
|
2108
|
+
const listTeamInvitations = (options) => (options.client ?? client).get({
|
|
2109
|
+
security: [{
|
|
2110
|
+
scheme: "bearer",
|
|
2111
|
+
type: "http"
|
|
2112
|
+
}, {
|
|
2113
|
+
scheme: "bearer",
|
|
2114
|
+
type: "http"
|
|
2115
|
+
}],
|
|
2116
|
+
url: "/teams/{teamId}/invitations",
|
|
2117
|
+
...options
|
|
2118
|
+
});
|
|
2119
|
+
/**
|
|
2120
|
+
* Invite a person to a team by email. The invitation expires after 7 days and an email is sent to the address
|
|
2121
|
+
*/
|
|
2122
|
+
const createTeamInvitation = (options) => (options.client ?? client).post({
|
|
2123
|
+
security: [{
|
|
2124
|
+
scheme: "bearer",
|
|
2125
|
+
type: "http"
|
|
2126
|
+
}, {
|
|
2127
|
+
scheme: "bearer",
|
|
2128
|
+
type: "http"
|
|
2129
|
+
}],
|
|
2130
|
+
url: "/teams/{teamId}/invitations",
|
|
2131
|
+
...options,
|
|
2132
|
+
headers: {
|
|
2133
|
+
"Content-Type": "application/json",
|
|
2134
|
+
...options.headers
|
|
2135
|
+
}
|
|
2136
|
+
});
|
|
2137
|
+
/**
|
|
2138
|
+
* Delete a team invitation
|
|
2139
|
+
*/
|
|
2140
|
+
const deleteTeamInvitation = (options) => (options.client ?? client).delete({
|
|
2141
|
+
security: [{
|
|
2142
|
+
scheme: "bearer",
|
|
2143
|
+
type: "http"
|
|
2144
|
+
}, {
|
|
2145
|
+
scheme: "bearer",
|
|
2146
|
+
type: "http"
|
|
2147
|
+
}],
|
|
2148
|
+
url: "/teams/{teamId}/invitations/{invitationId}",
|
|
2149
|
+
...options
|
|
2150
|
+
});
|
|
2151
|
+
/**
|
|
2152
|
+
* List the MCP server permissions granted to a team
|
|
2153
|
+
*/
|
|
2154
|
+
const listTeamServers = (options) => (options.client ?? client).get({
|
|
2155
|
+
security: [{
|
|
2156
|
+
scheme: "bearer",
|
|
2157
|
+
type: "http"
|
|
2158
|
+
}, {
|
|
2159
|
+
scheme: "bearer",
|
|
2160
|
+
type: "http"
|
|
2161
|
+
}],
|
|
2162
|
+
url: "/teams/{teamId}/servers",
|
|
2163
|
+
...options
|
|
2164
|
+
});
|
|
2165
|
+
/**
|
|
2166
|
+
* List the identity provider claim mappings that give membership of a team at sign-in
|
|
2167
|
+
*/
|
|
2168
|
+
const listTeamClaimMappings = (options) => (options.client ?? client).get({
|
|
2169
|
+
security: [{
|
|
2170
|
+
scheme: "bearer",
|
|
2171
|
+
type: "http"
|
|
2172
|
+
}, {
|
|
2173
|
+
scheme: "bearer",
|
|
2174
|
+
type: "http"
|
|
2175
|
+
}],
|
|
2176
|
+
url: "/teams/{teamId}/claim-mappings",
|
|
2177
|
+
...options
|
|
2178
|
+
});
|
|
2179
|
+
/**
|
|
2180
|
+
* Create a claim mapping that gives membership of a team to users with a matching identity provider claim
|
|
2181
|
+
*/
|
|
2182
|
+
const createTeamClaimMapping = (options) => (options.client ?? client).post({
|
|
2183
|
+
security: [{
|
|
2184
|
+
scheme: "bearer",
|
|
2185
|
+
type: "http"
|
|
2186
|
+
}, {
|
|
2187
|
+
scheme: "bearer",
|
|
2188
|
+
type: "http"
|
|
2189
|
+
}],
|
|
2190
|
+
url: "/teams/{teamId}/claim-mappings",
|
|
2191
|
+
...options,
|
|
2192
|
+
headers: {
|
|
2193
|
+
"Content-Type": "application/json",
|
|
2194
|
+
...options.headers
|
|
2195
|
+
}
|
|
2196
|
+
});
|
|
2197
|
+
/**
|
|
2198
|
+
* Delete a team claim mapping
|
|
2199
|
+
*/
|
|
2200
|
+
const deleteTeamClaimMapping = (options) => (options.client ?? client).delete({
|
|
2201
|
+
security: [{
|
|
2202
|
+
scheme: "bearer",
|
|
2203
|
+
type: "http"
|
|
2204
|
+
}, {
|
|
2205
|
+
scheme: "bearer",
|
|
2206
|
+
type: "http"
|
|
2207
|
+
}],
|
|
2208
|
+
url: "/teams/{teamId}/claim-mappings/{mappingId}",
|
|
2209
|
+
...options
|
|
2210
|
+
});
|
|
2211
|
+
/**
|
|
2212
|
+
* List the profiles assigned to a team
|
|
2213
|
+
*/
|
|
2214
|
+
const listTeamProfiles = (options) => (options.client ?? client).get({
|
|
2215
|
+
security: [{
|
|
2216
|
+
scheme: "bearer",
|
|
2217
|
+
type: "http"
|
|
2218
|
+
}, {
|
|
2219
|
+
scheme: "bearer",
|
|
2220
|
+
type: "http"
|
|
2221
|
+
}],
|
|
2222
|
+
url: "/teams/{teamId}/profiles",
|
|
2223
|
+
...options
|
|
2224
|
+
});
|
|
2225
|
+
/**
|
|
2226
|
+
* Assign a profile to a team. Only organization owners can lock the assignment
|
|
2227
|
+
*/
|
|
2228
|
+
const createTeamProfile = (options) => (options.client ?? client).post({
|
|
2229
|
+
security: [{
|
|
2230
|
+
scheme: "bearer",
|
|
2231
|
+
type: "http"
|
|
2232
|
+
}, {
|
|
2233
|
+
scheme: "bearer",
|
|
2234
|
+
type: "http"
|
|
2235
|
+
}],
|
|
2236
|
+
url: "/teams/{teamId}/profiles",
|
|
2237
|
+
...options,
|
|
2238
|
+
headers: {
|
|
2239
|
+
"Content-Type": "application/json",
|
|
2240
|
+
...options.headers
|
|
2241
|
+
}
|
|
2242
|
+
});
|
|
2243
|
+
/**
|
|
2244
|
+
* Remove a profile assignment from a team. Only organization owners can remove a locked assignment
|
|
2245
|
+
*/
|
|
2246
|
+
const deleteTeamProfile = (options) => (options.client ?? client).delete({
|
|
2247
|
+
security: [{
|
|
2248
|
+
scheme: "bearer",
|
|
2249
|
+
type: "http"
|
|
2250
|
+
}, {
|
|
2251
|
+
scheme: "bearer",
|
|
2252
|
+
type: "http"
|
|
2253
|
+
}],
|
|
2254
|
+
url: "/teams/{teamId}/profiles/{profileId}",
|
|
2255
|
+
...options
|
|
2256
|
+
});
|
|
2257
|
+
/**
|
|
2258
|
+
* List all secret stores for the tenant
|
|
2259
|
+
*/
|
|
2260
|
+
const listSecretStores = (options) => (options?.client ?? client).get({
|
|
2261
|
+
security: [{
|
|
2262
|
+
scheme: "bearer",
|
|
2263
|
+
type: "http"
|
|
2264
|
+
}, {
|
|
2265
|
+
scheme: "bearer",
|
|
2266
|
+
type: "http"
|
|
2267
|
+
}],
|
|
2268
|
+
url: "/secret-stores",
|
|
2269
|
+
...options
|
|
2270
|
+
});
|
|
2271
|
+
/**
|
|
2272
|
+
* Create a new secret store
|
|
2273
|
+
*/
|
|
2274
|
+
const createSecretStore = (options) => (options?.client ?? client).post({
|
|
2275
|
+
security: [{
|
|
2276
|
+
scheme: "bearer",
|
|
2277
|
+
type: "http"
|
|
2278
|
+
}, {
|
|
2279
|
+
scheme: "bearer",
|
|
2280
|
+
type: "http"
|
|
2281
|
+
}],
|
|
2282
|
+
url: "/secret-stores",
|
|
2283
|
+
...options,
|
|
2284
|
+
headers: {
|
|
2285
|
+
"Content-Type": "application/json",
|
|
2286
|
+
...options?.headers
|
|
2287
|
+
}
|
|
2288
|
+
});
|
|
2289
|
+
/**
|
|
2290
|
+
* Delete a secret store
|
|
2291
|
+
*/
|
|
2292
|
+
const deleteSecretStore = (options) => (options.client ?? client).delete({
|
|
2293
|
+
security: [{
|
|
2294
|
+
scheme: "bearer",
|
|
2295
|
+
type: "http"
|
|
2296
|
+
}, {
|
|
2297
|
+
scheme: "bearer",
|
|
2298
|
+
type: "http"
|
|
2299
|
+
}],
|
|
2300
|
+
url: "/secret-stores/{id}",
|
|
2301
|
+
...options
|
|
2302
|
+
});
|
|
2303
|
+
/**
|
|
2304
|
+
* Get a secret store by ID
|
|
2305
|
+
*/
|
|
2306
|
+
const getSecretStore = (options) => (options.client ?? client).get({
|
|
2307
|
+
security: [{
|
|
2308
|
+
scheme: "bearer",
|
|
2309
|
+
type: "http"
|
|
2310
|
+
}, {
|
|
2311
|
+
scheme: "bearer",
|
|
2312
|
+
type: "http"
|
|
2313
|
+
}],
|
|
2314
|
+
url: "/secret-stores/{id}",
|
|
2315
|
+
...options
|
|
2316
|
+
});
|
|
2317
|
+
/**
|
|
2318
|
+
* Update a secret store
|
|
2319
|
+
*/
|
|
2320
|
+
const patchSecretStore = (options) => (options.client ?? client).patch({
|
|
2321
|
+
security: [{
|
|
2322
|
+
scheme: "bearer",
|
|
2323
|
+
type: "http"
|
|
2324
|
+
}, {
|
|
2325
|
+
scheme: "bearer",
|
|
2326
|
+
type: "http"
|
|
2327
|
+
}],
|
|
2328
|
+
url: "/secret-stores/{id}",
|
|
2329
|
+
...options,
|
|
2330
|
+
headers: {
|
|
2331
|
+
"Content-Type": "application/json",
|
|
2332
|
+
...options.headers
|
|
2333
|
+
}
|
|
2334
|
+
});
|
|
2335
|
+
/**
|
|
2336
|
+
* List all secret mappings for a store
|
|
2337
|
+
*/
|
|
2338
|
+
const listSecretStoreMappings = (options) => (options.client ?? client).get({
|
|
2339
|
+
security: [{
|
|
2340
|
+
scheme: "bearer",
|
|
2341
|
+
type: "http"
|
|
2342
|
+
}, {
|
|
2343
|
+
scheme: "bearer",
|
|
2344
|
+
type: "http"
|
|
2345
|
+
}],
|
|
2346
|
+
url: "/secret-stores/{storeId}/mappings",
|
|
2347
|
+
...options
|
|
2348
|
+
});
|
|
2349
|
+
/**
|
|
2350
|
+
* Create a new secret mapping
|
|
2351
|
+
*/
|
|
2352
|
+
const createSecretStoreMapping = (options) => (options.client ?? client).post({
|
|
2353
|
+
security: [{
|
|
2354
|
+
scheme: "bearer",
|
|
2355
|
+
type: "http"
|
|
2356
|
+
}, {
|
|
2357
|
+
scheme: "bearer",
|
|
2358
|
+
type: "http"
|
|
2359
|
+
}],
|
|
2360
|
+
url: "/secret-stores/{storeId}/mappings",
|
|
2361
|
+
...options,
|
|
2362
|
+
headers: {
|
|
2363
|
+
"Content-Type": "application/json",
|
|
2364
|
+
...options.headers
|
|
2365
|
+
}
|
|
2366
|
+
});
|
|
2367
|
+
/**
|
|
2368
|
+
* Delete a secret mapping
|
|
2369
|
+
*/
|
|
2370
|
+
const deleteSecretStoreMapping = (options) => (options.client ?? client).delete({
|
|
2371
|
+
security: [{
|
|
2372
|
+
scheme: "bearer",
|
|
2373
|
+
type: "http"
|
|
2374
|
+
}, {
|
|
2375
|
+
scheme: "bearer",
|
|
2376
|
+
type: "http"
|
|
2377
|
+
}],
|
|
2378
|
+
url: "/secret-stores/{storeId}/mappings/{mappingName}",
|
|
2379
|
+
...options
|
|
2380
|
+
});
|
|
2381
|
+
/**
|
|
2382
|
+
* Update a secret mapping
|
|
2383
|
+
*/
|
|
2384
|
+
const patchSecretStoreMapping = (options) => (options.client ?? client).patch({
|
|
2385
|
+
security: [{
|
|
2386
|
+
scheme: "bearer",
|
|
2387
|
+
type: "http"
|
|
2388
|
+
}, {
|
|
2389
|
+
scheme: "bearer",
|
|
2390
|
+
type: "http"
|
|
2391
|
+
}],
|
|
2392
|
+
url: "/secret-stores/{storeId}/mappings/{mappingName}",
|
|
2393
|
+
...options,
|
|
2394
|
+
headers: {
|
|
2395
|
+
"Content-Type": "application/json",
|
|
2396
|
+
...options.headers
|
|
2397
|
+
}
|
|
2398
|
+
});
|
|
2399
|
+
/**
|
|
2400
|
+
* Test fetching a secret from the store using a secret identifier (e.g., AWS ARN, GCP secret path)
|
|
2401
|
+
*/
|
|
2402
|
+
const testSecretStore = (options) => (options.client ?? client).post({
|
|
2403
|
+
security: [{
|
|
2404
|
+
scheme: "bearer",
|
|
2405
|
+
type: "http"
|
|
2406
|
+
}, {
|
|
2407
|
+
scheme: "bearer",
|
|
2408
|
+
type: "http"
|
|
2409
|
+
}],
|
|
2410
|
+
url: "/secret-stores/{storeId}/test",
|
|
2411
|
+
...options,
|
|
2412
|
+
headers: {
|
|
2413
|
+
"Content-Type": "application/json",
|
|
2414
|
+
...options.headers
|
|
2415
|
+
}
|
|
2416
|
+
});
|
|
2417
|
+
/**
|
|
2418
|
+
* Remove the SIEM streaming destination
|
|
2419
|
+
*/
|
|
2420
|
+
const deleteSiemDestination = (options) => (options?.client ?? client).delete({
|
|
2421
|
+
security: [{
|
|
2422
|
+
scheme: "bearer",
|
|
2423
|
+
type: "http"
|
|
2424
|
+
}, {
|
|
2425
|
+
scheme: "bearer",
|
|
2426
|
+
type: "http"
|
|
2427
|
+
}],
|
|
2428
|
+
url: "/siem-destination",
|
|
2429
|
+
...options
|
|
2430
|
+
});
|
|
2431
|
+
/**
|
|
2432
|
+
* Get the SIEM streaming destination of the organization, or null when none is configured
|
|
2433
|
+
*/
|
|
2434
|
+
const getSiemDestination = (options) => (options?.client ?? client).get({
|
|
2435
|
+
security: [{
|
|
2436
|
+
scheme: "bearer",
|
|
2437
|
+
type: "http"
|
|
2438
|
+
}, {
|
|
2439
|
+
scheme: "bearer",
|
|
2440
|
+
type: "http"
|
|
2441
|
+
}],
|
|
2442
|
+
url: "/siem-destination",
|
|
2443
|
+
...options
|
|
2444
|
+
});
|
|
2445
|
+
/**
|
|
2446
|
+
* Update the SIEM streaming destination
|
|
2447
|
+
*/
|
|
2448
|
+
const patchSiemDestination = (options) => (options?.client ?? client).patch({
|
|
2449
|
+
security: [{
|
|
2450
|
+
scheme: "bearer",
|
|
2451
|
+
type: "http"
|
|
2452
|
+
}, {
|
|
2453
|
+
scheme: "bearer",
|
|
2454
|
+
type: "http"
|
|
2455
|
+
}],
|
|
2456
|
+
url: "/siem-destination",
|
|
2457
|
+
...options,
|
|
2458
|
+
headers: {
|
|
2459
|
+
"Content-Type": "application/json",
|
|
2460
|
+
...options?.headers
|
|
2461
|
+
}
|
|
2462
|
+
});
|
|
2463
|
+
/**
|
|
2464
|
+
* Configure SIEM streaming. The signing secret is returned once and cannot be retrieved later
|
|
2465
|
+
*/
|
|
2466
|
+
const createSiemDestination = (options) => (options?.client ?? client).post({
|
|
2467
|
+
security: [{
|
|
2468
|
+
scheme: "bearer",
|
|
2469
|
+
type: "http"
|
|
2470
|
+
}, {
|
|
2471
|
+
scheme: "bearer",
|
|
2472
|
+
type: "http"
|
|
2473
|
+
}],
|
|
2474
|
+
url: "/siem-destination",
|
|
2475
|
+
...options,
|
|
2476
|
+
headers: {
|
|
2477
|
+
"Content-Type": "application/json",
|
|
2478
|
+
...options?.headers
|
|
2479
|
+
}
|
|
2480
|
+
});
|
|
2481
|
+
/**
|
|
2482
|
+
* Reveal the signing secret used to sign delivered batches
|
|
2483
|
+
*/
|
|
2484
|
+
const getSiemDestinationSecret = (options) => (options?.client ?? client).get({
|
|
2485
|
+
security: [{
|
|
2486
|
+
scheme: "bearer",
|
|
2487
|
+
type: "http"
|
|
2488
|
+
}, {
|
|
2489
|
+
scheme: "bearer",
|
|
2490
|
+
type: "http"
|
|
2491
|
+
}],
|
|
2492
|
+
url: "/siem-destination/secret",
|
|
2493
|
+
...options
|
|
2494
|
+
});
|
|
2495
|
+
/**
|
|
2496
|
+
* Generate a new signing secret. Batches are signed with it immediately
|
|
2497
|
+
*/
|
|
2498
|
+
const rotateSiemDestinationSecret = (options) => (options?.client ?? client).post({
|
|
2499
|
+
security: [{
|
|
2500
|
+
scheme: "bearer",
|
|
2501
|
+
type: "http"
|
|
2502
|
+
}, {
|
|
2503
|
+
scheme: "bearer",
|
|
2504
|
+
type: "http"
|
|
2505
|
+
}],
|
|
2506
|
+
url: "/siem-destination/rotate-secret",
|
|
2507
|
+
...options
|
|
2508
|
+
});
|
|
2509
|
+
/**
|
|
2510
|
+
* Send a single test event to the destination and report what it answered
|
|
2511
|
+
*/
|
|
2512
|
+
const testSiemDestination = (options) => (options?.client ?? client).post({
|
|
2513
|
+
security: [{
|
|
2514
|
+
scheme: "bearer",
|
|
2515
|
+
type: "http"
|
|
2516
|
+
}, {
|
|
2517
|
+
scheme: "bearer",
|
|
2518
|
+
type: "http"
|
|
2519
|
+
}],
|
|
2520
|
+
url: "/siem-destination/test",
|
|
2521
|
+
...options
|
|
2522
|
+
});
|
|
2523
|
+
/**
|
|
2524
|
+
* List the profiles the caller can read, optionally filtered to one MCP server
|
|
2525
|
+
*/
|
|
2526
|
+
const listProfiles = (options) => (options?.client ?? client).get({
|
|
2527
|
+
security: [{
|
|
2528
|
+
scheme: "bearer",
|
|
2529
|
+
type: "http"
|
|
2530
|
+
}, {
|
|
2531
|
+
scheme: "bearer",
|
|
2532
|
+
type: "http"
|
|
2533
|
+
}],
|
|
2534
|
+
url: "/profiles",
|
|
2535
|
+
...options
|
|
2536
|
+
});
|
|
2537
|
+
/**
|
|
2538
|
+
* Create a new profile without any MCP servers attached
|
|
2539
|
+
*/
|
|
2540
|
+
const createProfile = (options) => (options?.client ?? client).post({
|
|
2541
|
+
security: [{
|
|
2542
|
+
scheme: "bearer",
|
|
2543
|
+
type: "http"
|
|
2544
|
+
}, {
|
|
2545
|
+
scheme: "bearer",
|
|
2546
|
+
type: "http"
|
|
2547
|
+
}],
|
|
2548
|
+
url: "/profiles",
|
|
2549
|
+
...options,
|
|
2550
|
+
headers: {
|
|
2551
|
+
"Content-Type": "application/json",
|
|
2552
|
+
...options?.headers
|
|
2553
|
+
}
|
|
2554
|
+
});
|
|
2555
|
+
/**
|
|
2556
|
+
* Delete a profile. Only callers who can manage the profile are permitted
|
|
2557
|
+
*/
|
|
2558
|
+
const deleteProfile = (options) => (options.client ?? client).delete({
|
|
2559
|
+
security: [{
|
|
2560
|
+
scheme: "bearer",
|
|
2561
|
+
type: "http"
|
|
2562
|
+
}, {
|
|
2563
|
+
scheme: "bearer",
|
|
2564
|
+
type: "http"
|
|
2565
|
+
}],
|
|
2566
|
+
url: "/profiles/{profileId}",
|
|
2567
|
+
...options
|
|
2568
|
+
});
|
|
2569
|
+
/**
|
|
2570
|
+
* Get one profile with its MCP servers and server credentials
|
|
2571
|
+
*/
|
|
2572
|
+
const getProfile = (options) => (options.client ?? client).get({
|
|
2573
|
+
security: [{
|
|
2574
|
+
scheme: "bearer",
|
|
2575
|
+
type: "http"
|
|
2576
|
+
}, {
|
|
2577
|
+
scheme: "bearer",
|
|
2578
|
+
type: "http"
|
|
2579
|
+
}],
|
|
2580
|
+
url: "/profiles/{profileId}",
|
|
2581
|
+
...options
|
|
2582
|
+
});
|
|
2583
|
+
/**
|
|
2584
|
+
* Update a profile. Closing a profile that was open to all users also removes it from all personal access tokens
|
|
2585
|
+
*/
|
|
2586
|
+
const updateProfile = (options) => (options.client ?? client).put({
|
|
2587
|
+
security: [{
|
|
2588
|
+
scheme: "bearer",
|
|
2589
|
+
type: "http"
|
|
2590
|
+
}, {
|
|
2591
|
+
scheme: "bearer",
|
|
2592
|
+
type: "http"
|
|
2593
|
+
}],
|
|
2594
|
+
url: "/profiles/{profileId}",
|
|
2595
|
+
...options,
|
|
2596
|
+
headers: {
|
|
2597
|
+
"Content-Type": "application/json",
|
|
2598
|
+
...options.headers
|
|
2599
|
+
}
|
|
2600
|
+
});
|
|
2601
|
+
/**
|
|
2602
|
+
* List the identity claim mappings that give access to the profile
|
|
2603
|
+
*/
|
|
2604
|
+
const listProfileClaimMappings = (options) => (options.client ?? client).get({
|
|
2605
|
+
security: [{
|
|
2606
|
+
scheme: "bearer",
|
|
2607
|
+
type: "http"
|
|
2608
|
+
}, {
|
|
2609
|
+
scheme: "bearer",
|
|
2610
|
+
type: "http"
|
|
2611
|
+
}],
|
|
2612
|
+
url: "/profiles/{profileId}/claim-mappings",
|
|
2613
|
+
...options
|
|
2614
|
+
});
|
|
2615
|
+
/**
|
|
2616
|
+
* Add an identity claim mapping that gives all users with the matching claim access to the profile
|
|
2617
|
+
*/
|
|
2618
|
+
const createProfileClaimMapping = (options) => (options.client ?? client).post({
|
|
2619
|
+
security: [{
|
|
2620
|
+
scheme: "bearer",
|
|
2621
|
+
type: "http"
|
|
2622
|
+
}, {
|
|
2623
|
+
scheme: "bearer",
|
|
2624
|
+
type: "http"
|
|
2625
|
+
}],
|
|
2626
|
+
url: "/profiles/{profileId}/claim-mappings",
|
|
2627
|
+
...options,
|
|
2628
|
+
headers: {
|
|
2629
|
+
"Content-Type": "application/json",
|
|
2630
|
+
...options.headers
|
|
2631
|
+
}
|
|
2632
|
+
});
|
|
2633
|
+
/**
|
|
2634
|
+
* Remove an identity claim mapping from the profile
|
|
2635
|
+
*/
|
|
2636
|
+
const deleteProfileClaimMapping = (options) => (options.client ?? client).delete({
|
|
2637
|
+
security: [{
|
|
2638
|
+
scheme: "bearer",
|
|
2639
|
+
type: "http"
|
|
2640
|
+
}, {
|
|
2641
|
+
scheme: "bearer",
|
|
2642
|
+
type: "http"
|
|
2643
|
+
}],
|
|
2644
|
+
url: "/profiles/{profileId}/claim-mappings/{mappingId}",
|
|
2645
|
+
...options
|
|
2646
|
+
});
|
|
2647
|
+
/**
|
|
2648
|
+
* List the accounts and teams that are assigned directly to the profile
|
|
2649
|
+
*/
|
|
2650
|
+
const listProfileDirectAssignments = (options) => (options.client ?? client).get({
|
|
2651
|
+
security: [{
|
|
2652
|
+
scheme: "bearer",
|
|
2653
|
+
type: "http"
|
|
2654
|
+
}, {
|
|
2655
|
+
scheme: "bearer",
|
|
2656
|
+
type: "http"
|
|
2657
|
+
}],
|
|
2658
|
+
url: "/profiles/{profileId}/direct-assignments",
|
|
2659
|
+
...options
|
|
2660
|
+
});
|
|
2661
|
+
/**
|
|
2662
|
+
* List the users who maintain the profile
|
|
2663
|
+
*/
|
|
2664
|
+
const listProfileMaintainers = (options) => (options.client ?? client).get({
|
|
2665
|
+
security: [{
|
|
2666
|
+
scheme: "bearer",
|
|
2667
|
+
type: "http"
|
|
2668
|
+
}, {
|
|
2669
|
+
scheme: "bearer",
|
|
2670
|
+
type: "http"
|
|
2671
|
+
}],
|
|
2672
|
+
url: "/profiles/{profileId}/maintainers",
|
|
2673
|
+
...options
|
|
2674
|
+
});
|
|
2675
|
+
/**
|
|
2676
|
+
* Add a user as a maintainer of the profile. Only callers who can manage the profile are permitted
|
|
2677
|
+
*/
|
|
2678
|
+
const createProfileMaintainer = (options) => (options.client ?? client).post({
|
|
2679
|
+
security: [{
|
|
2680
|
+
scheme: "bearer",
|
|
2681
|
+
type: "http"
|
|
2682
|
+
}, {
|
|
2683
|
+
scheme: "bearer",
|
|
2684
|
+
type: "http"
|
|
2685
|
+
}],
|
|
2686
|
+
url: "/profiles/{profileId}/maintainers",
|
|
2687
|
+
...options,
|
|
2688
|
+
headers: {
|
|
2689
|
+
"Content-Type": "application/json",
|
|
2690
|
+
...options.headers
|
|
2691
|
+
}
|
|
2692
|
+
});
|
|
2693
|
+
/**
|
|
2694
|
+
* Remove a maintainer from the profile. The last remaining maintainer cannot be removed
|
|
2695
|
+
*/
|
|
2696
|
+
const deleteProfileMaintainer = (options) => (options.client ?? client).delete({
|
|
2697
|
+
security: [{
|
|
2698
|
+
scheme: "bearer",
|
|
2699
|
+
type: "http"
|
|
2700
|
+
}, {
|
|
2701
|
+
scheme: "bearer",
|
|
2702
|
+
type: "http"
|
|
2703
|
+
}],
|
|
2704
|
+
url: "/profiles/{profileId}/maintainers/{userId}",
|
|
2705
|
+
...options
|
|
2706
|
+
});
|
|
2707
|
+
/**
|
|
2708
|
+
* List the tool configuration of the profile for each of its MCP servers
|
|
2709
|
+
*/
|
|
2710
|
+
const listProfileTools = (options) => (options.client ?? client).get({
|
|
2711
|
+
security: [{
|
|
2712
|
+
scheme: "bearer",
|
|
2713
|
+
type: "http"
|
|
2714
|
+
}, {
|
|
2715
|
+
scheme: "bearer",
|
|
2716
|
+
type: "http"
|
|
2717
|
+
}],
|
|
2718
|
+
url: "/profiles/{profileId}/tools",
|
|
2719
|
+
...options
|
|
2720
|
+
});
|
|
2721
|
+
/**
|
|
2722
|
+
* Replace the tool configuration that the profile uses for one of its MCP servers. The server must be attached to the profile
|
|
2723
|
+
*/
|
|
2724
|
+
const updateProfileServerTools = (options) => (options.client ?? client).put({
|
|
2725
|
+
security: [{
|
|
2726
|
+
scheme: "bearer",
|
|
2727
|
+
type: "http"
|
|
2728
|
+
}, {
|
|
2729
|
+
scheme: "bearer",
|
|
2730
|
+
type: "http"
|
|
2731
|
+
}],
|
|
2732
|
+
url: "/profiles/{profileId}/servers/{serverSlug}/tools",
|
|
2733
|
+
...options,
|
|
2734
|
+
headers: {
|
|
2735
|
+
"Content-Type": "application/json",
|
|
2736
|
+
...options.headers
|
|
2737
|
+
}
|
|
2738
|
+
});
|
|
2739
|
+
/**
|
|
2740
|
+
* List the sandboxes the caller can read. Set all=true to also include archived sandboxes
|
|
2741
|
+
*/
|
|
2742
|
+
const listSandboxes = (options) => (options?.client ?? client).get({
|
|
2743
|
+
security: [{
|
|
2744
|
+
scheme: "bearer",
|
|
2745
|
+
type: "http"
|
|
2746
|
+
}, {
|
|
2747
|
+
scheme: "bearer",
|
|
2748
|
+
type: "http"
|
|
2749
|
+
}],
|
|
2750
|
+
url: "/sandboxes",
|
|
2751
|
+
...options
|
|
2752
|
+
});
|
|
2753
|
+
/**
|
|
2754
|
+
* Create a new sandbox for the authenticated user. Requires a paid subscription and is limited to 10 concurrent sandboxes per organization
|
|
2755
|
+
*/
|
|
2756
|
+
const createSandbox = (options) => (options?.client ?? client).post({
|
|
2757
|
+
security: [{
|
|
2758
|
+
scheme: "bearer",
|
|
2759
|
+
type: "http"
|
|
2760
|
+
}, {
|
|
2761
|
+
scheme: "bearer",
|
|
2762
|
+
type: "http"
|
|
2763
|
+
}],
|
|
2764
|
+
url: "/sandboxes",
|
|
2765
|
+
...options
|
|
2766
|
+
});
|
|
2767
|
+
/**
|
|
2768
|
+
* Destroy the sandbox, delete its Kubernetes resources, and archive it
|
|
2769
|
+
*/
|
|
2770
|
+
const deleteSandbox = (options) => (options.client ?? client).delete({
|
|
2771
|
+
security: [{
|
|
2772
|
+
scheme: "bearer",
|
|
2773
|
+
type: "http"
|
|
2774
|
+
}, {
|
|
2775
|
+
scheme: "bearer",
|
|
2776
|
+
type: "http"
|
|
2777
|
+
}],
|
|
2778
|
+
url: "/sandboxes/{sandboxId}",
|
|
2779
|
+
...options
|
|
2780
|
+
});
|
|
2781
|
+
/**
|
|
2782
|
+
* Get a single sandbox by ID
|
|
2783
|
+
*/
|
|
2784
|
+
const getSandbox = (options) => (options.client ?? client).get({
|
|
2785
|
+
security: [{
|
|
2786
|
+
scheme: "bearer",
|
|
2787
|
+
type: "http"
|
|
2788
|
+
}, {
|
|
2789
|
+
scheme: "bearer",
|
|
2790
|
+
type: "http"
|
|
2791
|
+
}],
|
|
2792
|
+
url: "/sandboxes/{sandboxId}",
|
|
2793
|
+
...options
|
|
2794
|
+
});
|
|
2795
|
+
/**
|
|
2796
|
+
* Issue a short-lived token that opens an SSH session to the sandbox through the SSH proxy. The token expires after 5 minutes
|
|
2797
|
+
*/
|
|
2798
|
+
const createSandboxSshSession = (options) => (options.client ?? client).post({
|
|
2799
|
+
security: [{
|
|
2800
|
+
scheme: "bearer",
|
|
2801
|
+
type: "http"
|
|
2802
|
+
}, {
|
|
2803
|
+
scheme: "bearer",
|
|
2804
|
+
type: "http"
|
|
2805
|
+
}],
|
|
2806
|
+
url: "/sandboxes/{sandboxId}/ssh-session",
|
|
2807
|
+
...options
|
|
2808
|
+
});
|
|
2809
|
+
/**
|
|
2810
|
+
* Run a command in the sandbox and stream the output back as NDJSON. The command and its result are written to the sandbox audit log
|
|
2811
|
+
*/
|
|
2812
|
+
const execSandbox = (options) => (options.client ?? client).post({
|
|
2813
|
+
security: [{
|
|
2814
|
+
scheme: "bearer",
|
|
2815
|
+
type: "http"
|
|
2816
|
+
}, {
|
|
2817
|
+
scheme: "bearer",
|
|
2818
|
+
type: "http"
|
|
2819
|
+
}],
|
|
2820
|
+
url: "/sandboxes/{sandboxId}/exec",
|
|
2821
|
+
...options,
|
|
2822
|
+
headers: {
|
|
2823
|
+
"Content-Type": "application/json",
|
|
2824
|
+
...options.headers
|
|
2825
|
+
}
|
|
2826
|
+
});
|
|
2827
|
+
/**
|
|
2828
|
+
* Write the raw request body to the given file path in the sandbox
|
|
2829
|
+
*/
|
|
2830
|
+
const createSandboxWriteFile = (options) => (options.client ?? client).post({
|
|
2831
|
+
bodySerializer: null,
|
|
2832
|
+
security: [{
|
|
2833
|
+
scheme: "bearer",
|
|
2834
|
+
type: "http"
|
|
2835
|
+
}, {
|
|
2836
|
+
scheme: "bearer",
|
|
2837
|
+
type: "http"
|
|
2838
|
+
}],
|
|
2839
|
+
url: "/sandboxes/{sandboxId}/write-file",
|
|
2840
|
+
...options,
|
|
2841
|
+
headers: {
|
|
2842
|
+
"Content-Type": "application/octet-stream",
|
|
2843
|
+
...options.headers
|
|
2844
|
+
}
|
|
2845
|
+
});
|
|
2846
|
+
/**
|
|
2847
|
+
* Read the file at the given path in the sandbox and stream its content back
|
|
2848
|
+
*/
|
|
2849
|
+
const createSandboxReadFile = (options) => (options.client ?? client).post({
|
|
2850
|
+
security: [{
|
|
2851
|
+
scheme: "bearer",
|
|
2852
|
+
type: "http"
|
|
2853
|
+
}, {
|
|
2854
|
+
scheme: "bearer",
|
|
2855
|
+
type: "http"
|
|
2856
|
+
}],
|
|
2857
|
+
url: "/sandboxes/{sandboxId}/read-file",
|
|
2858
|
+
...options
|
|
2859
|
+
});
|
|
2860
|
+
/**
|
|
2861
|
+
* List the audit log entries of the sandbox, paginated and optionally filtered by date range
|
|
2862
|
+
*/
|
|
2863
|
+
const listSandboxAuditLogs = (options) => (options.client ?? client).get({
|
|
2864
|
+
security: [{
|
|
2865
|
+
scheme: "bearer",
|
|
2866
|
+
type: "http"
|
|
2867
|
+
}, {
|
|
2868
|
+
scheme: "bearer",
|
|
2869
|
+
type: "http"
|
|
2870
|
+
}],
|
|
2871
|
+
url: "/sandboxes/{sandboxId}/audit-logs",
|
|
2872
|
+
...options
|
|
2873
|
+
});
|
|
2874
|
+
/**
|
|
2875
|
+
* Get a single audit log entry of the sandbox by ID
|
|
2876
|
+
*/
|
|
2877
|
+
const getSandboxAuditLog = (options) => (options.client ?? client).get({
|
|
2878
|
+
security: [{
|
|
2879
|
+
scheme: "bearer",
|
|
2880
|
+
type: "http"
|
|
2881
|
+
}, {
|
|
2882
|
+
scheme: "bearer",
|
|
2883
|
+
type: "http"
|
|
2884
|
+
}],
|
|
2885
|
+
url: "/sandboxes/{sandboxId}/audit-logs/{id}",
|
|
2886
|
+
...options
|
|
2887
|
+
});
|
|
2888
|
+
/**
|
|
2889
|
+
* Send an email verification code
|
|
2890
|
+
*/
|
|
2891
|
+
const sendEmailVerificationCode = (options) => (options?.client ?? client).post({
|
|
2892
|
+
security: [{
|
|
2893
|
+
scheme: "bearer",
|
|
2894
|
+
type: "http"
|
|
2895
|
+
}, {
|
|
2896
|
+
scheme: "bearer",
|
|
2897
|
+
type: "http"
|
|
2898
|
+
}],
|
|
2899
|
+
url: "/email-verification/send-code",
|
|
2900
|
+
...options,
|
|
2901
|
+
headers: {
|
|
2902
|
+
"Content-Type": "application/json",
|
|
2903
|
+
...options?.headers
|
|
2904
|
+
}
|
|
2905
|
+
});
|
|
2906
|
+
/**
|
|
2907
|
+
* List the SCIM tokens of the organization. Requires permission to manage the organization
|
|
2908
|
+
*/
|
|
2909
|
+
const listScimConfigTokens = (options) => (options?.client ?? client).get({
|
|
2910
|
+
security: [{
|
|
2911
|
+
scheme: "bearer",
|
|
2912
|
+
type: "http"
|
|
2913
|
+
}, {
|
|
2914
|
+
scheme: "bearer",
|
|
2915
|
+
type: "http"
|
|
2916
|
+
}],
|
|
2917
|
+
url: "/scim-config/tokens",
|
|
2918
|
+
...options
|
|
2919
|
+
});
|
|
2920
|
+
/**
|
|
2921
|
+
* Create a SCIM token for identity provider provisioning. The raw token is returned in the response. Requires permission to manage the organization
|
|
2922
|
+
*/
|
|
2923
|
+
const createScimConfigToken = (options) => (options?.client ?? client).post({
|
|
2924
|
+
security: [{
|
|
2925
|
+
scheme: "bearer",
|
|
2926
|
+
type: "http"
|
|
2927
|
+
}, {
|
|
2928
|
+
scheme: "bearer",
|
|
2929
|
+
type: "http"
|
|
2930
|
+
}],
|
|
2931
|
+
url: "/scim-config/tokens",
|
|
2932
|
+
...options,
|
|
2933
|
+
headers: {
|
|
2934
|
+
"Content-Type": "application/json",
|
|
2935
|
+
...options?.headers
|
|
2936
|
+
}
|
|
2937
|
+
});
|
|
2938
|
+
/**
|
|
2939
|
+
* Reveal the raw secret of a SCIM token. Requires permission to manage the organization
|
|
2940
|
+
*/
|
|
2941
|
+
const getScimConfigTokenSecret = (options) => (options.client ?? client).get({
|
|
2942
|
+
security: [{
|
|
2943
|
+
scheme: "bearer",
|
|
2944
|
+
type: "http"
|
|
2945
|
+
}, {
|
|
2946
|
+
scheme: "bearer",
|
|
2947
|
+
type: "http"
|
|
2948
|
+
}],
|
|
2949
|
+
url: "/scim-config/tokens/{tokenId}/secret",
|
|
2950
|
+
...options
|
|
2951
|
+
});
|
|
2952
|
+
/**
|
|
2953
|
+
* Delete a SCIM token and revoke access for every client that uses it. Requires permission to manage the organization
|
|
2954
|
+
*/
|
|
2955
|
+
const deleteScimConfigToken = (options) => (options.client ?? client).delete({
|
|
2956
|
+
security: [{
|
|
2957
|
+
scheme: "bearer",
|
|
2958
|
+
type: "http"
|
|
2959
|
+
}, {
|
|
2960
|
+
scheme: "bearer",
|
|
2961
|
+
type: "http"
|
|
2962
|
+
}],
|
|
2963
|
+
url: "/scim-config/tokens/{tokenId}",
|
|
2964
|
+
...options
|
|
2965
|
+
});
|
|
2966
|
+
/**
|
|
2967
|
+
* List the OAuth clients the signed-in user has authorized
|
|
2968
|
+
*/
|
|
2969
|
+
const listConnectedClients = (options) => (options?.client ?? client).get({
|
|
2970
|
+
security: [{
|
|
2971
|
+
scheme: "bearer",
|
|
2972
|
+
type: "http"
|
|
2973
|
+
}, {
|
|
2974
|
+
scheme: "bearer",
|
|
2975
|
+
type: "http"
|
|
2976
|
+
}],
|
|
2977
|
+
url: "/connected-clients",
|
|
2978
|
+
...options
|
|
2979
|
+
});
|
|
2980
|
+
/**
|
|
2981
|
+
* Disconnect a client, revoking its grants and every token issued under them
|
|
2982
|
+
*/
|
|
2983
|
+
const deleteConnectedClient = (options) => (options.client ?? client).delete({
|
|
2984
|
+
security: [{
|
|
2985
|
+
scheme: "bearer",
|
|
2986
|
+
type: "http"
|
|
2987
|
+
}, {
|
|
2988
|
+
scheme: "bearer",
|
|
2989
|
+
type: "http"
|
|
2990
|
+
}],
|
|
2991
|
+
url: "/connected-clients/{clientId}",
|
|
2992
|
+
...options
|
|
2993
|
+
});
|
|
2994
|
+
/**
|
|
2995
|
+
* Update the name or the attached profiles of a connected client
|
|
2996
|
+
*/
|
|
2997
|
+
const patchConnectedClient = (options) => (options.client ?? client).patch({
|
|
2998
|
+
security: [{
|
|
2999
|
+
scheme: "bearer",
|
|
3000
|
+
type: "http"
|
|
3001
|
+
}, {
|
|
3002
|
+
scheme: "bearer",
|
|
3003
|
+
type: "http"
|
|
3004
|
+
}],
|
|
3005
|
+
url: "/connected-clients/{clientId}",
|
|
3006
|
+
...options,
|
|
3007
|
+
headers: {
|
|
3008
|
+
"Content-Type": "application/json",
|
|
3009
|
+
...options.headers
|
|
3010
|
+
}
|
|
3011
|
+
});
|
|
3012
|
+
/**
|
|
3013
|
+
* List the artifacts the caller can read: their own, the ones shared with them or one of their teams, and the ones shared with the organization
|
|
3014
|
+
*/
|
|
3015
|
+
const listArtifacts = (options) => (options?.client ?? client).get({
|
|
3016
|
+
security: [{
|
|
3017
|
+
scheme: "bearer",
|
|
3018
|
+
type: "http"
|
|
3019
|
+
}, {
|
|
3020
|
+
scheme: "bearer",
|
|
3021
|
+
type: "http"
|
|
3022
|
+
}],
|
|
3023
|
+
url: "/artifacts",
|
|
3024
|
+
...options
|
|
3025
|
+
});
|
|
3026
|
+
/**
|
|
3027
|
+
* Create an artifact from a Markdown or HTML document and return its viewer URL
|
|
3028
|
+
*/
|
|
3029
|
+
const createArtifact = (options) => (options?.client ?? client).post({
|
|
3030
|
+
security: [{
|
|
3031
|
+
scheme: "bearer",
|
|
3032
|
+
type: "http"
|
|
3033
|
+
}, {
|
|
3034
|
+
scheme: "bearer",
|
|
3035
|
+
type: "http"
|
|
3036
|
+
}],
|
|
3037
|
+
url: "/artifacts",
|
|
3038
|
+
...options,
|
|
3039
|
+
headers: {
|
|
3040
|
+
"Content-Type": "application/json",
|
|
3041
|
+
...options?.headers
|
|
3042
|
+
}
|
|
3043
|
+
});
|
|
3044
|
+
/**
|
|
3045
|
+
* Delete an artifact with all of its versions and stored content
|
|
3046
|
+
*/
|
|
3047
|
+
const deleteArtifact = (options) => (options.client ?? client).delete({
|
|
3048
|
+
security: [{
|
|
3049
|
+
scheme: "bearer",
|
|
3050
|
+
type: "http"
|
|
3051
|
+
}, {
|
|
3052
|
+
scheme: "bearer",
|
|
3053
|
+
type: "http"
|
|
3054
|
+
}],
|
|
3055
|
+
url: "/artifacts/{artifactId}",
|
|
3056
|
+
...options
|
|
3057
|
+
});
|
|
3058
|
+
/**
|
|
3059
|
+
* Get an artifact with its version history and a frame URL for the requested or current version, honoring its visibility for anonymous callers
|
|
3060
|
+
*/
|
|
3061
|
+
const getArtifact = (options) => (options.client ?? client).get({
|
|
3062
|
+
security: [{
|
|
3063
|
+
scheme: "bearer",
|
|
3064
|
+
type: "http"
|
|
3065
|
+
}, {
|
|
3066
|
+
scheme: "bearer",
|
|
3067
|
+
type: "http"
|
|
3068
|
+
}],
|
|
3069
|
+
url: "/artifacts/{artifactId}",
|
|
3070
|
+
...options
|
|
3071
|
+
});
|
|
3072
|
+
/**
|
|
3073
|
+
* Change the title, visibility or theme of an artifact without touching its content
|
|
3074
|
+
*/
|
|
3075
|
+
const patchArtifact = (options) => (options.client ?? client).patch({
|
|
3076
|
+
security: [{
|
|
3077
|
+
scheme: "bearer",
|
|
3078
|
+
type: "http"
|
|
3079
|
+
}, {
|
|
3080
|
+
scheme: "bearer",
|
|
3081
|
+
type: "http"
|
|
3082
|
+
}],
|
|
3083
|
+
url: "/artifacts/{artifactId}",
|
|
3084
|
+
...options,
|
|
3085
|
+
headers: {
|
|
3086
|
+
"Content-Type": "application/json",
|
|
3087
|
+
...options.headers
|
|
3088
|
+
}
|
|
3089
|
+
});
|
|
3090
|
+
/**
|
|
3091
|
+
* Update an artifact in place, storing new Markdown or HTML as a new version behind the same URL, or change its title or theme
|
|
3092
|
+
*/
|
|
3093
|
+
const updateArtifact = (options) => (options.client ?? client).put({
|
|
3094
|
+
security: [{
|
|
3095
|
+
scheme: "bearer",
|
|
3096
|
+
type: "http"
|
|
3097
|
+
}, {
|
|
3098
|
+
scheme: "bearer",
|
|
3099
|
+
type: "http"
|
|
3100
|
+
}],
|
|
3101
|
+
url: "/artifacts/{artifactId}",
|
|
3102
|
+
...options,
|
|
3103
|
+
headers: {
|
|
3104
|
+
"Content-Type": "application/json",
|
|
3105
|
+
...options.headers
|
|
3106
|
+
}
|
|
3107
|
+
});
|
|
3108
|
+
/**
|
|
3109
|
+
* Get the served HTML of an artifact version as JSON, rendered and themed, plus the Markdown source when there is one
|
|
3110
|
+
*/
|
|
3111
|
+
const getArtifactContent = (options) => (options.client ?? client).get({
|
|
3112
|
+
security: [{
|
|
3113
|
+
scheme: "bearer",
|
|
3114
|
+
type: "http"
|
|
3115
|
+
}, {
|
|
3116
|
+
scheme: "bearer",
|
|
3117
|
+
type: "http"
|
|
3118
|
+
}],
|
|
3119
|
+
url: "/artifacts/{artifactId}/content",
|
|
3120
|
+
...options
|
|
3121
|
+
});
|
|
3122
|
+
/**
|
|
3123
|
+
* List the users and teams an artifact is shared with
|
|
3124
|
+
*/
|
|
3125
|
+
const listArtifactShares = (options) => (options.client ?? client).get({
|
|
3126
|
+
security: [{
|
|
3127
|
+
scheme: "bearer",
|
|
3128
|
+
type: "http"
|
|
3129
|
+
}, {
|
|
3130
|
+
scheme: "bearer",
|
|
3131
|
+
type: "http"
|
|
3132
|
+
}],
|
|
3133
|
+
url: "/artifacts/{artifactId}/shares",
|
|
3134
|
+
...options
|
|
3135
|
+
});
|
|
3136
|
+
/**
|
|
3137
|
+
* Stop sharing an artifact with a user or a team and return who it is still shared with
|
|
3138
|
+
*/
|
|
3139
|
+
const unshareArtifact = (options) => (options.client ?? client).delete({
|
|
3140
|
+
security: [{
|
|
3141
|
+
scheme: "bearer",
|
|
3142
|
+
type: "http"
|
|
3143
|
+
}, {
|
|
3144
|
+
scheme: "bearer",
|
|
3145
|
+
type: "http"
|
|
3146
|
+
}],
|
|
3147
|
+
url: "/artifacts/{artifactId}/shares/{memberType}/{memberId}",
|
|
3148
|
+
...options
|
|
3149
|
+
});
|
|
3150
|
+
/**
|
|
3151
|
+
* Share an artifact with a user or a team, giving them read access whatever its visibility, and return who it is shared with
|
|
3152
|
+
*/
|
|
3153
|
+
const shareArtifact = (options) => (options.client ?? client).put({
|
|
3154
|
+
security: [{
|
|
3155
|
+
scheme: "bearer",
|
|
3156
|
+
type: "http"
|
|
3157
|
+
}, {
|
|
3158
|
+
scheme: "bearer",
|
|
3159
|
+
type: "http"
|
|
3160
|
+
}],
|
|
3161
|
+
url: "/artifacts/{artifactId}/shares/{memberType}/{memberId}",
|
|
3162
|
+
...options
|
|
3163
|
+
});
|
|
3164
|
+
/**
|
|
3165
|
+
* List the skills the caller can read, optionally narrowed to those whose name or description contains a text
|
|
3166
|
+
*/
|
|
3167
|
+
const listSkills = (options) => (options?.client ?? client).get({
|
|
3168
|
+
security: [{
|
|
3169
|
+
scheme: "bearer",
|
|
3170
|
+
type: "http"
|
|
3171
|
+
}, {
|
|
3172
|
+
scheme: "bearer",
|
|
3173
|
+
type: "http"
|
|
3174
|
+
}],
|
|
3175
|
+
url: "/skills",
|
|
3176
|
+
...options
|
|
3177
|
+
});
|
|
3178
|
+
/**
|
|
3179
|
+
* Create a skill from a name, a one-line description of when to use it and Markdown instructions
|
|
3180
|
+
*/
|
|
3181
|
+
const createSkill = (options) => (options?.client ?? client).post({
|
|
3182
|
+
security: [{
|
|
3183
|
+
scheme: "bearer",
|
|
3184
|
+
type: "http"
|
|
3185
|
+
}, {
|
|
3186
|
+
scheme: "bearer",
|
|
3187
|
+
type: "http"
|
|
3188
|
+
}],
|
|
3189
|
+
url: "/skills",
|
|
3190
|
+
...options,
|
|
3191
|
+
headers: {
|
|
3192
|
+
"Content-Type": "application/json",
|
|
3193
|
+
...options?.headers
|
|
3194
|
+
}
|
|
3195
|
+
});
|
|
3196
|
+
/**
|
|
3197
|
+
* Delete a skill and its shares
|
|
3198
|
+
*/
|
|
3199
|
+
const deleteSkill = (options) => (options.client ?? client).delete({
|
|
3200
|
+
security: [{
|
|
3201
|
+
scheme: "bearer",
|
|
3202
|
+
type: "http"
|
|
3203
|
+
}, {
|
|
3204
|
+
scheme: "bearer",
|
|
3205
|
+
type: "http"
|
|
3206
|
+
}],
|
|
3207
|
+
url: "/skills/{skillId}",
|
|
3208
|
+
...options
|
|
3209
|
+
});
|
|
3210
|
+
/**
|
|
3211
|
+
* Get a skill with its Markdown instructions
|
|
3212
|
+
*/
|
|
3213
|
+
const getSkill = (options) => (options.client ?? client).get({
|
|
3214
|
+
security: [{
|
|
3215
|
+
scheme: "bearer",
|
|
3216
|
+
type: "http"
|
|
3217
|
+
}, {
|
|
3218
|
+
scheme: "bearer",
|
|
3219
|
+
type: "http"
|
|
3220
|
+
}],
|
|
3221
|
+
url: "/skills/{skillId}",
|
|
3222
|
+
...options
|
|
3223
|
+
});
|
|
3224
|
+
/**
|
|
3225
|
+
* Update the name, description, instructions or visibility of a skill
|
|
3226
|
+
*/
|
|
3227
|
+
const updateSkill = (options) => (options.client ?? client).put({
|
|
3228
|
+
security: [{
|
|
3229
|
+
scheme: "bearer",
|
|
3230
|
+
type: "http"
|
|
3231
|
+
}, {
|
|
3232
|
+
scheme: "bearer",
|
|
3233
|
+
type: "http"
|
|
3234
|
+
}],
|
|
3235
|
+
url: "/skills/{skillId}",
|
|
3236
|
+
...options,
|
|
3237
|
+
headers: {
|
|
3238
|
+
"Content-Type": "application/json",
|
|
3239
|
+
...options.headers
|
|
3240
|
+
}
|
|
3241
|
+
});
|
|
3242
|
+
/**
|
|
3243
|
+
* List the users and teams a skill is shared with
|
|
3244
|
+
*/
|
|
3245
|
+
const listSkillShares = (options) => (options.client ?? client).get({
|
|
3246
|
+
security: [{
|
|
3247
|
+
scheme: "bearer",
|
|
3248
|
+
type: "http"
|
|
3249
|
+
}, {
|
|
3250
|
+
scheme: "bearer",
|
|
3251
|
+
type: "http"
|
|
3252
|
+
}],
|
|
3253
|
+
url: "/skills/{skillId}/shares",
|
|
3254
|
+
...options
|
|
3255
|
+
});
|
|
3256
|
+
/**
|
|
3257
|
+
* Stop sharing a skill with a user or a team and return who it is still shared with
|
|
3258
|
+
*/
|
|
3259
|
+
const unshareSkill = (options) => (options.client ?? client).delete({
|
|
3260
|
+
security: [{
|
|
3261
|
+
scheme: "bearer",
|
|
3262
|
+
type: "http"
|
|
3263
|
+
}, {
|
|
3264
|
+
scheme: "bearer",
|
|
3265
|
+
type: "http"
|
|
3266
|
+
}],
|
|
3267
|
+
url: "/skills/{skillId}/shares/{memberType}/{memberId}",
|
|
3268
|
+
...options
|
|
3269
|
+
});
|
|
3270
|
+
/**
|
|
3271
|
+
* Share a skill with a user or a team, giving them read access whatever its visibility, and return who it is shared with
|
|
3272
|
+
*/
|
|
3273
|
+
const shareSkill = (options) => (options.client ?? client).put({
|
|
3274
|
+
security: [{
|
|
3275
|
+
scheme: "bearer",
|
|
3276
|
+
type: "http"
|
|
3277
|
+
}, {
|
|
3278
|
+
scheme: "bearer",
|
|
3279
|
+
type: "http"
|
|
3280
|
+
}],
|
|
3281
|
+
url: "/skills/{skillId}/shares/{memberType}/{memberId}",
|
|
3282
|
+
...options
|
|
3283
|
+
});
|
|
3284
|
+
|
|
3285
|
+
//#endregion
|
|
3286
|
+
Object.defineProperty(exports, 'callMcpServerTool', {
|
|
3287
|
+
enumerable: true,
|
|
3288
|
+
get: function () {
|
|
3289
|
+
return callMcpServerTool;
|
|
3290
|
+
}
|
|
3291
|
+
});
|
|
3292
|
+
Object.defineProperty(exports, 'client', {
|
|
3293
|
+
enumerable: true,
|
|
3294
|
+
get: function () {
|
|
3295
|
+
return client;
|
|
3296
|
+
}
|
|
3297
|
+
});
|
|
3298
|
+
Object.defineProperty(exports, 'copyMcpServerCredentials', {
|
|
3299
|
+
enumerable: true,
|
|
3300
|
+
get: function () {
|
|
3301
|
+
return copyMcpServerCredentials;
|
|
3302
|
+
}
|
|
3303
|
+
});
|
|
3304
|
+
Object.defineProperty(exports, 'createArtifact', {
|
|
3305
|
+
enumerable: true,
|
|
3306
|
+
get: function () {
|
|
3307
|
+
return createArtifact;
|
|
3308
|
+
}
|
|
3309
|
+
});
|
|
3310
|
+
Object.defineProperty(exports, 'createMcpServer', {
|
|
3311
|
+
enumerable: true,
|
|
3312
|
+
get: function () {
|
|
3313
|
+
return createMcpServer;
|
|
3314
|
+
}
|
|
3315
|
+
});
|
|
3316
|
+
Object.defineProperty(exports, 'createMcpServerFile', {
|
|
3317
|
+
enumerable: true,
|
|
3318
|
+
get: function () {
|
|
3319
|
+
return createMcpServerFile;
|
|
3320
|
+
}
|
|
3321
|
+
});
|
|
3322
|
+
Object.defineProperty(exports, 'createProfile', {
|
|
3323
|
+
enumerable: true,
|
|
3324
|
+
get: function () {
|
|
3325
|
+
return createProfile;
|
|
3326
|
+
}
|
|
3327
|
+
});
|
|
3328
|
+
Object.defineProperty(exports, 'createProfileClaimMapping', {
|
|
3329
|
+
enumerable: true,
|
|
3330
|
+
get: function () {
|
|
3331
|
+
return createProfileClaimMapping;
|
|
3332
|
+
}
|
|
3333
|
+
});
|
|
3334
|
+
Object.defineProperty(exports, 'createProfileMaintainer', {
|
|
3335
|
+
enumerable: true,
|
|
3336
|
+
get: function () {
|
|
3337
|
+
return createProfileMaintainer;
|
|
3338
|
+
}
|
|
3339
|
+
});
|
|
3340
|
+
Object.defineProperty(exports, 'createSandbox', {
|
|
3341
|
+
enumerable: true,
|
|
3342
|
+
get: function () {
|
|
3343
|
+
return createSandbox;
|
|
3344
|
+
}
|
|
3345
|
+
});
|
|
3346
|
+
Object.defineProperty(exports, 'createSandboxReadFile', {
|
|
3347
|
+
enumerable: true,
|
|
3348
|
+
get: function () {
|
|
3349
|
+
return createSandboxReadFile;
|
|
3350
|
+
}
|
|
3351
|
+
});
|
|
3352
|
+
Object.defineProperty(exports, 'createSandboxSshSession', {
|
|
3353
|
+
enumerable: true,
|
|
3354
|
+
get: function () {
|
|
3355
|
+
return createSandboxSshSession;
|
|
3356
|
+
}
|
|
3357
|
+
});
|
|
3358
|
+
Object.defineProperty(exports, 'createSandboxWriteFile', {
|
|
3359
|
+
enumerable: true,
|
|
3360
|
+
get: function () {
|
|
3361
|
+
return createSandboxWriteFile;
|
|
3362
|
+
}
|
|
3363
|
+
});
|
|
3364
|
+
Object.defineProperty(exports, 'createScimConfigToken', {
|
|
3365
|
+
enumerable: true,
|
|
3366
|
+
get: function () {
|
|
3367
|
+
return createScimConfigToken;
|
|
3368
|
+
}
|
|
3369
|
+
});
|
|
3370
|
+
Object.defineProperty(exports, 'createSecretStore', {
|
|
3371
|
+
enumerable: true,
|
|
3372
|
+
get: function () {
|
|
3373
|
+
return createSecretStore;
|
|
3374
|
+
}
|
|
3375
|
+
});
|
|
3376
|
+
Object.defineProperty(exports, 'createSecretStoreMapping', {
|
|
3377
|
+
enumerable: true,
|
|
3378
|
+
get: function () {
|
|
3379
|
+
return createSecretStoreMapping;
|
|
3380
|
+
}
|
|
3381
|
+
});
|
|
3382
|
+
Object.defineProperty(exports, 'createSiemDestination', {
|
|
3383
|
+
enumerable: true,
|
|
3384
|
+
get: function () {
|
|
3385
|
+
return createSiemDestination;
|
|
3386
|
+
}
|
|
3387
|
+
});
|
|
3388
|
+
Object.defineProperty(exports, 'createSkill', {
|
|
3389
|
+
enumerable: true,
|
|
3390
|
+
get: function () {
|
|
3391
|
+
return createSkill;
|
|
3392
|
+
}
|
|
3393
|
+
});
|
|
3394
|
+
Object.defineProperty(exports, 'createTeam', {
|
|
3395
|
+
enumerable: true,
|
|
3396
|
+
get: function () {
|
|
3397
|
+
return createTeam;
|
|
3398
|
+
}
|
|
3399
|
+
});
|
|
3400
|
+
Object.defineProperty(exports, 'createTeamClaimMapping', {
|
|
3401
|
+
enumerable: true,
|
|
3402
|
+
get: function () {
|
|
3403
|
+
return createTeamClaimMapping;
|
|
3404
|
+
}
|
|
3405
|
+
});
|
|
3406
|
+
Object.defineProperty(exports, 'createTeamInvitation', {
|
|
3407
|
+
enumerable: true,
|
|
3408
|
+
get: function () {
|
|
3409
|
+
return createTeamInvitation;
|
|
3410
|
+
}
|
|
3411
|
+
});
|
|
3412
|
+
Object.defineProperty(exports, 'createTeamMember', {
|
|
3413
|
+
enumerable: true,
|
|
3414
|
+
get: function () {
|
|
3415
|
+
return createTeamMember;
|
|
3416
|
+
}
|
|
3417
|
+
});
|
|
3418
|
+
Object.defineProperty(exports, 'createTeamProfile', {
|
|
3419
|
+
enumerable: true,
|
|
3420
|
+
get: function () {
|
|
3421
|
+
return createTeamProfile;
|
|
3422
|
+
}
|
|
3423
|
+
});
|
|
3424
|
+
Object.defineProperty(exports, 'createUser', {
|
|
3425
|
+
enumerable: true,
|
|
3426
|
+
get: function () {
|
|
3427
|
+
return createUser;
|
|
3428
|
+
}
|
|
3429
|
+
});
|
|
3430
|
+
Object.defineProperty(exports, 'createUserPersonalAccessToken', {
|
|
3431
|
+
enumerable: true,
|
|
3432
|
+
get: function () {
|
|
3433
|
+
return createUserPersonalAccessToken;
|
|
3434
|
+
}
|
|
3435
|
+
});
|
|
3436
|
+
Object.defineProperty(exports, 'createUserProfile', {
|
|
3437
|
+
enumerable: true,
|
|
3438
|
+
get: function () {
|
|
3439
|
+
return createUserProfile;
|
|
3440
|
+
}
|
|
3441
|
+
});
|
|
3442
|
+
Object.defineProperty(exports, 'deleteArtifact', {
|
|
3443
|
+
enumerable: true,
|
|
3444
|
+
get: function () {
|
|
3445
|
+
return deleteArtifact;
|
|
3446
|
+
}
|
|
3447
|
+
});
|
|
3448
|
+
Object.defineProperty(exports, 'deleteConnectedClient', {
|
|
3449
|
+
enumerable: true,
|
|
3450
|
+
get: function () {
|
|
3451
|
+
return deleteConnectedClient;
|
|
3452
|
+
}
|
|
3453
|
+
});
|
|
3454
|
+
Object.defineProperty(exports, 'deleteMcpServer', {
|
|
3455
|
+
enumerable: true,
|
|
3456
|
+
get: function () {
|
|
3457
|
+
return deleteMcpServer;
|
|
3458
|
+
}
|
|
3459
|
+
});
|
|
3460
|
+
Object.defineProperty(exports, 'deleteMcpServerCredential', {
|
|
3461
|
+
enumerable: true,
|
|
3462
|
+
get: function () {
|
|
3463
|
+
return deleteMcpServerCredential;
|
|
3464
|
+
}
|
|
3465
|
+
});
|
|
3466
|
+
Object.defineProperty(exports, 'deleteMcpServerCredentialsProfile', {
|
|
3467
|
+
enumerable: true,
|
|
3468
|
+
get: function () {
|
|
3469
|
+
return deleteMcpServerCredentialsProfile;
|
|
3470
|
+
}
|
|
3471
|
+
});
|
|
3472
|
+
Object.defineProperty(exports, 'deleteMcpServerCredentialsServer', {
|
|
3473
|
+
enumerable: true,
|
|
3474
|
+
get: function () {
|
|
3475
|
+
return deleteMcpServerCredentialsServer;
|
|
3476
|
+
}
|
|
3477
|
+
});
|
|
3478
|
+
Object.defineProperty(exports, 'deleteMcpServerCredentialsUser', {
|
|
3479
|
+
enumerable: true,
|
|
3480
|
+
get: function () {
|
|
3481
|
+
return deleteMcpServerCredentialsUser;
|
|
3482
|
+
}
|
|
3483
|
+
});
|
|
3484
|
+
Object.defineProperty(exports, 'deleteMcpServerFile', {
|
|
3485
|
+
enumerable: true,
|
|
3486
|
+
get: function () {
|
|
3487
|
+
return deleteMcpServerFile;
|
|
3488
|
+
}
|
|
3489
|
+
});
|
|
3490
|
+
Object.defineProperty(exports, 'deleteMcpServerMember', {
|
|
3491
|
+
enumerable: true,
|
|
3492
|
+
get: function () {
|
|
3493
|
+
return deleteMcpServerMember;
|
|
3494
|
+
}
|
|
3495
|
+
});
|
|
3496
|
+
Object.defineProperty(exports, 'deleteProfile', {
|
|
3497
|
+
enumerable: true,
|
|
3498
|
+
get: function () {
|
|
3499
|
+
return deleteProfile;
|
|
3500
|
+
}
|
|
3501
|
+
});
|
|
3502
|
+
Object.defineProperty(exports, 'deleteProfileClaimMapping', {
|
|
3503
|
+
enumerable: true,
|
|
3504
|
+
get: function () {
|
|
3505
|
+
return deleteProfileClaimMapping;
|
|
3506
|
+
}
|
|
3507
|
+
});
|
|
3508
|
+
Object.defineProperty(exports, 'deleteProfileMaintainer', {
|
|
3509
|
+
enumerable: true,
|
|
3510
|
+
get: function () {
|
|
3511
|
+
return deleteProfileMaintainer;
|
|
3512
|
+
}
|
|
3513
|
+
});
|
|
3514
|
+
Object.defineProperty(exports, 'deleteSandbox', {
|
|
3515
|
+
enumerable: true,
|
|
3516
|
+
get: function () {
|
|
3517
|
+
return deleteSandbox;
|
|
3518
|
+
}
|
|
3519
|
+
});
|
|
3520
|
+
Object.defineProperty(exports, 'deleteScimConfigToken', {
|
|
3521
|
+
enumerable: true,
|
|
3522
|
+
get: function () {
|
|
3523
|
+
return deleteScimConfigToken;
|
|
3524
|
+
}
|
|
3525
|
+
});
|
|
3526
|
+
Object.defineProperty(exports, 'deleteSecretStore', {
|
|
3527
|
+
enumerable: true,
|
|
3528
|
+
get: function () {
|
|
3529
|
+
return deleteSecretStore;
|
|
3530
|
+
}
|
|
3531
|
+
});
|
|
3532
|
+
Object.defineProperty(exports, 'deleteSecretStoreMapping', {
|
|
3533
|
+
enumerable: true,
|
|
3534
|
+
get: function () {
|
|
3535
|
+
return deleteSecretStoreMapping;
|
|
3536
|
+
}
|
|
3537
|
+
});
|
|
3538
|
+
Object.defineProperty(exports, 'deleteSiemDestination', {
|
|
3539
|
+
enumerable: true,
|
|
3540
|
+
get: function () {
|
|
3541
|
+
return deleteSiemDestination;
|
|
3542
|
+
}
|
|
3543
|
+
});
|
|
3544
|
+
Object.defineProperty(exports, 'deleteSkill', {
|
|
3545
|
+
enumerable: true,
|
|
3546
|
+
get: function () {
|
|
3547
|
+
return deleteSkill;
|
|
3548
|
+
}
|
|
3549
|
+
});
|
|
3550
|
+
Object.defineProperty(exports, 'deleteTeam', {
|
|
3551
|
+
enumerable: true,
|
|
3552
|
+
get: function () {
|
|
3553
|
+
return deleteTeam;
|
|
3554
|
+
}
|
|
3555
|
+
});
|
|
3556
|
+
Object.defineProperty(exports, 'deleteTeamClaimMapping', {
|
|
3557
|
+
enumerable: true,
|
|
3558
|
+
get: function () {
|
|
3559
|
+
return deleteTeamClaimMapping;
|
|
3560
|
+
}
|
|
3561
|
+
});
|
|
3562
|
+
Object.defineProperty(exports, 'deleteTeamInvitation', {
|
|
3563
|
+
enumerable: true,
|
|
3564
|
+
get: function () {
|
|
3565
|
+
return deleteTeamInvitation;
|
|
3566
|
+
}
|
|
3567
|
+
});
|
|
3568
|
+
Object.defineProperty(exports, 'deleteTeamMember', {
|
|
3569
|
+
enumerable: true,
|
|
3570
|
+
get: function () {
|
|
3571
|
+
return deleteTeamMember;
|
|
3572
|
+
}
|
|
3573
|
+
});
|
|
3574
|
+
Object.defineProperty(exports, 'deleteTeamProfile', {
|
|
3575
|
+
enumerable: true,
|
|
3576
|
+
get: function () {
|
|
3577
|
+
return deleteTeamProfile;
|
|
3578
|
+
}
|
|
3579
|
+
});
|
|
3580
|
+
Object.defineProperty(exports, 'deleteUser', {
|
|
3581
|
+
enumerable: true,
|
|
3582
|
+
get: function () {
|
|
3583
|
+
return deleteUser;
|
|
3584
|
+
}
|
|
3585
|
+
});
|
|
3586
|
+
Object.defineProperty(exports, 'deleteUserPersonalAccessToken', {
|
|
3587
|
+
enumerable: true,
|
|
3588
|
+
get: function () {
|
|
3589
|
+
return deleteUserPersonalAccessToken;
|
|
3590
|
+
}
|
|
3591
|
+
});
|
|
3592
|
+
Object.defineProperty(exports, 'deleteUserProfile', {
|
|
3593
|
+
enumerable: true,
|
|
3594
|
+
get: function () {
|
|
3595
|
+
return deleteUserProfile;
|
|
3596
|
+
}
|
|
3597
|
+
});
|
|
3598
|
+
Object.defineProperty(exports, 'discoverMcpServerOauth', {
|
|
3599
|
+
enumerable: true,
|
|
3600
|
+
get: function () {
|
|
3601
|
+
return discoverMcpServerOauth;
|
|
3602
|
+
}
|
|
3603
|
+
});
|
|
3604
|
+
Object.defineProperty(exports, 'execSandbox', {
|
|
3605
|
+
enumerable: true,
|
|
3606
|
+
get: function () {
|
|
3607
|
+
return execSandbox;
|
|
3608
|
+
}
|
|
3609
|
+
});
|
|
3610
|
+
Object.defineProperty(exports, 'getArtifact', {
|
|
3611
|
+
enumerable: true,
|
|
3612
|
+
get: function () {
|
|
3613
|
+
return getArtifact;
|
|
3614
|
+
}
|
|
3615
|
+
});
|
|
3616
|
+
Object.defineProperty(exports, 'getArtifactContent', {
|
|
3617
|
+
enumerable: true,
|
|
3618
|
+
get: function () {
|
|
3619
|
+
return getArtifactContent;
|
|
3620
|
+
}
|
|
3621
|
+
});
|
|
3622
|
+
Object.defineProperty(exports, 'getAuditLog', {
|
|
3623
|
+
enumerable: true,
|
|
3624
|
+
get: function () {
|
|
3625
|
+
return getAuditLog;
|
|
3626
|
+
}
|
|
3627
|
+
});
|
|
3628
|
+
Object.defineProperty(exports, 'getAuditLogsSummary', {
|
|
3629
|
+
enumerable: true,
|
|
3630
|
+
get: function () {
|
|
3631
|
+
return getAuditLogsSummary;
|
|
3632
|
+
}
|
|
3633
|
+
});
|
|
3634
|
+
Object.defineProperty(exports, 'getAuthMe', {
|
|
3635
|
+
enumerable: true,
|
|
3636
|
+
get: function () {
|
|
3637
|
+
return getAuthMe;
|
|
3638
|
+
}
|
|
3639
|
+
});
|
|
3640
|
+
Object.defineProperty(exports, 'getDeploymentsStatus', {
|
|
3641
|
+
enumerable: true,
|
|
3642
|
+
get: function () {
|
|
3643
|
+
return getDeploymentsStatus;
|
|
3644
|
+
}
|
|
3645
|
+
});
|
|
3646
|
+
Object.defineProperty(exports, 'getMcpServer', {
|
|
3647
|
+
enumerable: true,
|
|
3648
|
+
get: function () {
|
|
3649
|
+
return getMcpServer;
|
|
3650
|
+
}
|
|
3651
|
+
});
|
|
3652
|
+
Object.defineProperty(exports, 'getMcpServerCredentialsAuthorizeUrl', {
|
|
3653
|
+
enumerable: true,
|
|
3654
|
+
get: function () {
|
|
3655
|
+
return getMcpServerCredentialsAuthorizeUrl;
|
|
3656
|
+
}
|
|
3657
|
+
});
|
|
3658
|
+
Object.defineProperty(exports, 'getMcpServerCredentialsProfile', {
|
|
3659
|
+
enumerable: true,
|
|
3660
|
+
get: function () {
|
|
3661
|
+
return getMcpServerCredentialsProfile;
|
|
3662
|
+
}
|
|
3663
|
+
});
|
|
3664
|
+
Object.defineProperty(exports, 'getMcpServerCredentialsServer', {
|
|
3665
|
+
enumerable: true,
|
|
3666
|
+
get: function () {
|
|
3667
|
+
return getMcpServerCredentialsServer;
|
|
3668
|
+
}
|
|
3669
|
+
});
|
|
3670
|
+
Object.defineProperty(exports, 'getMcpServerCredentialsToken', {
|
|
3671
|
+
enumerable: true,
|
|
3672
|
+
get: function () {
|
|
3673
|
+
return getMcpServerCredentialsToken;
|
|
3674
|
+
}
|
|
3675
|
+
});
|
|
3676
|
+
Object.defineProperty(exports, 'getMcpServerCredentialsUser', {
|
|
3677
|
+
enumerable: true,
|
|
3678
|
+
get: function () {
|
|
3679
|
+
return getMcpServerCredentialsUser;
|
|
3680
|
+
}
|
|
3681
|
+
});
|
|
3682
|
+
Object.defineProperty(exports, 'getMcpServerFile', {
|
|
3683
|
+
enumerable: true,
|
|
3684
|
+
get: function () {
|
|
3685
|
+
return getMcpServerFile;
|
|
3686
|
+
}
|
|
3687
|
+
});
|
|
3688
|
+
Object.defineProperty(exports, 'getMcpServerRunningStatus', {
|
|
3689
|
+
enumerable: true,
|
|
3690
|
+
get: function () {
|
|
3691
|
+
return getMcpServerRunningStatus;
|
|
3692
|
+
}
|
|
3693
|
+
});
|
|
3694
|
+
Object.defineProperty(exports, 'getMcpServerSourceCode', {
|
|
3695
|
+
enumerable: true,
|
|
3696
|
+
get: function () {
|
|
3697
|
+
return getMcpServerSourceCode;
|
|
3698
|
+
}
|
|
3699
|
+
});
|
|
3700
|
+
Object.defineProperty(exports, 'getMcpServerTool', {
|
|
3701
|
+
enumerable: true,
|
|
3702
|
+
get: function () {
|
|
3703
|
+
return getMcpServerTool;
|
|
3704
|
+
}
|
|
3705
|
+
});
|
|
3706
|
+
Object.defineProperty(exports, 'getMcpServersAccessPreview', {
|
|
3707
|
+
enumerable: true,
|
|
3708
|
+
get: function () {
|
|
3709
|
+
return getMcpServersAccessPreview;
|
|
3710
|
+
}
|
|
3711
|
+
});
|
|
3712
|
+
Object.defineProperty(exports, 'getProfile', {
|
|
3713
|
+
enumerable: true,
|
|
3714
|
+
get: function () {
|
|
3715
|
+
return getProfile;
|
|
3716
|
+
}
|
|
3717
|
+
});
|
|
3718
|
+
Object.defineProperty(exports, 'getSandbox', {
|
|
3719
|
+
enumerable: true,
|
|
3720
|
+
get: function () {
|
|
3721
|
+
return getSandbox;
|
|
3722
|
+
}
|
|
3723
|
+
});
|
|
3724
|
+
Object.defineProperty(exports, 'getSandboxAuditLog', {
|
|
3725
|
+
enumerable: true,
|
|
3726
|
+
get: function () {
|
|
3727
|
+
return getSandboxAuditLog;
|
|
3728
|
+
}
|
|
3729
|
+
});
|
|
3730
|
+
Object.defineProperty(exports, 'getScimConfigTokenSecret', {
|
|
3731
|
+
enumerable: true,
|
|
3732
|
+
get: function () {
|
|
3733
|
+
return getScimConfigTokenSecret;
|
|
3734
|
+
}
|
|
3735
|
+
});
|
|
3736
|
+
Object.defineProperty(exports, 'getSecretStore', {
|
|
3737
|
+
enumerable: true,
|
|
3738
|
+
get: function () {
|
|
3739
|
+
return getSecretStore;
|
|
3740
|
+
}
|
|
3741
|
+
});
|
|
3742
|
+
Object.defineProperty(exports, 'getSiemDestination', {
|
|
3743
|
+
enumerable: true,
|
|
3744
|
+
get: function () {
|
|
3745
|
+
return getSiemDestination;
|
|
3746
|
+
}
|
|
3747
|
+
});
|
|
3748
|
+
Object.defineProperty(exports, 'getSiemDestinationSecret', {
|
|
3749
|
+
enumerable: true,
|
|
3750
|
+
get: function () {
|
|
3751
|
+
return getSiemDestinationSecret;
|
|
3752
|
+
}
|
|
3753
|
+
});
|
|
3754
|
+
Object.defineProperty(exports, 'getSkill', {
|
|
3755
|
+
enumerable: true,
|
|
3756
|
+
get: function () {
|
|
3757
|
+
return getSkill;
|
|
3758
|
+
}
|
|
3759
|
+
});
|
|
3760
|
+
Object.defineProperty(exports, 'getTeam', {
|
|
3761
|
+
enumerable: true,
|
|
3762
|
+
get: function () {
|
|
3763
|
+
return getTeam;
|
|
3764
|
+
}
|
|
3765
|
+
});
|
|
3766
|
+
Object.defineProperty(exports, 'getTenant', {
|
|
3767
|
+
enumerable: true,
|
|
3768
|
+
get: function () {
|
|
3769
|
+
return getTenant;
|
|
3770
|
+
}
|
|
3771
|
+
});
|
|
3772
|
+
Object.defineProperty(exports, 'getTenantSubscription', {
|
|
3773
|
+
enumerable: true,
|
|
3774
|
+
get: function () {
|
|
3775
|
+
return getTenantSubscription;
|
|
3776
|
+
}
|
|
3777
|
+
});
|
|
3778
|
+
Object.defineProperty(exports, 'getToolsSearch', {
|
|
3779
|
+
enumerable: true,
|
|
3780
|
+
get: function () {
|
|
3781
|
+
return getToolsSearch;
|
|
3782
|
+
}
|
|
3783
|
+
});
|
|
3784
|
+
Object.defineProperty(exports, 'getUser', {
|
|
3785
|
+
enumerable: true,
|
|
3786
|
+
get: function () {
|
|
3787
|
+
return getUser;
|
|
3788
|
+
}
|
|
3789
|
+
});
|
|
3790
|
+
Object.defineProperty(exports, 'getUsersMe', {
|
|
3791
|
+
enumerable: true,
|
|
3792
|
+
get: function () {
|
|
3793
|
+
return getUsersMe;
|
|
3794
|
+
}
|
|
3795
|
+
});
|
|
3796
|
+
Object.defineProperty(exports, 'installPredefinedBuiltInServer', {
|
|
3797
|
+
enumerable: true,
|
|
3798
|
+
get: function () {
|
|
3799
|
+
return installPredefinedBuiltInServer;
|
|
3800
|
+
}
|
|
3801
|
+
});
|
|
3802
|
+
Object.defineProperty(exports, 'listArtifactShares', {
|
|
3803
|
+
enumerable: true,
|
|
3804
|
+
get: function () {
|
|
3805
|
+
return listArtifactShares;
|
|
3806
|
+
}
|
|
3807
|
+
});
|
|
3808
|
+
Object.defineProperty(exports, 'listArtifacts', {
|
|
3809
|
+
enumerable: true,
|
|
3810
|
+
get: function () {
|
|
3811
|
+
return listArtifacts;
|
|
3812
|
+
}
|
|
3813
|
+
});
|
|
3814
|
+
Object.defineProperty(exports, 'listAuditLogs', {
|
|
3815
|
+
enumerable: true,
|
|
3816
|
+
get: function () {
|
|
3817
|
+
return listAuditLogs;
|
|
3818
|
+
}
|
|
3819
|
+
});
|
|
3820
|
+
Object.defineProperty(exports, 'listAuditLogsFilterOptions', {
|
|
3821
|
+
enumerable: true,
|
|
3822
|
+
get: function () {
|
|
3823
|
+
return listAuditLogsFilterOptions;
|
|
3824
|
+
}
|
|
3825
|
+
});
|
|
3826
|
+
Object.defineProperty(exports, 'listConnectedClients', {
|
|
3827
|
+
enumerable: true,
|
|
3828
|
+
get: function () {
|
|
3829
|
+
return listConnectedClients;
|
|
3830
|
+
}
|
|
3831
|
+
});
|
|
3832
|
+
Object.defineProperty(exports, 'listDeploymentsDeploymentLogs', {
|
|
3833
|
+
enumerable: true,
|
|
3834
|
+
get: function () {
|
|
3835
|
+
return listDeploymentsDeploymentLogs;
|
|
3836
|
+
}
|
|
3837
|
+
});
|
|
3838
|
+
Object.defineProperty(exports, 'listDeploymentsLogs', {
|
|
3839
|
+
enumerable: true,
|
|
3840
|
+
get: function () {
|
|
3841
|
+
return listDeploymentsLogs;
|
|
3842
|
+
}
|
|
3843
|
+
});
|
|
3844
|
+
Object.defineProperty(exports, 'listDeploymentsMetrics', {
|
|
3845
|
+
enumerable: true,
|
|
3846
|
+
get: function () {
|
|
3847
|
+
return listDeploymentsMetrics;
|
|
3848
|
+
}
|
|
3849
|
+
});
|
|
3850
|
+
Object.defineProperty(exports, 'listMcpServerCredentialsProfileApikeys', {
|
|
3851
|
+
enumerable: true,
|
|
3852
|
+
get: function () {
|
|
3853
|
+
return listMcpServerCredentialsProfileApikeys;
|
|
3854
|
+
}
|
|
3855
|
+
});
|
|
3856
|
+
Object.defineProperty(exports, 'listMcpServerCredentialsServerApikeys', {
|
|
3857
|
+
enumerable: true,
|
|
3858
|
+
get: function () {
|
|
3859
|
+
return listMcpServerCredentialsServerApikeys;
|
|
3860
|
+
}
|
|
3861
|
+
});
|
|
3862
|
+
Object.defineProperty(exports, 'listMcpServerCredentialsUserApikeys', {
|
|
3863
|
+
enumerable: true,
|
|
3864
|
+
get: function () {
|
|
3865
|
+
return listMcpServerCredentialsUserApikeys;
|
|
3866
|
+
}
|
|
3867
|
+
});
|
|
3868
|
+
Object.defineProperty(exports, 'listMcpServerFiles', {
|
|
3869
|
+
enumerable: true,
|
|
3870
|
+
get: function () {
|
|
3871
|
+
return listMcpServerFiles;
|
|
3872
|
+
}
|
|
3873
|
+
});
|
|
3874
|
+
Object.defineProperty(exports, 'listMcpServerMembers', {
|
|
3875
|
+
enumerable: true,
|
|
3876
|
+
get: function () {
|
|
3877
|
+
return listMcpServerMembers;
|
|
3878
|
+
}
|
|
3879
|
+
});
|
|
3880
|
+
Object.defineProperty(exports, 'listMcpServerTools', {
|
|
3881
|
+
enumerable: true,
|
|
3882
|
+
get: function () {
|
|
3883
|
+
return listMcpServerTools;
|
|
3884
|
+
}
|
|
3885
|
+
});
|
|
3886
|
+
Object.defineProperty(exports, 'listMcpServers', {
|
|
3887
|
+
enumerable: true,
|
|
3888
|
+
get: function () {
|
|
3889
|
+
return listMcpServers;
|
|
3890
|
+
}
|
|
3891
|
+
});
|
|
3892
|
+
Object.defineProperty(exports, 'listProfileClaimMappings', {
|
|
3893
|
+
enumerable: true,
|
|
3894
|
+
get: function () {
|
|
3895
|
+
return listProfileClaimMappings;
|
|
3896
|
+
}
|
|
3897
|
+
});
|
|
3898
|
+
Object.defineProperty(exports, 'listProfileDirectAssignments', {
|
|
3899
|
+
enumerable: true,
|
|
3900
|
+
get: function () {
|
|
3901
|
+
return listProfileDirectAssignments;
|
|
3902
|
+
}
|
|
3903
|
+
});
|
|
3904
|
+
Object.defineProperty(exports, 'listProfileMaintainers', {
|
|
3905
|
+
enumerable: true,
|
|
3906
|
+
get: function () {
|
|
3907
|
+
return listProfileMaintainers;
|
|
3908
|
+
}
|
|
3909
|
+
});
|
|
3910
|
+
Object.defineProperty(exports, 'listProfileTools', {
|
|
3911
|
+
enumerable: true,
|
|
3912
|
+
get: function () {
|
|
3913
|
+
return listProfileTools;
|
|
3914
|
+
}
|
|
3915
|
+
});
|
|
3916
|
+
Object.defineProperty(exports, 'listProfiles', {
|
|
3917
|
+
enumerable: true,
|
|
3918
|
+
get: function () {
|
|
3919
|
+
return listProfiles;
|
|
3920
|
+
}
|
|
3921
|
+
});
|
|
3922
|
+
Object.defineProperty(exports, 'listSandboxAuditLogs', {
|
|
3923
|
+
enumerable: true,
|
|
3924
|
+
get: function () {
|
|
3925
|
+
return listSandboxAuditLogs;
|
|
3926
|
+
}
|
|
3927
|
+
});
|
|
3928
|
+
Object.defineProperty(exports, 'listSandboxes', {
|
|
3929
|
+
enumerable: true,
|
|
3930
|
+
get: function () {
|
|
3931
|
+
return listSandboxes;
|
|
3932
|
+
}
|
|
3933
|
+
});
|
|
3934
|
+
Object.defineProperty(exports, 'listScimConfigTokens', {
|
|
3935
|
+
enumerable: true,
|
|
3936
|
+
get: function () {
|
|
3937
|
+
return listScimConfigTokens;
|
|
3938
|
+
}
|
|
3939
|
+
});
|
|
3940
|
+
Object.defineProperty(exports, 'listSecretStoreMappings', {
|
|
3941
|
+
enumerable: true,
|
|
3942
|
+
get: function () {
|
|
3943
|
+
return listSecretStoreMappings;
|
|
3944
|
+
}
|
|
3945
|
+
});
|
|
3946
|
+
Object.defineProperty(exports, 'listSecretStores', {
|
|
3947
|
+
enumerable: true,
|
|
3948
|
+
get: function () {
|
|
3949
|
+
return listSecretStores;
|
|
3950
|
+
}
|
|
3951
|
+
});
|
|
3952
|
+
Object.defineProperty(exports, 'listSkillShares', {
|
|
3953
|
+
enumerable: true,
|
|
3954
|
+
get: function () {
|
|
3955
|
+
return listSkillShares;
|
|
3956
|
+
}
|
|
3957
|
+
});
|
|
3958
|
+
Object.defineProperty(exports, 'listSkills', {
|
|
3959
|
+
enumerable: true,
|
|
3960
|
+
get: function () {
|
|
3961
|
+
return listSkills;
|
|
3962
|
+
}
|
|
3963
|
+
});
|
|
3964
|
+
Object.defineProperty(exports, 'listTeamClaimMappings', {
|
|
3965
|
+
enumerable: true,
|
|
3966
|
+
get: function () {
|
|
3967
|
+
return listTeamClaimMappings;
|
|
3968
|
+
}
|
|
3969
|
+
});
|
|
3970
|
+
Object.defineProperty(exports, 'listTeamInvitations', {
|
|
3971
|
+
enumerable: true,
|
|
3972
|
+
get: function () {
|
|
3973
|
+
return listTeamInvitations;
|
|
3974
|
+
}
|
|
3975
|
+
});
|
|
3976
|
+
Object.defineProperty(exports, 'listTeamMembers', {
|
|
3977
|
+
enumerable: true,
|
|
3978
|
+
get: function () {
|
|
3979
|
+
return listTeamMembers;
|
|
3980
|
+
}
|
|
3981
|
+
});
|
|
3982
|
+
Object.defineProperty(exports, 'listTeamProfiles', {
|
|
3983
|
+
enumerable: true,
|
|
3984
|
+
get: function () {
|
|
3985
|
+
return listTeamProfiles;
|
|
3986
|
+
}
|
|
3987
|
+
});
|
|
3988
|
+
Object.defineProperty(exports, 'listTeamServers', {
|
|
3989
|
+
enumerable: true,
|
|
3990
|
+
get: function () {
|
|
3991
|
+
return listTeamServers;
|
|
3992
|
+
}
|
|
3993
|
+
});
|
|
3994
|
+
Object.defineProperty(exports, 'listTeams', {
|
|
3995
|
+
enumerable: true,
|
|
3996
|
+
get: function () {
|
|
3997
|
+
return listTeams;
|
|
3998
|
+
}
|
|
3999
|
+
});
|
|
4000
|
+
Object.defineProperty(exports, 'listTools', {
|
|
4001
|
+
enumerable: true,
|
|
4002
|
+
get: function () {
|
|
4003
|
+
return listTools;
|
|
4004
|
+
}
|
|
4005
|
+
});
|
|
4006
|
+
Object.defineProperty(exports, 'listUserPersonalAccessTokens', {
|
|
4007
|
+
enumerable: true,
|
|
4008
|
+
get: function () {
|
|
4009
|
+
return listUserPersonalAccessTokens;
|
|
4010
|
+
}
|
|
4011
|
+
});
|
|
4012
|
+
Object.defineProperty(exports, 'listUserProfiles', {
|
|
4013
|
+
enumerable: true,
|
|
4014
|
+
get: function () {
|
|
4015
|
+
return listUserProfiles;
|
|
4016
|
+
}
|
|
4017
|
+
});
|
|
4018
|
+
Object.defineProperty(exports, 'listUsers', {
|
|
4019
|
+
enumerable: true,
|
|
4020
|
+
get: function () {
|
|
4021
|
+
return listUsers;
|
|
4022
|
+
}
|
|
4023
|
+
});
|
|
4024
|
+
Object.defineProperty(exports, 'patchArtifact', {
|
|
4025
|
+
enumerable: true,
|
|
4026
|
+
get: function () {
|
|
4027
|
+
return patchArtifact;
|
|
4028
|
+
}
|
|
4029
|
+
});
|
|
4030
|
+
Object.defineProperty(exports, 'patchConnectedClient', {
|
|
4031
|
+
enumerable: true,
|
|
4032
|
+
get: function () {
|
|
4033
|
+
return patchConnectedClient;
|
|
4034
|
+
}
|
|
4035
|
+
});
|
|
4036
|
+
Object.defineProperty(exports, 'patchMcpServerTool', {
|
|
4037
|
+
enumerable: true,
|
|
4038
|
+
get: function () {
|
|
4039
|
+
return patchMcpServerTool;
|
|
4040
|
+
}
|
|
4041
|
+
});
|
|
4042
|
+
Object.defineProperty(exports, 'patchSecretStore', {
|
|
4043
|
+
enumerable: true,
|
|
4044
|
+
get: function () {
|
|
4045
|
+
return patchSecretStore;
|
|
4046
|
+
}
|
|
4047
|
+
});
|
|
4048
|
+
Object.defineProperty(exports, 'patchSecretStoreMapping', {
|
|
4049
|
+
enumerable: true,
|
|
4050
|
+
get: function () {
|
|
4051
|
+
return patchSecretStoreMapping;
|
|
4052
|
+
}
|
|
4053
|
+
});
|
|
4054
|
+
Object.defineProperty(exports, 'patchSiemDestination', {
|
|
4055
|
+
enumerable: true,
|
|
4056
|
+
get: function () {
|
|
4057
|
+
return patchSiemDestination;
|
|
4058
|
+
}
|
|
4059
|
+
});
|
|
4060
|
+
Object.defineProperty(exports, 'patchUserPersonalAccessToken', {
|
|
4061
|
+
enumerable: true,
|
|
4062
|
+
get: function () {
|
|
4063
|
+
return patchUserPersonalAccessToken;
|
|
4064
|
+
}
|
|
4065
|
+
});
|
|
4066
|
+
Object.defineProperty(exports, 'patchUserProfile', {
|
|
4067
|
+
enumerable: true,
|
|
4068
|
+
get: function () {
|
|
4069
|
+
return patchUserProfile;
|
|
4070
|
+
}
|
|
4071
|
+
});
|
|
4072
|
+
Object.defineProperty(exports, 'refreshTools', {
|
|
4073
|
+
enumerable: true,
|
|
4074
|
+
get: function () {
|
|
4075
|
+
return refreshTools;
|
|
4076
|
+
}
|
|
4077
|
+
});
|
|
4078
|
+
Object.defineProperty(exports, 'requestOwnEmailVerification', {
|
|
4079
|
+
enumerable: true,
|
|
4080
|
+
get: function () {
|
|
4081
|
+
return requestOwnEmailVerification;
|
|
4082
|
+
}
|
|
4083
|
+
});
|
|
4084
|
+
Object.defineProperty(exports, 'rotateSiemDestinationSecret', {
|
|
4085
|
+
enumerable: true,
|
|
4086
|
+
get: function () {
|
|
4087
|
+
return rotateSiemDestinationSecret;
|
|
4088
|
+
}
|
|
4089
|
+
});
|
|
4090
|
+
Object.defineProperty(exports, 'sdk_gen_exports', {
|
|
4091
|
+
enumerable: true,
|
|
4092
|
+
get: function () {
|
|
4093
|
+
return sdk_gen_exports;
|
|
4094
|
+
}
|
|
4095
|
+
});
|
|
4096
|
+
Object.defineProperty(exports, 'sendEmailVerificationCode', {
|
|
4097
|
+
enumerable: true,
|
|
4098
|
+
get: function () {
|
|
4099
|
+
return sendEmailVerificationCode;
|
|
4100
|
+
}
|
|
4101
|
+
});
|
|
4102
|
+
Object.defineProperty(exports, 'shareArtifact', {
|
|
4103
|
+
enumerable: true,
|
|
4104
|
+
get: function () {
|
|
4105
|
+
return shareArtifact;
|
|
4106
|
+
}
|
|
4107
|
+
});
|
|
4108
|
+
Object.defineProperty(exports, 'shareSkill', {
|
|
4109
|
+
enumerable: true,
|
|
4110
|
+
get: function () {
|
|
4111
|
+
return shareSkill;
|
|
4112
|
+
}
|
|
4113
|
+
});
|
|
4114
|
+
Object.defineProperty(exports, 'startMcpServer', {
|
|
4115
|
+
enumerable: true,
|
|
4116
|
+
get: function () {
|
|
4117
|
+
return startMcpServer;
|
|
4118
|
+
}
|
|
4119
|
+
});
|
|
4120
|
+
Object.defineProperty(exports, 'stopMcpServer', {
|
|
4121
|
+
enumerable: true,
|
|
4122
|
+
get: function () {
|
|
4123
|
+
return stopMcpServer;
|
|
4124
|
+
}
|
|
4125
|
+
});
|
|
4126
|
+
Object.defineProperty(exports, 'testMcpServerOpenapi', {
|
|
4127
|
+
enumerable: true,
|
|
4128
|
+
get: function () {
|
|
4129
|
+
return testMcpServerOpenapi;
|
|
4130
|
+
}
|
|
4131
|
+
});
|
|
4132
|
+
Object.defineProperty(exports, 'testSecretStore', {
|
|
4133
|
+
enumerable: true,
|
|
4134
|
+
get: function () {
|
|
4135
|
+
return testSecretStore;
|
|
4136
|
+
}
|
|
4137
|
+
});
|
|
4138
|
+
Object.defineProperty(exports, 'testSiemDestination', {
|
|
4139
|
+
enumerable: true,
|
|
4140
|
+
get: function () {
|
|
4141
|
+
return testSiemDestination;
|
|
4142
|
+
}
|
|
4143
|
+
});
|
|
4144
|
+
Object.defineProperty(exports, 'unshareArtifact', {
|
|
4145
|
+
enumerable: true,
|
|
4146
|
+
get: function () {
|
|
4147
|
+
return unshareArtifact;
|
|
4148
|
+
}
|
|
4149
|
+
});
|
|
4150
|
+
Object.defineProperty(exports, 'unshareSkill', {
|
|
4151
|
+
enumerable: true,
|
|
4152
|
+
get: function () {
|
|
4153
|
+
return unshareSkill;
|
|
4154
|
+
}
|
|
4155
|
+
});
|
|
4156
|
+
Object.defineProperty(exports, 'updateArtifact', {
|
|
4157
|
+
enumerable: true,
|
|
4158
|
+
get: function () {
|
|
4159
|
+
return updateArtifact;
|
|
4160
|
+
}
|
|
4161
|
+
});
|
|
4162
|
+
Object.defineProperty(exports, 'updateMcpServer', {
|
|
4163
|
+
enumerable: true,
|
|
4164
|
+
get: function () {
|
|
4165
|
+
return updateMcpServer;
|
|
4166
|
+
}
|
|
4167
|
+
});
|
|
4168
|
+
Object.defineProperty(exports, 'updateMcpServerAllToolsIsEnabled', {
|
|
4169
|
+
enumerable: true,
|
|
4170
|
+
get: function () {
|
|
4171
|
+
return updateMcpServerAllToolsIsEnabled;
|
|
4172
|
+
}
|
|
4173
|
+
});
|
|
4174
|
+
Object.defineProperty(exports, 'updateMcpServerCredentialsProfile', {
|
|
4175
|
+
enumerable: true,
|
|
4176
|
+
get: function () {
|
|
4177
|
+
return updateMcpServerCredentialsProfile;
|
|
4178
|
+
}
|
|
4179
|
+
});
|
|
4180
|
+
Object.defineProperty(exports, 'updateMcpServerCredentialsServer', {
|
|
4181
|
+
enumerable: true,
|
|
4182
|
+
get: function () {
|
|
4183
|
+
return updateMcpServerCredentialsServer;
|
|
4184
|
+
}
|
|
4185
|
+
});
|
|
4186
|
+
Object.defineProperty(exports, 'updateMcpServerCredentialsUser', {
|
|
4187
|
+
enumerable: true,
|
|
4188
|
+
get: function () {
|
|
4189
|
+
return updateMcpServerCredentialsUser;
|
|
4190
|
+
}
|
|
4191
|
+
});
|
|
4192
|
+
Object.defineProperty(exports, 'updateMcpServerFile', {
|
|
4193
|
+
enumerable: true,
|
|
4194
|
+
get: function () {
|
|
4195
|
+
return updateMcpServerFile;
|
|
4196
|
+
}
|
|
4197
|
+
});
|
|
4198
|
+
Object.defineProperty(exports, 'updateMcpServerFileName', {
|
|
4199
|
+
enumerable: true,
|
|
4200
|
+
get: function () {
|
|
4201
|
+
return updateMcpServerFileName;
|
|
4202
|
+
}
|
|
4203
|
+
});
|
|
4204
|
+
Object.defineProperty(exports, 'updateMcpServerIsEnabled', {
|
|
4205
|
+
enumerable: true,
|
|
4206
|
+
get: function () {
|
|
4207
|
+
return updateMcpServerIsEnabled;
|
|
4208
|
+
}
|
|
4209
|
+
});
|
|
4210
|
+
Object.defineProperty(exports, 'updateMcpServerMember', {
|
|
4211
|
+
enumerable: true,
|
|
4212
|
+
get: function () {
|
|
4213
|
+
return updateMcpServerMember;
|
|
4214
|
+
}
|
|
4215
|
+
});
|
|
4216
|
+
Object.defineProperty(exports, 'updateMcpServerSourceCode', {
|
|
4217
|
+
enumerable: true,
|
|
4218
|
+
get: function () {
|
|
4219
|
+
return updateMcpServerSourceCode;
|
|
4220
|
+
}
|
|
4221
|
+
});
|
|
4222
|
+
Object.defineProperty(exports, 'updateMcpServerToolIsEnabled', {
|
|
4223
|
+
enumerable: true,
|
|
4224
|
+
get: function () {
|
|
4225
|
+
return updateMcpServerToolIsEnabled;
|
|
4226
|
+
}
|
|
4227
|
+
});
|
|
4228
|
+
Object.defineProperty(exports, 'updateProfile', {
|
|
4229
|
+
enumerable: true,
|
|
4230
|
+
get: function () {
|
|
4231
|
+
return updateProfile;
|
|
4232
|
+
}
|
|
4233
|
+
});
|
|
4234
|
+
Object.defineProperty(exports, 'updateProfileServerTools', {
|
|
4235
|
+
enumerable: true,
|
|
4236
|
+
get: function () {
|
|
4237
|
+
return updateProfileServerTools;
|
|
4238
|
+
}
|
|
4239
|
+
});
|
|
4240
|
+
Object.defineProperty(exports, 'updateSkill', {
|
|
4241
|
+
enumerable: true,
|
|
4242
|
+
get: function () {
|
|
4243
|
+
return updateSkill;
|
|
4244
|
+
}
|
|
4245
|
+
});
|
|
4246
|
+
Object.defineProperty(exports, 'updateTeam', {
|
|
4247
|
+
enumerable: true,
|
|
4248
|
+
get: function () {
|
|
4249
|
+
return updateTeam;
|
|
4250
|
+
}
|
|
4251
|
+
});
|
|
4252
|
+
Object.defineProperty(exports, 'updateTeamMember', {
|
|
4253
|
+
enumerable: true,
|
|
4254
|
+
get: function () {
|
|
4255
|
+
return updateTeamMember;
|
|
4256
|
+
}
|
|
4257
|
+
});
|
|
4258
|
+
Object.defineProperty(exports, 'updateUser', {
|
|
4259
|
+
enumerable: true,
|
|
4260
|
+
get: function () {
|
|
4261
|
+
return updateUser;
|
|
4262
|
+
}
|
|
4263
|
+
});
|
|
4264
|
+
Object.defineProperty(exports, 'updateUsersMe', {
|
|
4265
|
+
enumerable: true,
|
|
4266
|
+
get: function () {
|
|
4267
|
+
return updateUsersMe;
|
|
4268
|
+
}
|
|
4269
|
+
});
|