gatana-sdk 2.3.9 → 3.1.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.
Files changed (38) hide show
  1. package/dist/api/index.cjs +167 -121
  2. package/dist/api/index.d.cts +2 -2
  3. package/dist/api/index.d.mts +2 -2
  4. package/dist/api/index.mjs +2 -2
  5. package/dist/apiv2/index.cjs +14 -11
  6. package/dist/apiv2/index.d.cts +2 -2
  7. package/dist/apiv2/index.d.mts +2 -2
  8. package/dist/apiv2/index.mjs +2 -2
  9. package/dist/index.cjs +2 -2
  10. package/dist/index.d.cts +2 -2
  11. package/dist/index.d.mts +2 -2
  12. package/dist/index.mjs +2 -2
  13. package/dist/{sdk.gen-DUNHa0uM.mjs → sdk.gen-CAAxLIvj.mjs} +85 -28
  14. package/dist/{sdk.gen-DUNHa0uM.mjs.map → sdk.gen-CAAxLIvj.mjs.map} +1 -1
  15. package/dist/sdk.gen-CPj479Qv.cjs +4453 -0
  16. package/dist/{sdk.gen-BMl_z1y-.cjs → sdk.gen-Cdv7MDsj.cjs} +121 -46
  17. package/dist/sdk.gen-Crii0E1f.d.mts +2090 -0
  18. package/dist/sdk.gen-Crii0E1f.d.mts.map +1 -0
  19. package/dist/sdk.gen-DTUv_UKF.d.cts +10119 -0
  20. package/dist/sdk.gen-DTUv_UKF.d.cts.map +1 -0
  21. package/dist/sdk.gen-DnHL4s0x.mjs +3423 -0
  22. package/dist/sdk.gen-DnHL4s0x.mjs.map +1 -0
  23. package/dist/sdk.gen-Do_HFvZj.d.cts +2090 -0
  24. package/dist/sdk.gen-Do_HFvZj.d.cts.map +1 -0
  25. package/dist/sdk.gen-oW0osWyp.d.mts +10119 -0
  26. package/dist/sdk.gen-oW0osWyp.d.mts.map +1 -0
  27. package/package.json +1 -1
  28. package/dist/sdk.gen-B5HNJH3y.mjs +0 -2388
  29. package/dist/sdk.gen-B5HNJH3y.mjs.map +0 -1
  30. package/dist/sdk.gen-B_k9Vt0B.cjs +0 -3142
  31. package/dist/sdk.gen-BfbbIXIn.d.cts +0 -4422
  32. package/dist/sdk.gen-BfbbIXIn.d.cts.map +0 -1
  33. package/dist/sdk.gen-BlL_JhaF.d.mts +0 -987
  34. package/dist/sdk.gen-BlL_JhaF.d.mts.map +0 -1
  35. package/dist/sdk.gen-Dnt5grWk.d.cts +0 -987
  36. package/dist/sdk.gen-Dnt5grWk.d.cts.map +0 -1
  37. package/dist/sdk.gen-cu6fHqHG.d.mts +0 -4422
  38. package/dist/sdk.gen-cu6fHqHG.d.mts.map +0 -1
@@ -0,0 +1,2090 @@
1
+ //#region src/apiv2/core/auth.gen.d.ts
2
+ type AuthToken = string | undefined;
3
+ interface Auth {
4
+ /**
5
+ * Which part of the request do we use to send the auth?
6
+ *
7
+ * @default 'header'
8
+ */
9
+ in?: 'header' | 'query' | 'cookie';
10
+ /**
11
+ * Header or query parameter name.
12
+ *
13
+ * @default 'Authorization'
14
+ */
15
+ name?: string;
16
+ scheme?: 'basic' | 'bearer';
17
+ type: 'apiKey' | 'http';
18
+ }
19
+ //#endregion
20
+ //#region src/apiv2/core/pathSerializer.gen.d.ts
21
+ interface SerializerOptions<T> {
22
+ /**
23
+ * @default true
24
+ */
25
+ explode: boolean;
26
+ style: T;
27
+ }
28
+ type ArrayStyle = 'form' | 'spaceDelimited' | 'pipeDelimited';
29
+ type ObjectStyle = 'form' | 'deepObject';
30
+ //#endregion
31
+ //#region src/apiv2/core/bodySerializer.gen.d.ts
32
+ type QuerySerializer = (query: Record<string, unknown>) => string;
33
+ type BodySerializer = (body: unknown) => unknown;
34
+ type QuerySerializerOptionsObject = {
35
+ allowReserved?: boolean;
36
+ array?: Partial<SerializerOptions<ArrayStyle>>;
37
+ object?: Partial<SerializerOptions<ObjectStyle>>;
38
+ };
39
+ type QuerySerializerOptions = QuerySerializerOptionsObject & {
40
+ /**
41
+ * Per-parameter serialization overrides. When provided, these settings
42
+ * override the global array/object settings for specific parameter names.
43
+ */
44
+ parameters?: Record<string, QuerySerializerOptionsObject>;
45
+ };
46
+ //#endregion
47
+ //#region src/apiv2/core/types.gen.d.ts
48
+ type HttpMethod = 'connect' | 'delete' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
49
+ type Client$1<RequestFn = never, Config = unknown, MethodFn = never, BuildUrlFn = never, SseFn = never> = {
50
+ /**
51
+ * Returns the final request URL.
52
+ */
53
+ buildUrl: BuildUrlFn;
54
+ getConfig: () => Config;
55
+ request: RequestFn;
56
+ setConfig: (config: Config) => Config;
57
+ } & { [K in HttpMethod]: MethodFn } & ([SseFn] extends [never] ? {
58
+ sse?: never;
59
+ } : {
60
+ sse: { [K in HttpMethod]: SseFn };
61
+ });
62
+ interface Config$1 {
63
+ /**
64
+ * Auth token or a function returning auth token. The resolved value will be
65
+ * added to the request payload as defined by its `security` array.
66
+ */
67
+ auth?: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken;
68
+ /**
69
+ * A function for serializing request body parameter. By default,
70
+ * {@link JSON.stringify()} will be used.
71
+ */
72
+ bodySerializer?: BodySerializer | null;
73
+ /**
74
+ * An object containing any HTTP headers that you want to pre-populate your
75
+ * `Headers` object with.
76
+ *
77
+ * {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more}
78
+ */
79
+ headers?: RequestInit['headers'] | Record<string, string | number | boolean | (string | number | boolean)[] | null | undefined | unknown>;
80
+ /**
81
+ * The request method.
82
+ *
83
+ * {@link https://developer.mozilla.org/docs/Web/API/fetch#method See more}
84
+ */
85
+ method?: Uppercase<HttpMethod>;
86
+ /**
87
+ * A function for serializing request query parameters. By default, arrays
88
+ * will be exploded in form style, objects will be exploded in deepObject
89
+ * style, and reserved characters are percent-encoded.
90
+ *
91
+ * This method will have no effect if the native `paramsSerializer()` Axios
92
+ * API function is used.
93
+ *
94
+ * {@link https://swagger.io/docs/specification/serialization/#query View examples}
95
+ */
96
+ querySerializer?: QuerySerializer | QuerySerializerOptions;
97
+ /**
98
+ * A function validating request data. This is useful if you want to ensure
99
+ * the request conforms to the desired shape, so it can be safely sent to
100
+ * the server.
101
+ */
102
+ requestValidator?: (data: unknown) => Promise<unknown>;
103
+ /**
104
+ * A function transforming response data before it's returned. This is useful
105
+ * for post-processing data, e.g., converting ISO strings into Date objects.
106
+ */
107
+ responseTransformer?: (data: unknown) => Promise<unknown>;
108
+ /**
109
+ * A function validating response data. This is useful if you want to ensure
110
+ * the response conforms to the desired shape, so it can be safely passed to
111
+ * the transformers and returned to the user.
112
+ */
113
+ responseValidator?: (data: unknown) => Promise<unknown>;
114
+ }
115
+ //#endregion
116
+ //#region src/apiv2/core/serverSentEvents.gen.d.ts
117
+ type ServerSentEventsOptions<TData = unknown> = Omit<RequestInit, 'method'> & Pick<Config$1, 'method' | 'responseTransformer' | 'responseValidator'> & {
118
+ /**
119
+ * Fetch API implementation. You can use this option to provide a custom
120
+ * fetch instance.
121
+ *
122
+ * @default globalThis.fetch
123
+ */
124
+ fetch?: typeof fetch;
125
+ /**
126
+ * Implementing clients can call request interceptors inside this hook.
127
+ */
128
+ onRequest?: (url: string, init: RequestInit) => Promise<Request>;
129
+ /**
130
+ * Callback invoked when a network or parsing error occurs during streaming.
131
+ *
132
+ * This option applies only if the endpoint returns a stream of events.
133
+ *
134
+ * @param error The error that occurred.
135
+ */
136
+ onSseError?: (error: unknown) => void;
137
+ /**
138
+ * Callback invoked when an event is streamed from the server.
139
+ *
140
+ * This option applies only if the endpoint returns a stream of events.
141
+ *
142
+ * @param event Event streamed from the server.
143
+ * @returns Nothing (void).
144
+ */
145
+ onSseEvent?: (event: StreamEvent<TData>) => void;
146
+ serializedBody?: RequestInit['body'];
147
+ /**
148
+ * Default retry delay in milliseconds.
149
+ *
150
+ * This option applies only if the endpoint returns a stream of events.
151
+ *
152
+ * @default 3000
153
+ */
154
+ sseDefaultRetryDelay?: number;
155
+ /**
156
+ * Maximum number of retry attempts before giving up.
157
+ */
158
+ sseMaxRetryAttempts?: number;
159
+ /**
160
+ * Maximum retry delay in milliseconds.
161
+ *
162
+ * Applies only when exponential backoff is used.
163
+ *
164
+ * This option applies only if the endpoint returns a stream of events.
165
+ *
166
+ * @default 30000
167
+ */
168
+ sseMaxRetryDelay?: number;
169
+ /**
170
+ * Optional sleep function for retry backoff.
171
+ *
172
+ * Defaults to using `setTimeout`.
173
+ */
174
+ sseSleepFn?: (ms: number) => Promise<void>;
175
+ url: string;
176
+ };
177
+ interface StreamEvent<TData = unknown> {
178
+ data: TData;
179
+ event?: string;
180
+ id?: string;
181
+ retry?: number;
182
+ }
183
+ type ServerSentEventsResult<TData = unknown, TReturn = void, TNext = unknown> = {
184
+ stream: AsyncGenerator<TData extends Record<string, unknown> ? TData[keyof TData] : TData, TReturn, TNext>;
185
+ };
186
+ //#endregion
187
+ //#region src/apiv2/client/utils.gen.d.ts
188
+ type ErrInterceptor<Err, Res, Req, Options> = (error: Err, response: Res, request: Req, options: Options) => Err | Promise<Err>;
189
+ type ReqInterceptor<Req, Options> = (request: Req, options: Options) => Req | Promise<Req>;
190
+ type ResInterceptor<Res, Req, Options> = (response: Res, request: Req, options: Options) => Res | Promise<Res>;
191
+ declare class Interceptors<Interceptor> {
192
+ fns: Array<Interceptor | null>;
193
+ clear(): void;
194
+ eject(id: number | Interceptor): void;
195
+ exists(id: number | Interceptor): boolean;
196
+ getInterceptorIndex(id: number | Interceptor): number;
197
+ update(id: number | Interceptor, fn: Interceptor): number | Interceptor | false;
198
+ use(fn: Interceptor): number;
199
+ }
200
+ interface Middleware<Req, Res, Err, Options> {
201
+ error: Interceptors<ErrInterceptor<Err, Res, Req, Options>>;
202
+ request: Interceptors<ReqInterceptor<Req, Options>>;
203
+ response: Interceptors<ResInterceptor<Res, Req, Options>>;
204
+ }
205
+ //#endregion
206
+ //#region src/apiv2/client/types.gen.d.ts
207
+ type ResponseStyle = 'data' | 'fields';
208
+ interface Config<T extends ClientOptions$1 = ClientOptions$1> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Config$1 {
209
+ /**
210
+ * Base URL for all requests made by this client.
211
+ */
212
+ baseUrl?: T['baseUrl'];
213
+ /**
214
+ * Fetch API implementation. You can use this option to provide a custom
215
+ * fetch instance.
216
+ *
217
+ * @default globalThis.fetch
218
+ */
219
+ fetch?: typeof fetch;
220
+ /**
221
+ * Please don't use the Fetch client for Next.js applications. The `next`
222
+ * options won't have any effect.
223
+ *
224
+ * Install {@link https://www.npmjs.com/package/@hey-api/client-next `@hey-api/client-next`} instead.
225
+ */
226
+ next?: never;
227
+ /**
228
+ * Return the response data parsed in a specified format. By default, `auto`
229
+ * will infer the appropriate method from the `Content-Type` response header.
230
+ * You can override this behavior with any of the {@link Body} methods.
231
+ * Select `stream` if you don't want to parse response data at all.
232
+ *
233
+ * @default 'auto'
234
+ */
235
+ parseAs?: 'arrayBuffer' | 'auto' | 'blob' | 'formData' | 'json' | 'stream' | 'text';
236
+ /**
237
+ * Should we return only data or multiple fields (data, error, response, etc.)?
238
+ *
239
+ * @default 'fields'
240
+ */
241
+ responseStyle?: ResponseStyle;
242
+ /**
243
+ * Throw an error instead of returning it in the response?
244
+ *
245
+ * @default false
246
+ */
247
+ throwOnError?: T['throwOnError'];
248
+ }
249
+ interface RequestOptions<TData = unknown, TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends Config<{
250
+ responseStyle: TResponseStyle;
251
+ throwOnError: ThrowOnError;
252
+ }>, Pick<ServerSentEventsOptions<TData>, 'onRequest' | 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
253
+ /**
254
+ * Any body that you want to add to your request.
255
+ *
256
+ * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
257
+ */
258
+ body?: unknown;
259
+ path?: Record<string, unknown>;
260
+ query?: Record<string, unknown>;
261
+ /**
262
+ * Security mechanism(s) to use for the request.
263
+ */
264
+ security?: ReadonlyArray<Auth>;
265
+ url: Url;
266
+ }
267
+ interface ResolvedRequestOptions<TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions<unknown, TResponseStyle, ThrowOnError, Url> {
268
+ serializedBody?: string;
269
+ }
270
+ type RequestResult<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean, TResponseStyle extends ResponseStyle = 'fields'> = ThrowOnError extends true ? Promise<TResponseStyle extends 'data' ? TData extends Record<string, unknown> ? TData[keyof TData] : TData : {
271
+ data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
272
+ request: Request;
273
+ response: Response;
274
+ }> : Promise<TResponseStyle extends 'data' ? (TData extends Record<string, unknown> ? TData[keyof TData] : TData) | undefined : ({
275
+ data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
276
+ error: undefined;
277
+ } | {
278
+ data: undefined;
279
+ error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
280
+ }) & {
281
+ request: Request;
282
+ response: Response;
283
+ }>;
284
+ interface ClientOptions$1 {
285
+ baseUrl?: string;
286
+ responseStyle?: ResponseStyle;
287
+ throwOnError?: boolean;
288
+ }
289
+ type MethodFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
290
+ type SseFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<never, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
291
+ type RequestFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'> & Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
292
+ type BuildUrlFn = <TData extends {
293
+ body?: unknown;
294
+ path?: Record<string, unknown>;
295
+ query?: Record<string, unknown>;
296
+ url: string;
297
+ }>(options: TData & Options$1<TData>) => string;
298
+ type Client = Client$1<RequestFn, Config, MethodFn, BuildUrlFn, SseFn> & {
299
+ interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
300
+ };
301
+ interface TDataShape {
302
+ body?: unknown;
303
+ headers?: unknown;
304
+ path?: unknown;
305
+ query?: unknown;
306
+ url: string;
307
+ }
308
+ type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
309
+ type Options$1<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown, TResponseStyle extends ResponseStyle = 'fields'> = OmitKeys<RequestOptions<TResponse, TResponseStyle, ThrowOnError>, 'body' | 'path' | 'query' | 'url'> & ([TData] extends [never] ? unknown : Omit<TData, 'url'>);
310
+ //#endregion
311
+ //#region src/apiv2/types.gen.d.ts
312
+ type ClientOptions = {
313
+ baseUrl: 'https://{YOUR_ORG_ID}.gatana.ai/api/v2' | (string & {});
314
+ };
315
+ type V2CreateServerRequest = {
316
+ slug: Schema0;
317
+ transportConfig?: Schema1;
318
+ transportConfigType?: Schema60;
319
+ description?: Schema63;
320
+ authorization?: Schema65;
321
+ oauthMetadata?: Schema74;
322
+ oauthClientConfiguration?: Schema97;
323
+ isEnabled?: Schema112;
324
+ timeoutProtocol?: Schema114;
325
+ timeoutTotal?: Schema116;
326
+ resetTimeoutOnProgressNotification?: Schema118;
327
+ isOutputCompressionEnabled?: Schema120;
328
+ isOutputCompressionTransformEnabled?: Schema122;
329
+ outputCompressionThresholdBytes?: Schema124;
330
+ firewallRules?: Schema126;
331
+ visibility?: Schema129;
332
+ id?: Schema130;
333
+ tenantId?: Schema132;
334
+ lastToolRefreshAt?: Schema134;
335
+ createdAt?: Schema136;
336
+ updatedAt?: Schema138;
337
+ };
338
+ type HttpStreamingTransportConfig = {
339
+ type: Schema3;
340
+ url: Schema4;
341
+ headers?: Schema5;
342
+ };
343
+ type StdioTransportConfig = {
344
+ type: Schema7;
345
+ command: Schema8;
346
+ dockerImage?: Schema9;
347
+ env?: Schema11;
348
+ transport: Schema13;
349
+ httpPort?: Schema14;
350
+ urlPath?: Schema16;
351
+ healthCheck?: Schema18;
352
+ limits?: Schema24;
353
+ requests?: Schema28;
354
+ storage?: StdioTransportStorage;
355
+ tailscale?: StdioTransportTailscale;
356
+ };
357
+ /**
358
+ * Persistent storage for the server. When enabled the server keeps one volume, mounted at the path in GATANA_DATA_DIR, which survives restarts and the idle stop. The size is fixed by the deployment and counts against the organization storage quota
359
+ */
360
+ type StdioTransportStorage = Schema32 | null;
361
+ /**
362
+ * Egress-only Tailscale access. When enabled the server can open connections to hosts on your tailnet, and to the subnets its routers advertise. Nothing on the tailnet can reach the server
363
+ */
364
+ type StdioTransportTailscale = Schema33 | null;
365
+ type SseTransportConfig = {
366
+ type: Schema35;
367
+ url: Schema36;
368
+ headers?: Schema37;
369
+ };
370
+ type HostedTransportConfig = {
371
+ type: Schema39;
372
+ runtime: Schema40;
373
+ env?: Schema41;
374
+ limits?: Schema43;
375
+ requests?: Schema45;
376
+ storage?: HostedTransportStorage;
377
+ tailscale?: HostedTransportTailscale;
378
+ };
379
+ /**
380
+ * Persistent storage for the server. When enabled the server keeps one volume, mounted at the path in GATANA_DATA_DIR, which survives restarts and the idle stop. The size is fixed by the deployment and counts against the organization storage quota
381
+ */
382
+ type HostedTransportStorage = Schema47 | null;
383
+ /**
384
+ * Egress-only Tailscale access. When enabled the server can open connections to hosts on your tailnet, and to the subnets its routers advertise. Nothing on the tailnet can reach the server
385
+ */
386
+ type HostedTransportTailscale = Schema48 | null;
387
+ type OpenApiTransportConfig = {
388
+ type: Schema50;
389
+ method: Schema51;
390
+ specUrl?: Schema52;
391
+ spec?: Schema54;
392
+ baseUrl?: Schema56;
393
+ headers?: Schema58;
394
+ };
395
+ /**
396
+ * Controls how tool refresh is authorized. "server-scoped" means only server-scoped credentials are required, "skip" means refresh is done without authorization, and "any" means any available credentials (server, user, profile) can be used. Defaults to "server-scoped".
397
+ */
398
+ type ToolRefreshCredentialPolicy = Schema72;
399
+ type ServerAuthorization = {
400
+ method: Schema66;
401
+ credentialsScope: Schema67;
402
+ apikeys?: Schema70;
403
+ toolRefreshCredentialPolicy?: ToolRefreshCredentialPolicy;
404
+ };
405
+ type ServerOAuthMetadata = {
406
+ resource?: Schema76;
407
+ as?: Schema81;
408
+ };
409
+ type ServerOAuthClientConfiguration = {
410
+ clientId?: Schema99;
411
+ clientSecret?: Schema101;
412
+ grantType: Schema103;
413
+ clientAuthMethod: Schema104;
414
+ scopes?: Schema109;
415
+ };
416
+ type OAuthGrantType = 'authorization_code' | 'device_code';
417
+ type ServerVisibility = 'private' | 'organization';
418
+ type V2UpdateServerRequest = {
419
+ slug?: Schema141;
420
+ description?: Schema63;
421
+ authorization?: Schema65;
422
+ transportConfig?: Schema145;
423
+ oauthMetadata?: Schema74;
424
+ oauthClientConfiguration?: Schema97;
425
+ isEnabled?: Schema112;
426
+ timeoutProtocol?: Schema114;
427
+ timeoutTotal?: Schema116;
428
+ resetTimeoutOnProgressNotification?: Schema118;
429
+ isOutputCompressionEnabled?: Schema120;
430
+ isOutputCompressionTransformEnabled?: Schema122;
431
+ outputCompressionThresholdBytes?: Schema124;
432
+ firewallRules?: Schema126;
433
+ visibility?: Schema129;
434
+ id?: Schema158;
435
+ tenantId?: Schema160;
436
+ name?: Schema162;
437
+ lastToolRefreshAt?: Schema164;
438
+ createdAt?: Schema166;
439
+ updatedAt?: Schema168;
440
+ };
441
+ type V2PatchServerRequest = { [key in Schema170]?: Schema171 };
442
+ /**
443
+ * URL-friendly name of the server, unique within the tenant
444
+ */
445
+ type Schema0 = string;
446
+ /**
447
+ * Transport configuration used to connect to the server
448
+ */
449
+ type Schema1 = Schema2;
450
+ type Schema2 = HttpStreamingTransportConfig | StdioTransportConfig | SseTransportConfig | HostedTransportConfig | OpenApiTransportConfig;
451
+ /**
452
+ * Transport type discriminator, always "httpstreaming"
453
+ */
454
+ type Schema3 = 'httpstreaming';
455
+ /**
456
+ * URL of the MCP streamable HTTP endpoint
457
+ */
458
+ type Schema4 = string;
459
+ /**
460
+ * Extra HTTP headers to send with each request, as [name, value] pairs
461
+ */
462
+ type Schema5 = Schema6;
463
+ type Schema6 = Array<[string, string]>;
464
+ /**
465
+ * Transport type discriminator, always "stdio"
466
+ */
467
+ type Schema7 = 'stdio';
468
+ /**
469
+ * Command line that starts the MCP server process
470
+ */
471
+ type Schema8 = string;
472
+ /**
473
+ * Docker image that the command runs in
474
+ */
475
+ type Schema9 = Schema10;
476
+ type Schema10 = string;
477
+ /**
478
+ * Environment variables for the process, as [name, value] pairs
479
+ */
480
+ type Schema11 = Schema12;
481
+ type Schema12 = Array<[string, string]>;
482
+ /**
483
+ * Protocol that the launched process speaks
484
+ */
485
+ type Schema13 = 'sse' | 'httpstreaming' | 'stdio';
486
+ /**
487
+ * Port that the process listens on when transport is HTTP-based
488
+ */
489
+ type Schema14 = Schema15 | null;
490
+ type Schema15 = number;
491
+ /**
492
+ * URL path of the MCP endpoint when transport is HTTP-based
493
+ */
494
+ type Schema16 = Schema17 | null;
495
+ type Schema17 = string;
496
+ /**
497
+ * HTTP health check configuration for the process
498
+ */
499
+ type Schema18 = Schema19;
500
+ type Schema19 = {
501
+ /**
502
+ * Whether the health check is active
503
+ */
504
+ enabled: boolean;
505
+ /**
506
+ * URL that the health check polls
507
+ */
508
+ url?: Schema20;
509
+ /**
510
+ * Seconds to wait before the first health check
511
+ */
512
+ delaySeconds: Schema21 | null;
513
+ /**
514
+ * Seconds between health checks
515
+ */
516
+ intervalSeconds: Schema22 | null;
517
+ /**
518
+ * Number of consecutive failures before the process counts as unhealthy
519
+ */
520
+ failureThreshold: Schema23 | null;
521
+ };
522
+ type Schema20 = string;
523
+ type Schema21 = number;
524
+ type Schema22 = number;
525
+ type Schema23 = number;
526
+ /**
527
+ * Deprecated: former resource ceiling, no longer applied to deployments. Use requests to reserve capacity instead
528
+ */
529
+ type Schema24 = Schema25 | null;
530
+ type Schema25 = {
531
+ cpu?: Schema26;
532
+ memory?: Schema27;
533
+ };
534
+ /**
535
+ * CPU limit in Kubernetes quantity format (e.g. "500m" or "1")
536
+ */
537
+ type Schema26 = string;
538
+ /**
539
+ * Memory limit in Kubernetes quantity format (e.g. "512Mi" or "1Gi")
540
+ */
541
+ type Schema27 = string;
542
+ /**
543
+ * Resources reserved for the process: the minimum it is guaranteed when the hardware is busy. Overrides the organization default
544
+ */
545
+ type Schema28 = Schema29 | null;
546
+ type Schema29 = {
547
+ cpu?: Schema30;
548
+ memory?: Schema31;
549
+ };
550
+ /**
551
+ * CPU reserved for the deployment, in Kubernetes quantity format (e.g. "250m" or "1"). This is the minimum the deployment is guaranteed when the hardware is busy; when capacity is free it may use more. Reserved capacity counts against the organization total even while the server idles, so keep it at what the server needs, not what it may burst to
552
+ */
553
+ type Schema30 = string;
554
+ /**
555
+ * Memory reserved for the deployment, in Kubernetes quantity format (e.g. "384Mi" or "1Gi"). Unlike CPU this is also the hard ceiling: a process that exceeds it is terminated
556
+ */
557
+ type Schema31 = string;
558
+ type Schema32 = {
559
+ /**
560
+ * Whether the server gets a persistent volume
561
+ */
562
+ enabled: boolean;
563
+ };
564
+ type Schema33 = {
565
+ /**
566
+ * Whether the server joins the tailnet
567
+ */
568
+ enabled: boolean;
569
+ /**
570
+ * Tailscale auth key that registers the machine. It is spent at the first registration and the machine identity is kept across restarts, so use a tagged key and do not make it ephemeral
571
+ */
572
+ authKey: string;
573
+ /**
574
+ * Machine name on the tailnet. Defaults to gatana-<server slug>
575
+ */
576
+ hostname?: Schema34 | null;
577
+ };
578
+ type Schema34 = string;
579
+ /**
580
+ * Transport type discriminator, always "sse"
581
+ */
582
+ type Schema35 = 'sse';
583
+ /**
584
+ * URL of the MCP SSE endpoint
585
+ */
586
+ type Schema36 = string;
587
+ /**
588
+ * Extra HTTP headers to send with each request, as [name, value] pairs
589
+ */
590
+ type Schema37 = Schema38;
591
+ type Schema38 = Array<[string, string]>;
592
+ /**
593
+ * Transport type discriminator, always "hosted"
594
+ */
595
+ type Schema39 = 'hosted';
596
+ /**
597
+ * Runtime that executes the hosted tool functions
598
+ */
599
+ type Schema40 = 'node24' | 'python313';
600
+ /**
601
+ * Environment variables for the hosted runtime, as [name, value] pairs
602
+ */
603
+ type Schema41 = Schema42;
604
+ type Schema42 = Array<[string, string]>;
605
+ /**
606
+ * Deprecated: former resource ceiling, no longer applied to deployments. Use requests to reserve capacity instead
607
+ */
608
+ type Schema43 = Schema44 | null;
609
+ type Schema44 = {
610
+ cpu?: Schema26;
611
+ memory?: Schema27;
612
+ };
613
+ /**
614
+ * Resources reserved for the hosted runtime: the minimum it is guaranteed when the hardware is busy. Overrides the organization default
615
+ */
616
+ type Schema45 = Schema46 | null;
617
+ type Schema46 = {
618
+ cpu?: Schema30;
619
+ memory?: Schema31;
620
+ };
621
+ type Schema47 = {
622
+ /**
623
+ * Whether the server gets a persistent volume
624
+ */
625
+ enabled: boolean;
626
+ };
627
+ type Schema48 = {
628
+ /**
629
+ * Whether the server joins the tailnet
630
+ */
631
+ enabled: boolean;
632
+ /**
633
+ * Tailscale auth key that registers the machine. It is spent at the first registration and the machine identity is kept across restarts, so use a tagged key and do not make it ephemeral
634
+ */
635
+ authKey: string;
636
+ /**
637
+ * Machine name on the tailnet. Defaults to gatana-<server slug>
638
+ */
639
+ hostname?: Schema49 | null;
640
+ };
641
+ type Schema49 = string;
642
+ /**
643
+ * Transport type discriminator, always "openapi"
644
+ */
645
+ type Schema50 = 'openapi';
646
+ /**
647
+ * How the OpenAPI spec is supplied: from a URL or as inline content
648
+ */
649
+ type Schema51 = 'specUrl' | 'spec';
650
+ /**
651
+ * URL to fetch the OpenAPI spec from, used when method is "specUrl"
652
+ */
653
+ type Schema52 = Schema53;
654
+ type Schema53 = string | '';
655
+ /**
656
+ * Inline OpenAPI spec content, used when method is "spec"
657
+ */
658
+ type Schema54 = Schema55;
659
+ type Schema55 = string;
660
+ /**
661
+ * Base URL for the API requests generated from the spec
662
+ */
663
+ type Schema56 = Schema57;
664
+ type Schema57 = string | '';
665
+ /**
666
+ * Extra HTTP headers to send with each request, as [name, value] pairs
667
+ */
668
+ type Schema58 = Schema59;
669
+ type Schema59 = Array<[string, string]>;
670
+ /**
671
+ * Transport type to create with a default configuration, used instead of transportConfig
672
+ */
673
+ type Schema60 = Schema61;
674
+ type Schema61 = 'httpstreaming' | 'sse' | 'stdio' | 'hosted' | 'openapi';
675
+ type Schema62 = Schema63;
676
+ /**
677
+ * Human-readable description of the server
678
+ */
679
+ type Schema63 = string;
680
+ type Schema64 = Schema65;
681
+ /**
682
+ * Authorization configuration for the server
683
+ */
684
+ type Schema65 = ServerAuthorization;
685
+ /**
686
+ * Authorization method that the server uses
687
+ */
688
+ type Schema66 = 'none' | 'oauth' | 'oauth-client-credentials' | 'apikey';
689
+ /**
690
+ * Whether credentials are shared for the whole server or stored per user
691
+ */
692
+ type Schema67 = Schema68 | Schema69;
693
+ type Schema68 = 'server';
694
+ type Schema69 = 'user';
695
+ /**
696
+ * Names of the API keys that the server expects
697
+ */
698
+ type Schema70 = Schema71;
699
+ type Schema71 = Array<string>;
700
+ type Schema72 = 'server-scoped' | 'skip' | 'any';
701
+ type Schema73 = Schema74;
702
+ /**
703
+ * Discovered OAuth metadata, or null when not discovered
704
+ */
705
+ type Schema74 = Schema75 | ServerOAuthMetadata;
706
+ type Schema75 = null;
707
+ /**
708
+ * Discovered protected resource metadata (RFC 9728)
709
+ */
710
+ type Schema76 = Schema77;
711
+ type Schema77 = {
712
+ /**
713
+ * Resource identifier from the protected resource metadata
714
+ */
715
+ id?: Schema78;
716
+ /**
717
+ * Scopes that the protected resource supports
718
+ */
719
+ availableScopes?: Schema79;
720
+ /**
721
+ * URL where the protected resource metadata was fetched from
722
+ */
723
+ metadataUrl?: Schema80;
724
+ };
725
+ type Schema78 = string;
726
+ type Schema79 = Array<string>;
727
+ type Schema80 = string;
728
+ /**
729
+ * Discovered authorization server metadata (RFC 8414)
730
+ */
731
+ type Schema81 = Schema82;
732
+ type Schema82 = {
733
+ /**
734
+ * Issuer identifier of the authorization server
735
+ */
736
+ issuer?: Schema83;
737
+ /**
738
+ * URL of the authorization endpoint
739
+ */
740
+ authorizeEndpoint?: Schema84;
741
+ /**
742
+ * URL of the device authorization endpoint
743
+ */
744
+ deviceAuthorizationEndpoint?: Schema85;
745
+ /**
746
+ * URL of the token endpoint
747
+ */
748
+ tokenEndpoint?: Schema86;
749
+ /**
750
+ * Extra query parameters to add to the authorization request
751
+ */
752
+ extraAuthorizationParameters?: Schema87;
753
+ /**
754
+ * URL of the dynamic client registration endpoint
755
+ */
756
+ registrationEndpoint?: Schema88;
757
+ /**
758
+ * Whether the authorization server supports PKCE
759
+ */
760
+ supportsPKCE?: Schema89;
761
+ /**
762
+ * Client authentication methods that the token endpoint supports
763
+ */
764
+ supportedClientAuthMethods?: Schema90;
765
+ /**
766
+ * Whether the authorization server supports dynamic client registration
767
+ */
768
+ supportsDynamicClientRegistration?: Schema91;
769
+ /**
770
+ * Reason why dynamic client registration is not available
771
+ */
772
+ noDynamicClientRegistrationReason?: Schema92;
773
+ /**
774
+ * URL of the authorization server documentation
775
+ */
776
+ serviceDocumentation?: Schema93;
777
+ /**
778
+ * URL where the authorization server metadata was fetched from
779
+ */
780
+ metadataUrl?: Schema94;
781
+ /**
782
+ * Scopes that the authorization server supports
783
+ */
784
+ availableScopes?: Schema95;
785
+ };
786
+ type Schema83 = string;
787
+ type Schema84 = string;
788
+ type Schema85 = string;
789
+ type Schema86 = string;
790
+ type Schema87 = string;
791
+ type Schema88 = string;
792
+ type Schema89 = boolean;
793
+ type Schema90 = Array<string>;
794
+ type Schema91 = boolean;
795
+ type Schema92 = string | null;
796
+ type Schema93 = string;
797
+ type Schema94 = string;
798
+ type Schema95 = Array<string>;
799
+ type Schema96 = Schema97;
800
+ /**
801
+ * OAuth client configuration, or null when not configured
802
+ */
803
+ type Schema97 = Schema98 | ServerOAuthClientConfiguration;
804
+ type Schema98 = null;
805
+ /**
806
+ * OAuth client ID
807
+ */
808
+ type Schema99 = Schema100;
809
+ type Schema100 = string;
810
+ /**
811
+ * OAuth client secret
812
+ */
813
+ type Schema101 = Schema102;
814
+ type Schema102 = string;
815
+ /**
816
+ * OAuth grant type used to obtain tokens
817
+ */
818
+ type Schema103 = OAuthGrantType;
819
+ /**
820
+ * Client authentication method used at the token endpoint
821
+ */
822
+ type Schema104 = Schema105 | Schema106 | Schema107 | Schema108;
823
+ type Schema105 = 'client_secret_basic';
824
+ type Schema106 = 'client_secret_post';
825
+ type Schema107 = 'none';
826
+ type Schema108 = string;
827
+ /**
828
+ * Space-separated OAuth scopes to request
829
+ */
830
+ type Schema109 = Schema110;
831
+ type Schema110 = string;
832
+ type Schema111 = Schema112;
833
+ /**
834
+ * Whether the server is enabled
835
+ */
836
+ type Schema112 = boolean;
837
+ type Schema113 = Schema114;
838
+ /**
839
+ * Timeout in seconds for a single protocol request to the server
840
+ */
841
+ type Schema114 = number;
842
+ type Schema115 = Schema116;
843
+ /**
844
+ * Total timeout in seconds for a tool call, including progress notifications
845
+ */
846
+ type Schema116 = number;
847
+ type Schema117 = Schema118;
848
+ /**
849
+ * Whether a progress notification resets the protocol timeout
850
+ */
851
+ type Schema118 = boolean;
852
+ type Schema119 = Schema120;
853
+ /**
854
+ * Whether large tool outputs are compressed before they are returned to the client
855
+ */
856
+ type Schema120 = boolean;
857
+ type Schema121 = Schema122;
858
+ /**
859
+ * Whether the compression transform step is applied to tool outputs
860
+ */
861
+ type Schema122 = boolean;
862
+ type Schema123 = Schema124;
863
+ /**
864
+ * Minimum output size in bytes before compression is applied
865
+ */
866
+ type Schema124 = number;
867
+ type Schema125 = Schema126;
868
+ /**
869
+ * Firewall rules evaluated against tool calls to the server
870
+ */
871
+ type Schema126 = Array<Schema127>;
872
+ type Schema127 = {
873
+ /**
874
+ * CEL representing the condition
875
+ */
876
+ condition: string;
877
+ /**
878
+ * Action to take when the condition matches
879
+ */
880
+ action: 'deny' | 'modify' | 'log';
881
+ };
882
+ type Schema128 = Schema129;
883
+ /**
884
+ * Who can see the server: only members or the whole organization
885
+ */
886
+ type Schema129 = ServerVisibility;
887
+ /**
888
+ * Read-only; accepted and ignored
889
+ */
890
+ type Schema130 = Schema131;
891
+ type Schema131 = string;
892
+ /**
893
+ * Read-only; accepted and ignored
894
+ */
895
+ type Schema132 = Schema133;
896
+ type Schema133 = string;
897
+ /**
898
+ * Read-only; accepted and ignored
899
+ */
900
+ type Schema134 = Schema135;
901
+ type Schema135 = string | null;
902
+ /**
903
+ * Read-only; accepted and ignored
904
+ */
905
+ type Schema136 = Schema137;
906
+ type Schema137 = string;
907
+ /**
908
+ * Read-only; accepted and ignored
909
+ */
910
+ type Schema138 = Schema139;
911
+ type Schema139 = string;
912
+ type Schema140 = string;
913
+ /**
914
+ * URL-friendly name of the server, unique within the tenant
915
+ */
916
+ type Schema141 = Schema142;
917
+ type Schema142 = string;
918
+ type Schema143 = Schema63;
919
+ type Schema144 = Schema65;
920
+ /**
921
+ * Transport configuration used to connect to the server
922
+ */
923
+ type Schema145 = HttpStreamingTransportConfig | StdioTransportConfig | SseTransportConfig | Schema146 | HostedTransportConfig | OpenApiTransportConfig;
924
+ type Schema146 = {
925
+ /**
926
+ * Transport type discriminator, always "self"
927
+ */
928
+ type: 'self';
929
+ /**
930
+ * ID of the built-in server implementation
931
+ */
932
+ id: string;
933
+ };
934
+ type Schema147 = Schema74;
935
+ type Schema148 = Schema97;
936
+ type Schema149 = Schema112;
937
+ type Schema150 = Schema114;
938
+ type Schema151 = Schema116;
939
+ type Schema152 = Schema118;
940
+ type Schema153 = Schema120;
941
+ type Schema154 = Schema122;
942
+ type Schema155 = Schema124;
943
+ type Schema156 = Schema126;
944
+ type Schema157 = Schema129;
945
+ /**
946
+ * Read-only; accepted and ignored
947
+ */
948
+ type Schema158 = Schema159;
949
+ type Schema159 = string;
950
+ /**
951
+ * Read-only; accepted and ignored
952
+ */
953
+ type Schema160 = Schema161;
954
+ type Schema161 = string;
955
+ /**
956
+ * Deprecated; accepted and ignored
957
+ */
958
+ type Schema162 = Schema163;
959
+ type Schema163 = string;
960
+ /**
961
+ * Read-only; accepted and ignored
962
+ */
963
+ type Schema164 = Schema165;
964
+ type Schema165 = string | null;
965
+ /**
966
+ * Read-only; accepted and ignored
967
+ */
968
+ type Schema166 = Schema167;
969
+ type Schema167 = string;
970
+ /**
971
+ * Read-only; accepted and ignored
972
+ */
973
+ type Schema168 = Schema169;
974
+ type Schema169 = string;
975
+ type Schema170 = string;
976
+ type Schema171 = unknown;
977
+ type Schema172 = string;
978
+ type V2ListServersResponse = {
979
+ servers: Schema173;
980
+ };
981
+ type V2ServerDto = Server;
982
+ type Server = {
983
+ id: Schema174;
984
+ slug: Schema175;
985
+ tenantId: Schema176;
986
+ description: Schema177;
987
+ authorization: Schema178;
988
+ transportConfig: Schema186;
989
+ oauthClientConfiguration: Schema245;
990
+ oauthMetadata: Schema259;
991
+ visibility: Schema281;
992
+ isEnabled: Schema282;
993
+ lastToolRefreshAt: Schema283;
994
+ timeoutProtocol: Schema285;
995
+ timeoutTotal: Schema286;
996
+ resetTimeoutOnProgressNotification: Schema287;
997
+ isOutputCompressionEnabled: Schema288;
998
+ isOutputCompressionTransformEnabled: Schema289;
999
+ outputCompressionThresholdBytes: Schema290;
1000
+ firewallRules: Schema291;
1001
+ createdAt: Schema293;
1002
+ updatedAt: Schema294;
1003
+ };
1004
+ type CredentialDtoV2 = {
1005
+ id: Schema296;
1006
+ tenantId: Schema297;
1007
+ scope: Schema298;
1008
+ userId: Schema299;
1009
+ profileId: Schema301;
1010
+ lastUsedAt: Schema303;
1011
+ authorizedAt: Schema305;
1012
+ type: Schema306;
1013
+ createdAt: Schema307;
1014
+ updatedAt: Schema308;
1015
+ serverSlug: Schema309;
1016
+ userEmail: Schema310;
1017
+ userName: Schema312;
1018
+ profileName: Schema314;
1019
+ };
1020
+ type ServerCredentialsCredential = ({
1021
+ type: 'apikey';
1022
+ } & ServerCredentialsApiKeys) | ({
1023
+ type: 'oauth';
1024
+ } & ServerCredentialsOauthTokens) | ({
1025
+ type: 'oauth-client-credentials';
1026
+ } & ServerCredentialsOauthClientCredentials);
1027
+ type ServerCredentialsApiKeys = {
1028
+ type: Schema316;
1029
+ apikeys: Schema317;
1030
+ };
1031
+ type ServerCredentialsOauthTokens = {
1032
+ type: Schema319;
1033
+ tokenSet: Schema320;
1034
+ };
1035
+ type ServerCredentialsOauthClientCredentials = {
1036
+ type: Schema329;
1037
+ clientConfig?: ServerOAuthClientConfigurationClientCredentials;
1038
+ tokenSet?: Schema331;
1039
+ };
1040
+ /**
1041
+ * Client configuration for OAuth client credentials
1042
+ */
1043
+ type ServerOAuthClientConfigurationClientCredentials = Schema330;
1044
+ type CredentialRefreshResponse = {
1045
+ id: Schema332;
1046
+ accessTokenExpiresAt: Schema333;
1047
+ };
1048
+ type PaginatedCredentialAuditLog = {
1049
+ pagination: Schema335;
1050
+ data: Schema342;
1051
+ };
1052
+ type CredentialAuditLog = {
1053
+ tenantId: Schema343;
1054
+ id: Schema344;
1055
+ credentialId: Schema345;
1056
+ userId: Schema346;
1057
+ eventName: Schema348;
1058
+ details: Schema349;
1059
+ createdAt: Schema352;
1060
+ updatedAt: Schema353;
1061
+ };
1062
+ type Schema173 = Array<Server>;
1063
+ /**
1064
+ * Unique ID of the server
1065
+ */
1066
+ type Schema174 = string;
1067
+ /**
1068
+ * URL-friendly name of the server, unique within the tenant
1069
+ */
1070
+ type Schema175 = string;
1071
+ /**
1072
+ * ID of the tenant that owns the server
1073
+ */
1074
+ type Schema176 = string;
1075
+ /**
1076
+ * Human-readable description of the server
1077
+ */
1078
+ type Schema177 = string;
1079
+ /**
1080
+ * Authorization configuration for the server
1081
+ */
1082
+ type Schema178 = ServerAuthorizationOutput;
1083
+ /**
1084
+ * Authorization method that the server uses
1085
+ */
1086
+ type Schema179 = 'none' | 'oauth' | 'oauth-client-credentials' | 'apikey';
1087
+ /**
1088
+ * Whether credentials are shared for the whole server or stored per user
1089
+ */
1090
+ type Schema180 = Schema181 | Schema182;
1091
+ type Schema181 = 'server';
1092
+ type Schema182 = 'user';
1093
+ /**
1094
+ * Names of the API keys that the server expects
1095
+ */
1096
+ type Schema183 = Schema184;
1097
+ type Schema184 = Array<string>;
1098
+ type Schema185 = 'server-scoped' | 'skip' | 'any';
1099
+ /**
1100
+ * Transport configuration used to connect to the server
1101
+ */
1102
+ type Schema186 = HttpStreamingTransportConfigOutput | StdioTransportConfigOutput | SseTransportConfigOutput | Schema223 | HostedTransportConfigOutput | OpenApiTransportConfigOutput;
1103
+ /**
1104
+ * Transport type discriminator, always "httpstreaming"
1105
+ */
1106
+ type Schema187 = 'httpstreaming';
1107
+ /**
1108
+ * URL of the MCP streamable HTTP endpoint
1109
+ */
1110
+ type Schema188 = string;
1111
+ /**
1112
+ * Extra HTTP headers to send with each request, as [name, value] pairs
1113
+ */
1114
+ type Schema189 = Schema190;
1115
+ type Schema190 = Array<[string, string]>;
1116
+ /**
1117
+ * Transport type discriminator, always "stdio"
1118
+ */
1119
+ type Schema191 = 'stdio';
1120
+ /**
1121
+ * Command line that starts the MCP server process
1122
+ */
1123
+ type Schema192 = string;
1124
+ /**
1125
+ * Docker image that the command runs in
1126
+ */
1127
+ type Schema193 = Schema194;
1128
+ type Schema194 = string;
1129
+ /**
1130
+ * Environment variables for the process, as [name, value] pairs
1131
+ */
1132
+ type Schema195 = Schema196;
1133
+ type Schema196 = Array<[string, string]>;
1134
+ /**
1135
+ * Protocol that the launched process speaks
1136
+ */
1137
+ type Schema197 = 'sse' | 'httpstreaming' | 'stdio';
1138
+ /**
1139
+ * Port that the process listens on when transport is HTTP-based
1140
+ */
1141
+ type Schema198 = Schema199 | null;
1142
+ type Schema199 = number;
1143
+ /**
1144
+ * URL path of the MCP endpoint when transport is HTTP-based
1145
+ */
1146
+ type Schema200 = Schema201 | null;
1147
+ type Schema201 = string;
1148
+ /**
1149
+ * HTTP health check configuration for the process
1150
+ */
1151
+ type Schema202 = Schema203;
1152
+ type Schema203 = {
1153
+ /**
1154
+ * Whether the health check is active
1155
+ */
1156
+ enabled: boolean;
1157
+ /**
1158
+ * URL that the health check polls
1159
+ */
1160
+ url: Schema204;
1161
+ /**
1162
+ * Seconds to wait before the first health check
1163
+ */
1164
+ delaySeconds: Schema205 | null;
1165
+ /**
1166
+ * Seconds between health checks
1167
+ */
1168
+ intervalSeconds: Schema206 | null;
1169
+ /**
1170
+ * Number of consecutive failures before the process counts as unhealthy
1171
+ */
1172
+ failureThreshold: Schema207 | null;
1173
+ };
1174
+ type Schema204 = string;
1175
+ type Schema205 = number;
1176
+ type Schema206 = number;
1177
+ type Schema207 = number;
1178
+ /**
1179
+ * Deprecated: former resource ceiling, no longer applied to deployments. Use requests to reserve capacity instead
1180
+ */
1181
+ type Schema208 = Schema209 | null;
1182
+ type Schema209 = {
1183
+ cpu?: Schema210;
1184
+ memory?: Schema211;
1185
+ };
1186
+ /**
1187
+ * CPU limit in Kubernetes quantity format (e.g. "500m" or "1")
1188
+ */
1189
+ type Schema210 = string;
1190
+ /**
1191
+ * Memory limit in Kubernetes quantity format (e.g. "512Mi" or "1Gi")
1192
+ */
1193
+ type Schema211 = string;
1194
+ /**
1195
+ * Resources reserved for the process: the minimum it is guaranteed when the hardware is busy. Overrides the organization default
1196
+ */
1197
+ type Schema212 = Schema213 | null;
1198
+ type Schema213 = {
1199
+ cpu?: Schema214;
1200
+ memory?: Schema215;
1201
+ };
1202
+ /**
1203
+ * CPU reserved for the deployment, in Kubernetes quantity format (e.g. "250m" or "1"). This is the minimum the deployment is guaranteed when the hardware is busy; when capacity is free it may use more. Reserved capacity counts against the organization total even while the server idles, so keep it at what the server needs, not what it may burst to
1204
+ */
1205
+ type Schema214 = string;
1206
+ /**
1207
+ * Memory reserved for the deployment, in Kubernetes quantity format (e.g. "384Mi" or "1Gi"). Unlike CPU this is also the hard ceiling: a process that exceeds it is terminated
1208
+ */
1209
+ type Schema215 = string;
1210
+ type Schema216 = {
1211
+ /**
1212
+ * Whether the server gets a persistent volume
1213
+ */
1214
+ enabled: boolean;
1215
+ };
1216
+ type Schema217 = {
1217
+ /**
1218
+ * Whether the server joins the tailnet
1219
+ */
1220
+ enabled: boolean;
1221
+ /**
1222
+ * Tailscale auth key that registers the machine. It is spent at the first registration and the machine identity is kept across restarts, so use a tagged key and do not make it ephemeral
1223
+ */
1224
+ authKey: string;
1225
+ /**
1226
+ * Machine name on the tailnet. Defaults to gatana-<server slug>
1227
+ */
1228
+ hostname?: Schema218 | null;
1229
+ };
1230
+ type Schema218 = string;
1231
+ /**
1232
+ * Transport type discriminator, always "sse"
1233
+ */
1234
+ type Schema219 = 'sse';
1235
+ /**
1236
+ * URL of the MCP SSE endpoint
1237
+ */
1238
+ type Schema220 = string;
1239
+ /**
1240
+ * Extra HTTP headers to send with each request, as [name, value] pairs
1241
+ */
1242
+ type Schema221 = Schema222;
1243
+ type Schema222 = Array<[string, string]>;
1244
+ type Schema223 = {
1245
+ /**
1246
+ * Transport type discriminator, always "self"
1247
+ */
1248
+ type: 'self';
1249
+ /**
1250
+ * ID of the built-in server implementation
1251
+ */
1252
+ id: string;
1253
+ };
1254
+ /**
1255
+ * Transport type discriminator, always "hosted"
1256
+ */
1257
+ type Schema224 = 'hosted';
1258
+ /**
1259
+ * Runtime that executes the hosted tool functions
1260
+ */
1261
+ type Schema225 = 'node24' | 'python313';
1262
+ /**
1263
+ * Environment variables for the hosted runtime, as [name, value] pairs
1264
+ */
1265
+ type Schema226 = Schema227;
1266
+ type Schema227 = Array<[string, string]>;
1267
+ /**
1268
+ * Deprecated: former resource ceiling, no longer applied to deployments. Use requests to reserve capacity instead
1269
+ */
1270
+ type Schema228 = Schema229 | null;
1271
+ type Schema229 = {
1272
+ cpu?: Schema210;
1273
+ memory?: Schema211;
1274
+ };
1275
+ /**
1276
+ * Resources reserved for the hosted runtime: the minimum it is guaranteed when the hardware is busy. Overrides the organization default
1277
+ */
1278
+ type Schema230 = Schema231 | null;
1279
+ type Schema231 = {
1280
+ cpu?: Schema214;
1281
+ memory?: Schema215;
1282
+ };
1283
+ type Schema232 = {
1284
+ /**
1285
+ * Whether the server gets a persistent volume
1286
+ */
1287
+ enabled: boolean;
1288
+ };
1289
+ type Schema233 = {
1290
+ /**
1291
+ * Whether the server joins the tailnet
1292
+ */
1293
+ enabled: boolean;
1294
+ /**
1295
+ * Tailscale auth key that registers the machine. It is spent at the first registration and the machine identity is kept across restarts, so use a tagged key and do not make it ephemeral
1296
+ */
1297
+ authKey: string;
1298
+ /**
1299
+ * Machine name on the tailnet. Defaults to gatana-<server slug>
1300
+ */
1301
+ hostname?: Schema234 | null;
1302
+ };
1303
+ type Schema234 = string;
1304
+ /**
1305
+ * Transport type discriminator, always "openapi"
1306
+ */
1307
+ type Schema235 = 'openapi';
1308
+ /**
1309
+ * How the OpenAPI spec is supplied: from a URL or as inline content
1310
+ */
1311
+ type Schema236 = 'specUrl' | 'spec';
1312
+ /**
1313
+ * URL to fetch the OpenAPI spec from, used when method is "specUrl"
1314
+ */
1315
+ type Schema237 = Schema238;
1316
+ type Schema238 = string | '';
1317
+ /**
1318
+ * Inline OpenAPI spec content, used when method is "spec"
1319
+ */
1320
+ type Schema239 = Schema240;
1321
+ type Schema240 = string;
1322
+ /**
1323
+ * Base URL for the API requests generated from the spec
1324
+ */
1325
+ type Schema241 = Schema242;
1326
+ type Schema242 = string | '';
1327
+ /**
1328
+ * Extra HTTP headers to send with each request, as [name, value] pairs
1329
+ */
1330
+ type Schema243 = Schema244;
1331
+ type Schema244 = Array<[string, string]>;
1332
+ /**
1333
+ * OAuth client configuration, or null when not configured
1334
+ */
1335
+ type Schema245 = Schema246 | ServerOAuthClientConfigurationOutput;
1336
+ type Schema246 = null;
1337
+ /**
1338
+ * OAuth client ID
1339
+ */
1340
+ type Schema247 = Schema248;
1341
+ type Schema248 = string;
1342
+ /**
1343
+ * OAuth client secret
1344
+ */
1345
+ type Schema249 = Schema250;
1346
+ type Schema250 = string;
1347
+ /**
1348
+ * OAuth grant type used to obtain tokens
1349
+ */
1350
+ type Schema251 = OAuthGrantType;
1351
+ /**
1352
+ * Client authentication method used at the token endpoint
1353
+ */
1354
+ type Schema252 = Schema253 | Schema254 | Schema255 | Schema256;
1355
+ type Schema253 = 'client_secret_basic';
1356
+ type Schema254 = 'client_secret_post';
1357
+ type Schema255 = 'none';
1358
+ type Schema256 = string;
1359
+ /**
1360
+ * Space-separated OAuth scopes to request
1361
+ */
1362
+ type Schema257 = Schema258;
1363
+ type Schema258 = string;
1364
+ /**
1365
+ * Discovered OAuth metadata, or null when not discovered
1366
+ */
1367
+ type Schema259 = Schema260 | ServerOAuthMetadataOutput;
1368
+ type Schema260 = null;
1369
+ /**
1370
+ * Discovered protected resource metadata (RFC 9728)
1371
+ */
1372
+ type Schema261 = Schema262;
1373
+ type Schema262 = {
1374
+ /**
1375
+ * Resource identifier from the protected resource metadata
1376
+ */
1377
+ id: Schema263;
1378
+ /**
1379
+ * Scopes that the protected resource supports
1380
+ */
1381
+ availableScopes: Schema264;
1382
+ /**
1383
+ * URL where the protected resource metadata was fetched from
1384
+ */
1385
+ metadataUrl: Schema265;
1386
+ };
1387
+ type Schema263 = string;
1388
+ type Schema264 = Array<string>;
1389
+ type Schema265 = string;
1390
+ /**
1391
+ * Discovered authorization server metadata (RFC 8414)
1392
+ */
1393
+ type Schema266 = Schema267;
1394
+ type Schema267 = {
1395
+ /**
1396
+ * Issuer identifier of the authorization server
1397
+ */
1398
+ issuer: Schema268;
1399
+ /**
1400
+ * URL of the authorization endpoint
1401
+ */
1402
+ authorizeEndpoint: Schema269;
1403
+ /**
1404
+ * URL of the device authorization endpoint
1405
+ */
1406
+ deviceAuthorizationEndpoint: Schema270;
1407
+ /**
1408
+ * URL of the token endpoint
1409
+ */
1410
+ tokenEndpoint: Schema271;
1411
+ /**
1412
+ * Extra query parameters to add to the authorization request
1413
+ */
1414
+ extraAuthorizationParameters: Schema272;
1415
+ /**
1416
+ * URL of the dynamic client registration endpoint
1417
+ */
1418
+ registrationEndpoint?: Schema273;
1419
+ /**
1420
+ * Whether the authorization server supports PKCE
1421
+ */
1422
+ supportsPKCE: Schema274;
1423
+ /**
1424
+ * Client authentication methods that the token endpoint supports
1425
+ */
1426
+ supportedClientAuthMethods: Schema275;
1427
+ /**
1428
+ * Whether the authorization server supports dynamic client registration
1429
+ */
1430
+ supportsDynamicClientRegistration: Schema276;
1431
+ /**
1432
+ * Reason why dynamic client registration is not available
1433
+ */
1434
+ noDynamicClientRegistrationReason?: Schema277;
1435
+ /**
1436
+ * URL of the authorization server documentation
1437
+ */
1438
+ serviceDocumentation: Schema278;
1439
+ /**
1440
+ * URL where the authorization server metadata was fetched from
1441
+ */
1442
+ metadataUrl: Schema279;
1443
+ /**
1444
+ * Scopes that the authorization server supports
1445
+ */
1446
+ availableScopes: Schema280;
1447
+ };
1448
+ type Schema268 = string;
1449
+ type Schema269 = string;
1450
+ type Schema270 = string;
1451
+ type Schema271 = string;
1452
+ type Schema272 = string;
1453
+ type Schema273 = string;
1454
+ type Schema274 = boolean;
1455
+ type Schema275 = Array<string>;
1456
+ type Schema276 = boolean;
1457
+ type Schema277 = string | null;
1458
+ type Schema278 = string;
1459
+ type Schema279 = string;
1460
+ type Schema280 = Array<string>;
1461
+ /**
1462
+ * Who can see the server: only members or the whole organization
1463
+ */
1464
+ type Schema281 = ServerVisibility;
1465
+ /**
1466
+ * Whether the server is enabled
1467
+ */
1468
+ type Schema282 = boolean;
1469
+ /**
1470
+ * Time of the last tool refresh, or null if tools were never refreshed
1471
+ */
1472
+ type Schema283 = Schema284 | null;
1473
+ type Schema284 = string;
1474
+ /**
1475
+ * Timeout in seconds for a single protocol request to the server
1476
+ */
1477
+ type Schema285 = number;
1478
+ /**
1479
+ * Total timeout in seconds for a tool call, including progress notifications
1480
+ */
1481
+ type Schema286 = number;
1482
+ /**
1483
+ * Whether a progress notification resets the protocol timeout
1484
+ */
1485
+ type Schema287 = boolean;
1486
+ /**
1487
+ * Whether large tool outputs are compressed before they are returned to the client
1488
+ */
1489
+ type Schema288 = boolean;
1490
+ /**
1491
+ * Whether the compression transform step is applied to tool outputs
1492
+ */
1493
+ type Schema289 = boolean;
1494
+ /**
1495
+ * Minimum output size in bytes before compression is applied
1496
+ */
1497
+ type Schema290 = number;
1498
+ /**
1499
+ * Firewall rules evaluated against tool calls to the server
1500
+ */
1501
+ type Schema291 = Array<Schema292>;
1502
+ type Schema292 = {
1503
+ /**
1504
+ * CEL representing the condition
1505
+ */
1506
+ condition: string;
1507
+ /**
1508
+ * Action to take when the condition matches
1509
+ */
1510
+ action: 'deny' | 'modify' | 'log';
1511
+ };
1512
+ /**
1513
+ * Time when the server was created
1514
+ */
1515
+ type Schema293 = string;
1516
+ /**
1517
+ * Time when the server was last updated
1518
+ */
1519
+ type Schema294 = string;
1520
+ type Schema295 = {
1521
+ /**
1522
+ * Credentials the caller can read, without secret values
1523
+ */
1524
+ credentials: Array<CredentialDtoV2>;
1525
+ };
1526
+ /**
1527
+ * Unique ID of the credential record
1528
+ */
1529
+ type Schema296 = string;
1530
+ /**
1531
+ * ID of the tenant that owns the credential
1532
+ */
1533
+ type Schema297 = string;
1534
+ /**
1535
+ * Scope that the credential applies to: server, user, or profile
1536
+ */
1537
+ type Schema298 = 'server' | 'user' | 'profile';
1538
+ /**
1539
+ * ID of the owning user, or null
1540
+ */
1541
+ type Schema299 = Schema300 | null;
1542
+ type Schema300 = string;
1543
+ /**
1544
+ * ID of the owning profile when scope is "profile", otherwise null
1545
+ */
1546
+ type Schema301 = Schema302 | null;
1547
+ type Schema302 = string;
1548
+ /**
1549
+ * Time when the credential was last used, or null if never used
1550
+ */
1551
+ type Schema303 = Schema304 | null;
1552
+ type Schema304 = string;
1553
+ /**
1554
+ * Time when the credential was authorized
1555
+ */
1556
+ type Schema305 = string;
1557
+ /**
1558
+ * Authorization method that the credential was created with
1559
+ */
1560
+ type Schema306 = 'oauth' | 'apikey' | 'oauth-client-credentials';
1561
+ /**
1562
+ * Time when the credential record was created
1563
+ */
1564
+ type Schema307 = string;
1565
+ /**
1566
+ * Time when the credential record was last updated
1567
+ */
1568
+ type Schema308 = string;
1569
+ /**
1570
+ * Slug of the server that the credential authorizes access to
1571
+ */
1572
+ type Schema309 = string;
1573
+ /**
1574
+ * Email address of the owning user, or null
1575
+ */
1576
+ type Schema310 = Schema311 | null;
1577
+ type Schema311 = string;
1578
+ /**
1579
+ * Display name of the owning user, or null
1580
+ */
1581
+ type Schema312 = Schema313 | null;
1582
+ type Schema313 = string;
1583
+ /**
1584
+ * Name of the owning profile, or null
1585
+ */
1586
+ type Schema314 = Schema315 | null;
1587
+ type Schema315 = string;
1588
+ /**
1589
+ * Credential type discriminator, always "apikey"
1590
+ */
1591
+ type Schema316 = 'apikey';
1592
+ /**
1593
+ * API keys as [name, value] pairs
1594
+ */
1595
+ type Schema317 = Array<Schema318>;
1596
+ type Schema318 = [string, string];
1597
+ /**
1598
+ * Credential type discriminator, always "oauth"
1599
+ */
1600
+ type Schema319 = 'oauth';
1601
+ /**
1602
+ * OAuth tokens obtained from the authorization flow
1603
+ */
1604
+ type Schema320 = Schema328;
1605
+ /**
1606
+ * OAuth access token
1607
+ */
1608
+ type Schema321 = string;
1609
+ /**
1610
+ * Expiry time of the access token, as a Unix epoch timestamp
1611
+ */
1612
+ type Schema322 = Schema323;
1613
+ type Schema323 = number;
1614
+ /**
1615
+ * OpenID Connect ID token, if the authorization server issued one
1616
+ */
1617
+ type Schema324 = Schema325;
1618
+ type Schema325 = string;
1619
+ /**
1620
+ * OAuth refresh token, if the authorization server issued one
1621
+ */
1622
+ type Schema326 = Schema327;
1623
+ type Schema327 = string;
1624
+ type Schema328 = {
1625
+ accessToken: Schema321;
1626
+ accessTokenExpiresAt?: Schema322;
1627
+ idToken?: Schema324;
1628
+ refreshToken?: Schema326;
1629
+ };
1630
+ /**
1631
+ * Credential type discriminator, always "oauth-client-credentials"
1632
+ */
1633
+ type Schema329 = 'oauth-client-credentials';
1634
+ type Schema330 = {
1635
+ clientId: Schema247;
1636
+ clientSecret: Schema249;
1637
+ clientAuthMethod: Schema252;
1638
+ scopes: Schema257;
1639
+ };
1640
+ /**
1641
+ * Cached tokenset for client credentials
1642
+ */
1643
+ type Schema331 = Schema328;
1644
+ /**
1645
+ * ID of the refreshed credential
1646
+ */
1647
+ type Schema332 = string;
1648
+ /**
1649
+ * Expiry time of the refreshed access token, as a Unix epoch timestamp, or null if unknown
1650
+ */
1651
+ type Schema333 = Schema334 | null;
1652
+ type Schema334 = number;
1653
+ /**
1654
+ * Pagination metadata
1655
+ */
1656
+ type Schema335 = {
1657
+ page: Schema336;
1658
+ limit: Schema337;
1659
+ total: Schema338;
1660
+ totalPages: Schema339;
1661
+ hasNext: Schema340;
1662
+ hasPrev: Schema341;
1663
+ };
1664
+ /**
1665
+ * Current page number
1666
+ */
1667
+ type Schema336 = number;
1668
+ /**
1669
+ * Maximum number of items per page
1670
+ */
1671
+ type Schema337 = number;
1672
+ /**
1673
+ * Total number of items across all pages
1674
+ */
1675
+ type Schema338 = number;
1676
+ /**
1677
+ * Total number of pages
1678
+ */
1679
+ type Schema339 = number;
1680
+ /**
1681
+ * Whether a next page exists
1682
+ */
1683
+ type Schema340 = boolean;
1684
+ /**
1685
+ * Whether a previous page exists
1686
+ */
1687
+ type Schema341 = boolean;
1688
+ /**
1689
+ * Items on the current page
1690
+ */
1691
+ type Schema342 = Array<CredentialAuditLog>;
1692
+ /**
1693
+ * ID of the tenant that owns the entry
1694
+ */
1695
+ type Schema343 = string;
1696
+ /**
1697
+ * Unique ID of the audit log entry
1698
+ */
1699
+ type Schema344 = string;
1700
+ /**
1701
+ * ID of the credential that the entry belongs to
1702
+ */
1703
+ type Schema345 = string;
1704
+ /**
1705
+ * ID of the user who performed the action, or null
1706
+ */
1707
+ type Schema346 = Schema347 | null;
1708
+ type Schema347 = string;
1709
+ /**
1710
+ * Name of the audited event (e.g. "create", "update", "delete")
1711
+ */
1712
+ type Schema348 = string;
1713
+ /**
1714
+ * Event-specific details; update events include a diff of the change
1715
+ */
1716
+ type Schema349 = { [key in Schema350]?: Schema351 };
1717
+ type Schema350 = string;
1718
+ type Schema351 = unknown;
1719
+ /**
1720
+ * Time when the entry was created
1721
+ */
1722
+ type Schema352 = string;
1723
+ /**
1724
+ * Time when the entry was last updated
1725
+ */
1726
+ type Schema353 = string;
1727
+ /**
1728
+ * Controls how tool refresh is authorized. "server-scoped" means only server-scoped credentials are required, "skip" means refresh is done without authorization, and "any" means any available credentials (server, user, profile) can be used. Defaults to "server-scoped".
1729
+ */
1730
+ type ToolRefreshCredentialPolicyOutput = Schema185;
1731
+ type ServerAuthorizationOutput = {
1732
+ method: Schema179;
1733
+ credentialsScope: Schema180;
1734
+ apikeys?: Schema183;
1735
+ toolRefreshCredentialPolicy: ToolRefreshCredentialPolicyOutput;
1736
+ };
1737
+ type HttpStreamingTransportConfigOutput = {
1738
+ type: Schema187;
1739
+ url: Schema188;
1740
+ headers?: Schema189;
1741
+ };
1742
+ type StdioTransportConfigOutput = {
1743
+ type: Schema191;
1744
+ command: Schema192;
1745
+ dockerImage?: Schema193;
1746
+ env?: Schema195;
1747
+ transport: Schema197;
1748
+ httpPort?: Schema198;
1749
+ urlPath?: Schema200;
1750
+ healthCheck?: Schema202;
1751
+ limits?: Schema208;
1752
+ requests?: Schema212;
1753
+ storage?: StdioTransportStorageOutput;
1754
+ tailscale?: StdioTransportTailscaleOutput;
1755
+ };
1756
+ /**
1757
+ * Persistent storage for the server. When enabled the server keeps one volume, mounted at the path in GATANA_DATA_DIR, which survives restarts and the idle stop. The size is fixed by the deployment and counts against the organization storage quota
1758
+ */
1759
+ type StdioTransportStorageOutput = Schema216 | null;
1760
+ /**
1761
+ * Egress-only Tailscale access. When enabled the server can open connections to hosts on your tailnet, and to the subnets its routers advertise. Nothing on the tailnet can reach the server
1762
+ */
1763
+ type StdioTransportTailscaleOutput = Schema217 | null;
1764
+ type SseTransportConfigOutput = {
1765
+ type: Schema219;
1766
+ url: Schema220;
1767
+ headers?: Schema221;
1768
+ };
1769
+ type HostedTransportConfigOutput = {
1770
+ type: Schema224;
1771
+ runtime: Schema225;
1772
+ env?: Schema226;
1773
+ limits?: Schema228;
1774
+ requests?: Schema230;
1775
+ storage?: HostedTransportStorageOutput;
1776
+ tailscale?: HostedTransportTailscaleOutput;
1777
+ };
1778
+ /**
1779
+ * Persistent storage for the server. When enabled the server keeps one volume, mounted at the path in GATANA_DATA_DIR, which survives restarts and the idle stop. The size is fixed by the deployment and counts against the organization storage quota
1780
+ */
1781
+ type HostedTransportStorageOutput = Schema232 | null;
1782
+ /**
1783
+ * Egress-only Tailscale access. When enabled the server can open connections to hosts on your tailnet, and to the subnets its routers advertise. Nothing on the tailnet can reach the server
1784
+ */
1785
+ type HostedTransportTailscaleOutput = Schema233 | null;
1786
+ type OpenApiTransportConfigOutput = {
1787
+ type: Schema235;
1788
+ method: Schema236;
1789
+ specUrl: Schema237;
1790
+ spec: Schema239;
1791
+ baseUrl: Schema241;
1792
+ headers?: Schema243;
1793
+ };
1794
+ type ServerOAuthClientConfigurationOutput = {
1795
+ clientId: Schema247;
1796
+ clientSecret: Schema249;
1797
+ grantType: Schema251;
1798
+ clientAuthMethod: Schema252;
1799
+ scopes: Schema257;
1800
+ };
1801
+ type ServerOAuthMetadataOutput = {
1802
+ resource?: Schema261;
1803
+ as?: Schema266;
1804
+ };
1805
+ type ListServersV2Data = {
1806
+ body?: never;
1807
+ path?: never;
1808
+ query?: never;
1809
+ url: '/servers';
1810
+ };
1811
+ type ListServersV2Responses = {
1812
+ /**
1813
+ * Successful response
1814
+ */
1815
+ 200: V2ListServersResponse;
1816
+ };
1817
+ type ListServersV2Response = ListServersV2Responses[keyof ListServersV2Responses];
1818
+ type CreateServerV2Data = {
1819
+ body?: V2CreateServerRequest;
1820
+ path?: never;
1821
+ query?: never;
1822
+ url: '/servers';
1823
+ };
1824
+ type CreateServerV2Responses = {
1825
+ /**
1826
+ * Successful response
1827
+ */
1828
+ 200: Server;
1829
+ };
1830
+ type CreateServerV2Response = CreateServerV2Responses[keyof CreateServerV2Responses];
1831
+ type DeleteServerV2Data = {
1832
+ body?: never;
1833
+ path: {
1834
+ slug: Schema140;
1835
+ };
1836
+ query?: never;
1837
+ url: '/servers/{slug}';
1838
+ };
1839
+ type DeleteServerV2Responses = {
1840
+ /**
1841
+ * Successful response
1842
+ */
1843
+ 200: unknown;
1844
+ };
1845
+ type GetServerV2Data = {
1846
+ body?: never;
1847
+ path: {
1848
+ slug: Schema140;
1849
+ };
1850
+ query?: never;
1851
+ url: '/servers/{slug}';
1852
+ };
1853
+ type GetServerV2Responses = {
1854
+ /**
1855
+ * Successful response
1856
+ */
1857
+ 200: Server;
1858
+ };
1859
+ type GetServerV2Response = GetServerV2Responses[keyof GetServerV2Responses];
1860
+ type PatchServerV2Data = {
1861
+ body?: V2PatchServerRequest;
1862
+ path: {
1863
+ slug: Schema140;
1864
+ };
1865
+ query?: never;
1866
+ url: '/servers/{slug}';
1867
+ };
1868
+ type PatchServerV2Responses = {
1869
+ /**
1870
+ * Successful response
1871
+ */
1872
+ 200: Server;
1873
+ };
1874
+ type PatchServerV2Response = PatchServerV2Responses[keyof PatchServerV2Responses];
1875
+ type UpdateServerV2Data = {
1876
+ body?: V2UpdateServerRequest;
1877
+ path: {
1878
+ slug: Schema140;
1879
+ };
1880
+ query?: never;
1881
+ url: '/servers/{slug}';
1882
+ };
1883
+ type UpdateServerV2Responses = {
1884
+ /**
1885
+ * Successful response
1886
+ */
1887
+ 200: Server;
1888
+ };
1889
+ type UpdateServerV2Response = UpdateServerV2Responses[keyof UpdateServerV2Responses];
1890
+ type ListCredentialsV2Data = {
1891
+ body?: never;
1892
+ path?: never;
1893
+ query?: {
1894
+ /**
1895
+ * Filter to credentials of a single server, by server ID
1896
+ */
1897
+ serverId?: Schema172;
1898
+ };
1899
+ url: '/credentials';
1900
+ };
1901
+ type ListCredentialsV2Responses = {
1902
+ /**
1903
+ * Successful response
1904
+ */
1905
+ 200: Schema295;
1906
+ };
1907
+ type ListCredentialsV2Response = ListCredentialsV2Responses[keyof ListCredentialsV2Responses];
1908
+ type DeleteCredentialV2Data = {
1909
+ body?: never;
1910
+ path: {
1911
+ /**
1912
+ * ID of the credential
1913
+ */
1914
+ id: string;
1915
+ };
1916
+ query?: never;
1917
+ url: '/credentials/{id}';
1918
+ };
1919
+ type DeleteCredentialV2Responses = {
1920
+ /**
1921
+ * Successful response
1922
+ */
1923
+ 200: Schema295;
1924
+ };
1925
+ type DeleteCredentialV2Response = DeleteCredentialV2Responses[keyof DeleteCredentialV2Responses];
1926
+ type GetCredentialV2Data = {
1927
+ body?: never;
1928
+ path: {
1929
+ /**
1930
+ * ID of the credential
1931
+ */
1932
+ id: string;
1933
+ };
1934
+ query?: never;
1935
+ url: '/credentials/{id}';
1936
+ };
1937
+ type GetCredentialV2Responses = {
1938
+ /**
1939
+ * Successful response
1940
+ */
1941
+ 200: CredentialDtoV2;
1942
+ };
1943
+ type GetCredentialV2Response = GetCredentialV2Responses[keyof GetCredentialV2Responses];
1944
+ type GetCredentialSecretV2Data = {
1945
+ body?: never;
1946
+ path: {
1947
+ /**
1948
+ * ID of the credential
1949
+ */
1950
+ id: string;
1951
+ };
1952
+ query?: never;
1953
+ url: '/credentials/{id}/secret';
1954
+ };
1955
+ type GetCredentialSecretV2Responses = {
1956
+ /**
1957
+ * Successful response
1958
+ */
1959
+ 200: ServerCredentialsCredential;
1960
+ };
1961
+ type GetCredentialSecretV2Response = GetCredentialSecretV2Responses[keyof GetCredentialSecretV2Responses];
1962
+ type RefreshCredentialV2Data = {
1963
+ body?: never;
1964
+ path: {
1965
+ /**
1966
+ * ID of the credential
1967
+ */
1968
+ id: string;
1969
+ };
1970
+ query?: never;
1971
+ url: '/credentials/{id}/refresh';
1972
+ };
1973
+ type RefreshCredentialV2Responses = {
1974
+ /**
1975
+ * Successful response
1976
+ */
1977
+ 200: CredentialRefreshResponse;
1978
+ };
1979
+ type RefreshCredentialV2Response = RefreshCredentialV2Responses[keyof RefreshCredentialV2Responses];
1980
+ type ListCredentialAuditLogsV2Data = {
1981
+ body?: never;
1982
+ path: {
1983
+ /**
1984
+ * ID of the credential
1985
+ */
1986
+ credentialId: string;
1987
+ };
1988
+ query?: never;
1989
+ url: '/credentials/{credentialId}/audit-logs';
1990
+ };
1991
+ type ListCredentialAuditLogsV2Responses = {
1992
+ /**
1993
+ * Successful response
1994
+ */
1995
+ 200: PaginatedCredentialAuditLog;
1996
+ };
1997
+ type ListCredentialAuditLogsV2Response = ListCredentialAuditLogsV2Responses[keyof ListCredentialAuditLogsV2Responses];
1998
+ type GetCredentialAuditLogV2Data = {
1999
+ body?: never;
2000
+ path: {
2001
+ /**
2002
+ * ID of the credential
2003
+ */
2004
+ credentialId: string;
2005
+ /**
2006
+ * ID of the audit log entry
2007
+ */
2008
+ auditLogId: string;
2009
+ };
2010
+ query?: never;
2011
+ url: '/credentials/{credentialId}/audit-logs/{auditLogId}';
2012
+ };
2013
+ type GetCredentialAuditLogV2Responses = {
2014
+ /**
2015
+ * Successful response
2016
+ */
2017
+ 200: CredentialAuditLog;
2018
+ };
2019
+ type GetCredentialAuditLogV2Response = GetCredentialAuditLogV2Responses[keyof GetCredentialAuditLogV2Responses];
2020
+ declare namespace sdk_gen_d_exports {
2021
+ export { Options, createServerV2, deleteCredentialV2, deleteServerV2, getCredentialAuditLogV2, getCredentialSecretV2, getCredentialV2, getServerV2, listCredentialAuditLogsV2, listCredentialsV2, listServersV2, patchServerV2, refreshCredentialV2, updateServerV2 };
2022
+ }
2023
+ type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown> = Options$1<TData, ThrowOnError, TResponse> & {
2024
+ /**
2025
+ * You can provide a client instance returned by `createClient()` instead of
2026
+ * individual options. This might be also useful if you want to implement a
2027
+ * custom client.
2028
+ */
2029
+ client?: Client;
2030
+ /**
2031
+ * You can pass arbitrary values through the `meta` object. This can be
2032
+ * used to access values that aren't defined as part of the SDK function.
2033
+ */
2034
+ meta?: Record<string, unknown>;
2035
+ };
2036
+ /**
2037
+ * List all MCP servers the caller has access to
2038
+ */
2039
+ declare const listServersV2: <ThrowOnError extends boolean = true>(options?: Options<ListServersV2Data, ThrowOnError>) => RequestResult<ListServersV2Responses, unknown, ThrowOnError, "fields">;
2040
+ /**
2041
+ * Create a new MCP server. Requires `slug` and `transportConfig`. All other fields are optional with sensible defaults. Read-only fields are silently ignored
2042
+ */
2043
+ declare const createServerV2: <ThrowOnError extends boolean = true>(options?: Options<CreateServerV2Data, ThrowOnError>) => RequestResult<CreateServerV2Responses, unknown, ThrowOnError, "fields">;
2044
+ /**
2045
+ * Delete an MCP server
2046
+ */
2047
+ declare const deleteServerV2: <ThrowOnError extends boolean = true>(options: Options<DeleteServerV2Data, ThrowOnError>) => RequestResult<DeleteServerV2Responses, unknown, ThrowOnError, "fields">;
2048
+ /**
2049
+ * Get a single MCP server. The response body can be PUT back to update the server
2050
+ */
2051
+ declare const getServerV2: <ThrowOnError extends boolean = true>(options: Options<GetServerV2Data, ThrowOnError>) => RequestResult<GetServerV2Responses, unknown, ThrowOnError, "fields">;
2052
+ /**
2053
+ * Partially update an MCP server using JSON Merge Patch (RFC 7396). Send only the fields to change. Explicit `null` clears nullable fields (oauthMetadata, oauthClientConfiguration). Absent fields are untouched. Read-only fields are silently ignored
2054
+ */
2055
+ declare const patchServerV2: <ThrowOnError extends boolean = true>(options: Options<PatchServerV2Data, ThrowOnError>) => RequestResult<PatchServerV2Responses, unknown, ThrowOnError, "fields">;
2056
+ /**
2057
+ * Update an MCP server. Accepts the full server object from GET; read-only fields (id, tenantId, createdAt, updatedAt, lastToolRefreshAt) are silently ignored. Supports updating isEnabled, authorization, and config in a single call
2058
+ */
2059
+ declare const updateServerV2: <ThrowOnError extends boolean = true>(options: Options<UpdateServerV2Data, ThrowOnError>) => RequestResult<UpdateServerV2Responses, unknown, ThrowOnError, "fields">;
2060
+ /**
2061
+ * List the credentials the caller can read, optionally filtered by server. Secret values are not included
2062
+ */
2063
+ declare const listCredentialsV2: <ThrowOnError extends boolean = true>(options?: Options<ListCredentialsV2Data, ThrowOnError>) => RequestResult<ListCredentialsV2Responses, unknown, ThrowOnError, "fields">;
2064
+ /**
2065
+ * Delete a credential. Requires the delete permission on the credential
2066
+ */
2067
+ declare const deleteCredentialV2: <ThrowOnError extends boolean = true>(options: Options<DeleteCredentialV2Data, ThrowOnError>) => RequestResult<DeleteCredentialV2Responses, unknown, ThrowOnError, "fields">;
2068
+ /**
2069
+ * Get a credential by ID. Secret values are not included
2070
+ */
2071
+ declare const getCredentialV2: <ThrowOnError extends boolean = true>(options: Options<GetCredentialV2Data, ThrowOnError>) => RequestResult<GetCredentialV2Responses, unknown, ThrowOnError, "fields">;
2072
+ /**
2073
+ * Reveal the secret values of a credential. Requires the read-secret permission on the credential
2074
+ */
2075
+ declare const getCredentialSecretV2: <ThrowOnError extends boolean = true>(options: Options<GetCredentialSecretV2Data, ThrowOnError>) => RequestResult<GetCredentialSecretV2Responses, unknown, ThrowOnError, "fields">;
2076
+ /**
2077
+ * Refresh the OAuth tokens of a credential and store the new token set. Only OAuth credentials can be refreshed, and the read-secret permission is required
2078
+ */
2079
+ declare const refreshCredentialV2: <ThrowOnError extends boolean = true>(options: Options<RefreshCredentialV2Data, ThrowOnError>) => RequestResult<RefreshCredentialV2Responses, unknown, ThrowOnError, "fields">;
2080
+ /**
2081
+ * List the audit log entries of a credential, paginated. Requires the read-secret permission on the credential
2082
+ */
2083
+ declare const listCredentialAuditLogsV2: <ThrowOnError extends boolean = true>(options: Options<ListCredentialAuditLogsV2Data, ThrowOnError>) => RequestResult<ListCredentialAuditLogsV2Responses, unknown, ThrowOnError, "fields">;
2084
+ /**
2085
+ * Get a single audit log entry of a credential. Requires the read-secret permission on the credential
2086
+ */
2087
+ declare const getCredentialAuditLogV2: <ThrowOnError extends boolean = true>(options: Options<GetCredentialAuditLogV2Data, ThrowOnError>) => RequestResult<GetCredentialAuditLogV2Responses, unknown, ThrowOnError, "fields">;
2088
+ //#endregion
2089
+ export { ListCredentialsV2Responses as $, Schema329 as $a, Schema280 as $i, Schema183 as $n, Schema6 as $o, Schema231 as $r, ServerOAuthMetadata as $s, Schema134 as $t, GetCredentialAuditLogV2Responses as A, Schema308 as Aa, Schema26 as Ai, Schema162 as An, Schema39 as Ao, Schema210 as Ar, Schema88 as As, Schema113 as At, HostedTransportConfig as B, Schema317 as Ba, Schema269 as Bi, Schema171 as Bn, Schema48 as Bo, Schema22 as Br, Schema97 as Bs, Schema122 as Bt, DeleteCredentialV2Data as C, Schema301 as Ca, Schema253 as Ci, Schema156 as Cn, Schema350 as Co, Schema204 as Cr, Schema81 as Cs, Schema107 as Ct, DeleteServerV2Responses as D, Schema305 as Da, Schema257 as Di, Schema16 as Dn, Schema36 as Do, Schema208 as Dr, Schema85 as Ds, Schema110 as Dt, DeleteServerV2Data as E, Schema304 as Ea, Schema256 as Ei, Schema159 as En, Schema353 as Eo, Schema207 as Er, Schema84 as Es, Schema11 as Et, GetCredentialV2Response as F, Schema312 as Fa, Schema264 as Fi, Schema167 as Fn, Schema43 as Fo, Schema215 as Fr, Schema92 as Fs, Schema118 as Ft, HostedTransportTailscaleOutput as G, Schema321 as Ga, Schema273 as Gi, Schema176 as Gn, Schema52 as Go, Schema224 as Gr, ServerAuthorizationOutput as Gs, Schema127 as Gt, HostedTransportStorage as H, Schema319 as Ha, Schema270 as Hi, Schema173 as Hn, Schema5 as Ho, Schema221 as Hr, Schema99 as Hs, Schema124 as Ht, GetCredentialV2Responses as I, Schema313 as Ia, Schema265 as Ii, Schema168 as In, Schema44 as Io, Schema216 as Ir, Schema93 as Is, Schema119 as It, ListCredentialAuditLogsV2Data as J, Schema324 as Ja, Schema276 as Ji, Schema179 as Jn, Schema55 as Jo, Schema227 as Jr, ServerCredentialsOauthClientCredentials as Js, Schema13 as Jt, HttpStreamingTransportConfig as K, Schema322 as Ka, Schema274 as Ki, Schema177 as Kn, Schema53 as Ko, Schema225 as Kr, ServerCredentialsApiKeys as Ks, Schema128 as Kt, GetServerV2Data as L, Schema314 as La, Schema266 as Li, Schema169 as Ln, Schema45 as Lo, Schema217 as Lr, Schema94 as Ls, Schema12 as Lt, GetCredentialSecretV2Response as M, Schema31 as Ma, Schema261 as Mi, Schema164 as Mn, Schema40 as Mo, Schema212 as Mr, Schema9 as Ms, Schema115 as Mt, GetCredentialSecretV2Responses as N, Schema310 as Na, Schema262 as Ni, Schema165 as Nn, Schema41 as No, Schema213 as Nr, Schema90 as Ns, Schema116 as Nt, GetCredentialAuditLogV2Data as O, Schema306 as Oa, Schema258 as Oi, Schema160 as On, Schema37 as Oo, Schema209 as Or, Schema86 as Os, Schema111 as Ot, GetCredentialV2Data as P, Schema311 as Pa, Schema263 as Pi, Schema166 as Pn, Schema42 as Po, Schema214 as Pr, Schema91 as Ps, Schema117 as Pt, ListCredentialsV2Response as Q, Schema328 as Qa, Schema28 as Qi, Schema182 as Qn, Schema59 as Qo, Schema230 as Qr, ServerOAuthClientConfigurationOutput as Qs, Schema133 as Qt, GetServerV2Response as R, Schema315 as Ra, Schema267 as Ri, Schema17 as Rn, Schema46 as Ro, Schema218 as Rr, Schema95 as Rs, Schema120 as Rt, CredentialRefreshResponse as S, Schema300 as Sa, Schema252 as Si, Schema155 as Sn, Schema35 as So, Schema203 as Sr, Schema80 as Ss, Schema106 as St, DeleteCredentialV2Responses as T, Schema303 as Ta, Schema255 as Ti, Schema158 as Tn, Schema352 as To, Schema206 as Tr, Schema83 as Ts, Schema109 as Tt, HostedTransportStorageOutput as U, Schema32 as Ua, Schema271 as Ui, Schema174 as Un, Schema50 as Uo, Schema222 as Ur, Server as Us, Schema125 as Ut, HostedTransportConfigOutput as V, Schema318 as Va, Schema27 as Vi, Schema172 as Vn, Schema49 as Vo, Schema220 as Vr, Schema98 as Vs, Schema123 as Vt, HostedTransportTailscale as W, Schema320 as Wa, Schema272 as Wi, Schema175 as Wn, Schema51 as Wo, Schema223 as Wr, ServerAuthorization as Ws, Schema126 as Wt, ListCredentialAuditLogsV2Responses as X, Schema326 as Xa, Schema278 as Xi, Schema180 as Xn, Schema57 as Xo, Schema229 as Xr, ServerOAuthClientConfiguration as Xs, Schema131 as Xt, ListCredentialAuditLogsV2Response as Y, Schema325 as Ya, Schema277 as Yi, Schema18 as Yn, Schema56 as Yo, Schema228 as Yr, ServerCredentialsOauthTokens as Ys, Schema130 as Yt, ListCredentialsV2Data as Z, Schema327 as Za, Schema279 as Zi, Schema181 as Zn, Schema58 as Zo, Schema23 as Zr, ServerOAuthClientConfigurationClientCredentials as Zs, Schema132 as Zt, CreateServerV2Data as _, Schema297 as _a, V2PatchServerRequest as _c, Schema248 as _i, Schema150 as _n, Schema345 as _o, Schema2 as _r, Schema76 as _s, Schema101 as _t, getCredentialAuditLogV2 as a, Schema286 as aa, StdioTransportConfigOutput as ac, Schema237 as ai, Schema14 as an, Schema334 as ao, Schema189 as ar, Schema65 as as, OpenApiTransportConfigOutput as at, CredentialAuditLog as b, Schema3 as ba, Schema250 as bi, Schema153 as bn, Schema348 as bo, Schema201 as br, Schema79 as bs, Schema104 as bt, getServerV2 as c, Schema289 as ca, StdioTransportTailscale as cc, Schema24 as ci, Schema142 as cn, Schema337 as co, Schema191 as cr, Schema68 as cs, PatchServerV2Response as ct, listServersV2 as d, Schema291 as da, ToolRefreshCredentialPolicyOutput as dc, Schema242 as di, Schema145 as dn, Schema34 as do, Schema194 as dr, Schema70 as ds, RefreshCredentialV2Response as dt, Schema281 as ea, ServerOAuthMetadataOutput as ec, Schema232 as ei, Schema135 as en, Schema33 as eo, Schema184 as er, Schema60 as es, ListServersV2Data as et, patchServerV2 as f, Schema292 as fa, UpdateServerV2Data as fc, Schema243 as fi, Schema146 as fn, Schema340 as fo, Schema195 as fr, Schema71 as fs, RefreshCredentialV2Responses as ft, ClientOptions as g, Schema296 as ga, V2ListServersResponse as gc, Schema247 as gi, Schema15 as gn, Schema344 as go, Schema199 as gr, Schema75 as gs, Schema100 as gt, updateServerV2 as h, Schema295 as ha, V2CreateServerRequest as hc, Schema246 as hi, Schema149 as hn, Schema343 as ho, Schema198 as hr, Schema74 as hs, Schema10 as ht, deleteServerV2 as i, Schema285 as ia, StdioTransportConfig as ic, Schema236 as ii, Schema139 as in, Schema333 as io, Schema188 as ir, Schema64 as is, OpenApiTransportConfig as it, GetCredentialSecretV2Data as j, Schema309 as ja, Schema260 as ji, Schema163 as jn, Schema4 as jo, Schema211 as jr, Schema89 as js, Schema114 as jt, GetCredentialAuditLogV2Response as k, Schema307 as ka, Schema259 as ki, Schema161 as kn, Schema38 as ko, Schema21 as kr, Schema87 as ks, Schema112 as kt, listCredentialAuditLogsV2 as l, Schema29 as la, StdioTransportTailscaleOutput as lc, Schema240 as li, Schema143 as ln, Schema338 as lo, Schema192 as lr, Schema69 as ls, PatchServerV2Responses as lt, sdk_gen_d_exports as m, Schema294 as ma, UpdateServerV2Responses as mc, Schema245 as mi, Schema148 as mn, Schema342 as mo, Schema197 as mr, Schema73 as ms, Schema1 as mt, createServerV2 as n, Schema283 as na, SseTransportConfig as nc, Schema234 as ni, Schema137 as nn, Schema331 as no, Schema186 as nr, Schema62 as ns, ListServersV2Responses as nt, getCredentialSecretV2 as o, Schema287 as oa, StdioTransportStorage as oc, Schema238 as oi, Schema140 as on, Schema335 as oo, Schema19 as or, Schema66 as os, PaginatedCredentialAuditLog as ot, refreshCredentialV2 as p, Schema293 as pa, UpdateServerV2Response as pc, Schema244 as pi, Schema147 as pn, Schema341 as po, Schema196 as pr, Schema72 as ps, Schema0 as pt, HttpStreamingTransportConfigOutput as q, Schema323 as qa, Schema275 as qi, Schema178 as qn, Schema54 as qo, Schema226 as qr, ServerCredentialsCredential as qs, Schema129 as qt, deleteCredentialV2 as r, Schema284 as ra, SseTransportConfigOutput as rc, Schema235 as ri, Schema138 as rn, Schema332 as ro, Schema187 as rr, Schema63 as rs, OAuthGrantType as rt, getCredentialV2 as s, Schema288 as sa, StdioTransportStorageOutput as sc, Schema239 as si, Schema141 as sn, Schema336 as so, Schema190 as sr, Schema67 as ss, PatchServerV2Data as st, Options as t, Schema282 as ta, ServerVisibility as tc, Schema233 as ti, Schema136 as tn, Schema330 as to, Schema185 as tr, Schema61 as ts, ListServersV2Response as tt, listCredentialsV2 as u, Schema290 as ua, ToolRefreshCredentialPolicy as uc, Schema241 as ui, Schema144 as un, Schema339 as uo, Schema193 as ur, Schema7 as us, RefreshCredentialV2Data as ut, CreateServerV2Response as v, Schema298 as va, V2ServerDto as vc, Schema249 as vi, Schema151 as vn, Schema346 as vo, Schema20 as vr, Schema77 as vs, Schema102 as vt, DeleteCredentialV2Response as w, Schema302 as wa, Schema254 as wi, Schema157 as wn, Schema351 as wo, Schema205 as wr, Schema82 as ws, Schema108 as wt, CredentialDtoV2 as x, Schema30 as xa, Schema251 as xi, Schema154 as xn, Schema349 as xo, Schema202 as xr, Schema8 as xs, Schema105 as xt, CreateServerV2Responses as y, Schema299 as ya, V2UpdateServerRequest as yc, Schema25 as yi, Schema152 as yn, Schema347 as yo, Schema200 as yr, Schema78 as ys, Schema103 as yt, GetServerV2Responses as z, Schema316 as za, Schema268 as zi, Schema170 as zn, Schema47 as zo, Schema219 as zr, Schema96 as zs, Schema121 as zt };
2090
+ //# sourceMappingURL=sdk.gen-Crii0E1f.d.mts.map