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,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-Do_HFvZj.d.cts.map
|