@ktmcp/apicurio 1.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/README.md +31 -0
- package/dist/index.d.ts +2 -0
- package/dist/index.js +4558 -0
- package/package.json +35 -0
package/dist/index.js
ADDED
|
@@ -0,0 +1,4558 @@
|
|
|
1
|
+
#!/usr/bin/env node
|
|
2
|
+
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
|
|
3
|
+
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
|
|
4
|
+
import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
|
|
5
|
+
const API_SPEC = {
|
|
6
|
+
"openapi": "3.0.2",
|
|
7
|
+
"servers": [
|
|
8
|
+
{
|
|
9
|
+
"url": "http://apicurio.local"
|
|
10
|
+
}
|
|
11
|
+
],
|
|
12
|
+
"info": {
|
|
13
|
+
"contact": {
|
|
14
|
+
"email": "apicurio@lists.jboss.org",
|
|
15
|
+
"name": "Apicurio",
|
|
16
|
+
"url": "https://github.com/apicurio/apicurio-registry"
|
|
17
|
+
},
|
|
18
|
+
"description": "Apicurio Registry is a datastore for standard event schemas and API designs. Apicurio Registry enables developers to manage and share the structure of their data using a REST interface. For example, client applications can dynamically push or pull the latest updates to or from the registry without needing to redeploy. Apicurio Registry also enables developers to create rules that govern how registry content can evolve over time. For example, this includes rules for content validation and version compatibility.\n\nThe Apicurio Registry REST API enables client applications to manage the artifacts in the registry. This API provides create, read, update, and delete operations for schema and API artifacts, rules, versions, and metadata. \n\nThe supported artifact types include:\n- Apache Avro schema\n- AsyncAPI specification\n- Google protocol buffers\n- GraphQL schema\n- JSON Schema\n- Kafka Connect schema\n- OpenAPI specification\n- Web Services Description Language\n- XML Schema Definition\n\n\n**Important**: The Apicurio Registry REST API is available from `https://MY-REGISTRY-URL/apis/registry/v2` by default. Therefore you must prefix all API operation paths with `../apis/registry/v2` in this case. For example: `../apis/registry/v2/ids/globalIds/{globalId}`.\n",
|
|
19
|
+
"license": {
|
|
20
|
+
"name": "Apache 2.0",
|
|
21
|
+
"url": "https://www.apache.org/licenses/LICENSE-2.0"
|
|
22
|
+
},
|
|
23
|
+
"title": "Apicurio Registry API [v2]",
|
|
24
|
+
"version": "2.4.x",
|
|
25
|
+
"x-apisguru-categories": [
|
|
26
|
+
"developer_tools"
|
|
27
|
+
],
|
|
28
|
+
"x-origin": [
|
|
29
|
+
{
|
|
30
|
+
"format": "openapi",
|
|
31
|
+
"url": "https://raw.githubusercontent.com/Apicurio/apicurio-registry/master/app/src/main/resources-unfiltered/META-INF/resources/api-specifications/registry/v2/openapi.json",
|
|
32
|
+
"version": "3.0"
|
|
33
|
+
}
|
|
34
|
+
],
|
|
35
|
+
"x-preferred": true,
|
|
36
|
+
"x-providerName": "apicurio.local",
|
|
37
|
+
"x-serviceName": "registry",
|
|
38
|
+
"x-logo": {
|
|
39
|
+
"url": "https://api.apis.guru/v2/cache/logo/https_apis.guru_assets_images_no-logo.svg"
|
|
40
|
+
}
|
|
41
|
+
},
|
|
42
|
+
"tags": [
|
|
43
|
+
{
|
|
44
|
+
"description": "The primary way to interact with the Apicurio Registry API is to add, update, \nor delete artifacts. This section includes all of these primary operations.",
|
|
45
|
+
"name": "Artifacts"
|
|
46
|
+
},
|
|
47
|
+
{
|
|
48
|
+
"description": "Sometimes the metadata for an artifact is important. For example, metadata includes \nwhen the artifact was created, last updated, and so on. This section contains \noperations to access (and in some cases change) an artifact's metadata.",
|
|
49
|
+
"name": "Metadata"
|
|
50
|
+
},
|
|
51
|
+
{
|
|
52
|
+
"description": "When artifact content is updated, old versions of the artifact content are not lost. All versions can be listed and accessed if necessary. This section describes the operations used to list and access all versions of an artifact's content and metadata.",
|
|
53
|
+
"name": "Versions"
|
|
54
|
+
},
|
|
55
|
+
{
|
|
56
|
+
"description": "Rules can be configured on a per-artifact basis, allowing for different approaches\nto content evolution for each artifact. These rules override any global rules\nthat have been configured. This section contains the operations used to manage a\nsingle artifact's rules.",
|
|
57
|
+
"name": "Artifact rules"
|
|
58
|
+
},
|
|
59
|
+
{
|
|
60
|
+
"description": "Global rules can be configured in the registry to govern how artifact content can \nevolve over time (as artifact content is **updated**). Global rules are applied \nwhenever an artifact is added to the registry, and also whenever an artifact's \ncontent is updated (only if that artifact does not have its own specific rules \nconfigured). This section describes the operations used to manage the global rules.",
|
|
61
|
+
"name": "Global rules"
|
|
62
|
+
},
|
|
63
|
+
{
|
|
64
|
+
"description": "The search API is used to browse or find artifacts in the registry. This section describes the operations for searching for artifacts and versions. ",
|
|
65
|
+
"name": "Search"
|
|
66
|
+
},
|
|
67
|
+
{
|
|
68
|
+
"description": "Application functionality that is only accessible to admin users. Includes logging, global rules, and export/import of registry data.",
|
|
69
|
+
"name": "Admin"
|
|
70
|
+
},
|
|
71
|
+
{
|
|
72
|
+
"description": "System level functionality, including versioning and status information.",
|
|
73
|
+
"name": "System"
|
|
74
|
+
},
|
|
75
|
+
{
|
|
76
|
+
"description": "Operations related to users.",
|
|
77
|
+
"name": "Users"
|
|
78
|
+
},
|
|
79
|
+
{
|
|
80
|
+
"description": "Registry artifacts can be collected together using groups. This section includes all of the primary operations related to groups.",
|
|
81
|
+
"name": "Groups"
|
|
82
|
+
}
|
|
83
|
+
],
|
|
84
|
+
"paths": {
|
|
85
|
+
"/admin/artifactTypes": {
|
|
86
|
+
"get": {
|
|
87
|
+
"description": "Gets a list of all the configured artifact types.\n\nThis operation can fail for the following reasons:\n\n* A server error occurred (HTTP error `500`)\n",
|
|
88
|
+
"operationId": "listArtifactTypes",
|
|
89
|
+
"responses": {
|
|
90
|
+
"200": {
|
|
91
|
+
"content": {
|
|
92
|
+
"application/json": {
|
|
93
|
+
"schema": {
|
|
94
|
+
"items": {
|
|
95
|
+
"$ref": "#/components/schemas/ArtifactTypeInfo"
|
|
96
|
+
},
|
|
97
|
+
"type": "array"
|
|
98
|
+
}
|
|
99
|
+
}
|
|
100
|
+
},
|
|
101
|
+
"description": "The list of available artifact types."
|
|
102
|
+
},
|
|
103
|
+
"500": {
|
|
104
|
+
"$ref": "#/components/responses/ServerError"
|
|
105
|
+
}
|
|
106
|
+
},
|
|
107
|
+
"summary": "List artifact types",
|
|
108
|
+
"tags": [
|
|
109
|
+
"Artifact Type",
|
|
110
|
+
"Admin"
|
|
111
|
+
]
|
|
112
|
+
},
|
|
113
|
+
"summary": "The list of artifact types supported by this instance of Registry."
|
|
114
|
+
},
|
|
115
|
+
"/admin/config/properties": {
|
|
116
|
+
"get": {
|
|
117
|
+
"description": "Returns a list of all configuration properties that have been set. The list is not paged.\n\nThis operation may fail for one of the following reasons:\n\n* A server error occurred (HTTP error `500`)\n",
|
|
118
|
+
"operationId": "listConfigProperties",
|
|
119
|
+
"responses": {
|
|
120
|
+
"200": {
|
|
121
|
+
"content": {
|
|
122
|
+
"application/json": {
|
|
123
|
+
"schema": {
|
|
124
|
+
"items": {
|
|
125
|
+
"$ref": "#/components/schemas/ConfigurationProperty"
|
|
126
|
+
},
|
|
127
|
+
"type": "array"
|
|
128
|
+
}
|
|
129
|
+
}
|
|
130
|
+
},
|
|
131
|
+
"description": "On a successful response, returns a list of configuration properties."
|
|
132
|
+
},
|
|
133
|
+
"500": {
|
|
134
|
+
"$ref": "#/components/responses/ServerError"
|
|
135
|
+
}
|
|
136
|
+
},
|
|
137
|
+
"summary": "List all configuration properties",
|
|
138
|
+
"tags": [
|
|
139
|
+
"Admin"
|
|
140
|
+
]
|
|
141
|
+
},
|
|
142
|
+
"summary": "Manage configuration properties."
|
|
143
|
+
},
|
|
144
|
+
"/admin/config/properties/{propertyName}": {
|
|
145
|
+
"delete": {
|
|
146
|
+
"description": "Resets the value of a single configuration property. This will return the property to\nits default value (see external documentation for supported properties and their default\nvalues).\n\nThis operation may fail for one of the following reasons:\n\n* Property not found or not configured (HTTP error `404`)\n* A server error occurred (HTTP error `500`)\n",
|
|
147
|
+
"operationId": "resetConfigProperty",
|
|
148
|
+
"responses": {
|
|
149
|
+
"204": {
|
|
150
|
+
"description": "The configuration property was deleted."
|
|
151
|
+
},
|
|
152
|
+
"404": {
|
|
153
|
+
"$ref": "#/components/responses/NotFound"
|
|
154
|
+
},
|
|
155
|
+
"500": {
|
|
156
|
+
"$ref": "#/components/responses/ServerError"
|
|
157
|
+
}
|
|
158
|
+
},
|
|
159
|
+
"summary": "Reset a configuration property",
|
|
160
|
+
"tags": [
|
|
161
|
+
"Admin"
|
|
162
|
+
]
|
|
163
|
+
},
|
|
164
|
+
"get": {
|
|
165
|
+
"description": "Returns the value of a single configuration property.\n\nThis operation may fail for one of the following reasons:\n\n* Property not found or not configured (HTTP error `404`)\n* A server error occurred (HTTP error `500`)\n",
|
|
166
|
+
"operationId": "getConfigProperty",
|
|
167
|
+
"responses": {
|
|
168
|
+
"200": {
|
|
169
|
+
"content": {
|
|
170
|
+
"application/json": {
|
|
171
|
+
"schema": {
|
|
172
|
+
"$ref": "#/components/schemas/ConfigurationProperty"
|
|
173
|
+
}
|
|
174
|
+
}
|
|
175
|
+
},
|
|
176
|
+
"description": "The configuration property value."
|
|
177
|
+
},
|
|
178
|
+
"404": {
|
|
179
|
+
"$ref": "#/components/responses/NotFound"
|
|
180
|
+
},
|
|
181
|
+
"500": {
|
|
182
|
+
"$ref": "#/components/responses/ServerError"
|
|
183
|
+
}
|
|
184
|
+
},
|
|
185
|
+
"summary": "Get configuration property value",
|
|
186
|
+
"tags": [
|
|
187
|
+
"Admin"
|
|
188
|
+
]
|
|
189
|
+
},
|
|
190
|
+
"parameters": [
|
|
191
|
+
{
|
|
192
|
+
"description": "The name of a configuration property.",
|
|
193
|
+
"in": "path",
|
|
194
|
+
"name": "propertyName",
|
|
195
|
+
"required": true,
|
|
196
|
+
"schema": {
|
|
197
|
+
"type": "string"
|
|
198
|
+
}
|
|
199
|
+
}
|
|
200
|
+
],
|
|
201
|
+
"put": {
|
|
202
|
+
"description": "Updates the value of a single configuration property.\n\nThis operation may fail for one of the following reasons:\n\n* Property not found or not configured (HTTP error `404`)\n* A server error occurred (HTTP error `500`)\n",
|
|
203
|
+
"operationId": "updateConfigProperty",
|
|
204
|
+
"requestBody": {
|
|
205
|
+
"content": {
|
|
206
|
+
"application/json": {
|
|
207
|
+
"schema": {
|
|
208
|
+
"$ref": "#/components/schemas/UpdateConfigurationProperty"
|
|
209
|
+
}
|
|
210
|
+
}
|
|
211
|
+
},
|
|
212
|
+
"required": true
|
|
213
|
+
},
|
|
214
|
+
"responses": {
|
|
215
|
+
"204": {
|
|
216
|
+
"description": "The configuration property was updated."
|
|
217
|
+
},
|
|
218
|
+
"404": {
|
|
219
|
+
"$ref": "#/components/responses/NotFound"
|
|
220
|
+
},
|
|
221
|
+
"500": {
|
|
222
|
+
"$ref": "#/components/responses/ServerError"
|
|
223
|
+
}
|
|
224
|
+
},
|
|
225
|
+
"summary": "Update a configuration property",
|
|
226
|
+
"tags": [
|
|
227
|
+
"Admin"
|
|
228
|
+
]
|
|
229
|
+
},
|
|
230
|
+
"summary": "Manage a single configuration property (by name)."
|
|
231
|
+
},
|
|
232
|
+
"/admin/export": {
|
|
233
|
+
"get": {
|
|
234
|
+
"description": "Exports registry data as a ZIP archive.",
|
|
235
|
+
"operationId": "exportData",
|
|
236
|
+
"parameters": [
|
|
237
|
+
{
|
|
238
|
+
"description": "Indicates if the operation is done for a browser. If true, the response will be a JSON payload with a property called `href`. This `href` will be a single-use, naked download link suitable for use by a web browser to download the content.",
|
|
239
|
+
"in": "query",
|
|
240
|
+
"name": "forBrowser",
|
|
241
|
+
"schema": {
|
|
242
|
+
"type": "boolean"
|
|
243
|
+
}
|
|
244
|
+
}
|
|
245
|
+
],
|
|
246
|
+
"responses": {
|
|
247
|
+
"200": {
|
|
248
|
+
"content": {
|
|
249
|
+
"application/json": {
|
|
250
|
+
"schema": {
|
|
251
|
+
"$ref": "#/components/schemas/DownloadRef"
|
|
252
|
+
}
|
|
253
|
+
},
|
|
254
|
+
"application/zip": {
|
|
255
|
+
"schema": {
|
|
256
|
+
"$ref": "#/components/schemas/FileContent"
|
|
257
|
+
}
|
|
258
|
+
}
|
|
259
|
+
},
|
|
260
|
+
"description": "Response when the export is successful."
|
|
261
|
+
},
|
|
262
|
+
"500": {
|
|
263
|
+
"$ref": "#/components/responses/ServerError"
|
|
264
|
+
}
|
|
265
|
+
},
|
|
266
|
+
"summary": "Export registry data",
|
|
267
|
+
"tags": [
|
|
268
|
+
"Admin"
|
|
269
|
+
]
|
|
270
|
+
},
|
|
271
|
+
"summary": "Provides a way to export registry data."
|
|
272
|
+
},
|
|
273
|
+
"/admin/import": {
|
|
274
|
+
"post": {
|
|
275
|
+
"description": "Imports registry data that was previously exported using the `/admin/export` operation.",
|
|
276
|
+
"operationId": "importData",
|
|
277
|
+
"parameters": [
|
|
278
|
+
{
|
|
279
|
+
"description": "If this header is set to false, global ids of imported data will be ignored and replaced by next id in global id sequence. This allows to import any data even thought the global ids would cause a conflict.",
|
|
280
|
+
"in": "header",
|
|
281
|
+
"name": "X-Registry-Preserve-GlobalId",
|
|
282
|
+
"schema": {
|
|
283
|
+
"type": "boolean"
|
|
284
|
+
}
|
|
285
|
+
},
|
|
286
|
+
{
|
|
287
|
+
"description": "If this header is set to false, content ids of imported data will be ignored and replaced by next id in content id sequence. The mapping between content and artifacts will be preserved. This allows to import any data even thought the content ids would cause a conflict.",
|
|
288
|
+
"in": "header",
|
|
289
|
+
"name": "X-Registry-Preserve-ContentId",
|
|
290
|
+
"required": false,
|
|
291
|
+
"schema": {
|
|
292
|
+
"type": "boolean"
|
|
293
|
+
}
|
|
294
|
+
}
|
|
295
|
+
],
|
|
296
|
+
"requestBody": {
|
|
297
|
+
"content": {
|
|
298
|
+
"application/zip": {
|
|
299
|
+
"schema": {
|
|
300
|
+
"$ref": "#/components/schemas/FileContent"
|
|
301
|
+
}
|
|
302
|
+
}
|
|
303
|
+
},
|
|
304
|
+
"description": "The ZIP file representing the previously exported registry data.",
|
|
305
|
+
"required": true
|
|
306
|
+
},
|
|
307
|
+
"responses": {
|
|
308
|
+
"201": {
|
|
309
|
+
"description": "Indicates that the import was successful."
|
|
310
|
+
},
|
|
311
|
+
"500": {
|
|
312
|
+
"$ref": "#/components/responses/ServerError"
|
|
313
|
+
}
|
|
314
|
+
},
|
|
315
|
+
"summary": "Import registry data",
|
|
316
|
+
"tags": [
|
|
317
|
+
"Admin"
|
|
318
|
+
]
|
|
319
|
+
},
|
|
320
|
+
"summary": "Provides a way to import data into the registry."
|
|
321
|
+
},
|
|
322
|
+
"/admin/loggers": {
|
|
323
|
+
"get": {
|
|
324
|
+
"description": "List all of the configured logging levels. These override the default\nlogging configuration.",
|
|
325
|
+
"operationId": "listLogConfigurations",
|
|
326
|
+
"responses": {
|
|
327
|
+
"200": {
|
|
328
|
+
"content": {
|
|
329
|
+
"application/json": {
|
|
330
|
+
"schema": {
|
|
331
|
+
"items": {
|
|
332
|
+
"$ref": "#/components/schemas/NamedLogConfiguration"
|
|
333
|
+
},
|
|
334
|
+
"type": "array"
|
|
335
|
+
}
|
|
336
|
+
}
|
|
337
|
+
},
|
|
338
|
+
"description": "The list of logging configurations."
|
|
339
|
+
},
|
|
340
|
+
"500": {
|
|
341
|
+
"$ref": "#/components/responses/ServerError"
|
|
342
|
+
}
|
|
343
|
+
},
|
|
344
|
+
"summary": "List logging configurations",
|
|
345
|
+
"tags": [
|
|
346
|
+
"Admin"
|
|
347
|
+
]
|
|
348
|
+
},
|
|
349
|
+
"summary": "Manage logger settings/configurations."
|
|
350
|
+
},
|
|
351
|
+
"/admin/loggers/{logger}": {
|
|
352
|
+
"delete": {
|
|
353
|
+
"description": "Removes the configured logger configuration (if any) for the given logger.",
|
|
354
|
+
"operationId": "removeLogConfiguration",
|
|
355
|
+
"responses": {
|
|
356
|
+
"200": {
|
|
357
|
+
"content": {
|
|
358
|
+
"application/json": {
|
|
359
|
+
"schema": {
|
|
360
|
+
"$ref": "#/components/schemas/NamedLogConfiguration"
|
|
361
|
+
}
|
|
362
|
+
}
|
|
363
|
+
},
|
|
364
|
+
"description": "The default logger configuration (now that the configuration for this logger has been removed, the \ndefault configuration is applied)."
|
|
365
|
+
},
|
|
366
|
+
"500": {
|
|
367
|
+
"$ref": "#/components/responses/ServerError"
|
|
368
|
+
}
|
|
369
|
+
},
|
|
370
|
+
"summary": "Removes logger configuration",
|
|
371
|
+
"tags": [
|
|
372
|
+
"Admin"
|
|
373
|
+
]
|
|
374
|
+
},
|
|
375
|
+
"get": {
|
|
376
|
+
"description": "Returns the configured logger configuration for the provided logger name, if no logger configuration is persisted it will return the current default log configuration in the system.",
|
|
377
|
+
"operationId": "getLogConfiguration",
|
|
378
|
+
"responses": {
|
|
379
|
+
"200": {
|
|
380
|
+
"content": {
|
|
381
|
+
"application/json": {
|
|
382
|
+
"schema": {
|
|
383
|
+
"$ref": "#/components/schemas/NamedLogConfiguration"
|
|
384
|
+
}
|
|
385
|
+
}
|
|
386
|
+
},
|
|
387
|
+
"description": "The logger configuration for the named logger."
|
|
388
|
+
},
|
|
389
|
+
"500": {
|
|
390
|
+
"$ref": "#/components/responses/ServerError"
|
|
391
|
+
}
|
|
392
|
+
},
|
|
393
|
+
"summary": "Get a single logger configuration",
|
|
394
|
+
"tags": [
|
|
395
|
+
"Admin"
|
|
396
|
+
]
|
|
397
|
+
},
|
|
398
|
+
"parameters": [
|
|
399
|
+
{
|
|
400
|
+
"description": "The name of a single logger.",
|
|
401
|
+
"in": "path",
|
|
402
|
+
"name": "logger",
|
|
403
|
+
"required": true,
|
|
404
|
+
"schema": {
|
|
405
|
+
"type": "string"
|
|
406
|
+
}
|
|
407
|
+
}
|
|
408
|
+
],
|
|
409
|
+
"put": {
|
|
410
|
+
"description": "Configures the logger referenced by the provided logger name with the given configuration.",
|
|
411
|
+
"operationId": "setLogConfiguration",
|
|
412
|
+
"requestBody": {
|
|
413
|
+
"content": {
|
|
414
|
+
"application/json": {
|
|
415
|
+
"schema": {
|
|
416
|
+
"$ref": "#/components/schemas/LogConfiguration"
|
|
417
|
+
}
|
|
418
|
+
}
|
|
419
|
+
},
|
|
420
|
+
"description": "The new logger configuration.",
|
|
421
|
+
"required": true
|
|
422
|
+
},
|
|
423
|
+
"responses": {
|
|
424
|
+
"200": {
|
|
425
|
+
"content": {
|
|
426
|
+
"application/json": {
|
|
427
|
+
"schema": {
|
|
428
|
+
"$ref": "#/components/schemas/NamedLogConfiguration"
|
|
429
|
+
}
|
|
430
|
+
}
|
|
431
|
+
},
|
|
432
|
+
"description": "The new configuration for the given logger."
|
|
433
|
+
},
|
|
434
|
+
"500": {
|
|
435
|
+
"$ref": "#/components/responses/ServerError"
|
|
436
|
+
}
|
|
437
|
+
},
|
|
438
|
+
"summary": "Set a logger's configuration",
|
|
439
|
+
"tags": [
|
|
440
|
+
"Admin"
|
|
441
|
+
]
|
|
442
|
+
},
|
|
443
|
+
"summary": "Manage logger settings/configurations."
|
|
444
|
+
},
|
|
445
|
+
"/admin/roleMappings": {
|
|
446
|
+
"get": {
|
|
447
|
+
"description": "Gets a list of all role mappings configured in the registry (if any).\n\nThis operation can fail for the following reasons:\n\n* A server error occurred (HTTP error `500`)\n",
|
|
448
|
+
"operationId": "listRoleMappings",
|
|
449
|
+
"responses": {
|
|
450
|
+
"200": {
|
|
451
|
+
"content": {
|
|
452
|
+
"application/json": {
|
|
453
|
+
"schema": {
|
|
454
|
+
"items": {
|
|
455
|
+
"$ref": "#/components/schemas/RoleMapping"
|
|
456
|
+
},
|
|
457
|
+
"type": "array"
|
|
458
|
+
}
|
|
459
|
+
}
|
|
460
|
+
},
|
|
461
|
+
"description": "A successful response will return the list of role mappings."
|
|
462
|
+
},
|
|
463
|
+
"500": {
|
|
464
|
+
"$ref": "#/components/responses/ServerError"
|
|
465
|
+
}
|
|
466
|
+
},
|
|
467
|
+
"summary": "List all role mappings",
|
|
468
|
+
"tags": [
|
|
469
|
+
"Admin"
|
|
470
|
+
]
|
|
471
|
+
},
|
|
472
|
+
"post": {
|
|
473
|
+
"description": "Creates a new mapping between a user/principal and a role.\n\nThis operation can fail for the following reasons:\n\n* A server error occurred (HTTP error `500`)\n\n",
|
|
474
|
+
"operationId": "createRoleMapping",
|
|
475
|
+
"requestBody": {
|
|
476
|
+
"content": {
|
|
477
|
+
"application/json": {
|
|
478
|
+
"schema": {
|
|
479
|
+
"$ref": "#/components/schemas/RoleMapping"
|
|
480
|
+
}
|
|
481
|
+
}
|
|
482
|
+
},
|
|
483
|
+
"required": true
|
|
484
|
+
},
|
|
485
|
+
"responses": {
|
|
486
|
+
"204": {
|
|
487
|
+
"description": "Returned when the role mapping was successfully created."
|
|
488
|
+
},
|
|
489
|
+
"500": {
|
|
490
|
+
"$ref": "#/components/responses/ServerError"
|
|
491
|
+
}
|
|
492
|
+
},
|
|
493
|
+
"summary": "Create a new role mapping",
|
|
494
|
+
"tags": [
|
|
495
|
+
"Admin"
|
|
496
|
+
]
|
|
497
|
+
},
|
|
498
|
+
"summary": "Collection to manage role mappings for authenticated principals"
|
|
499
|
+
},
|
|
500
|
+
"/admin/roleMappings/{principalId}": {
|
|
501
|
+
"delete": {
|
|
502
|
+
"description": "Deletes a single role mapping, effectively denying access to a user/principal.\n\nThis operation can fail for the following reasons:\n\n* No role mapping for the principalId exists (HTTP error `404`)\n* A server error occurred (HTTP error `500`)\n",
|
|
503
|
+
"operationId": "deleteRoleMapping",
|
|
504
|
+
"responses": {
|
|
505
|
+
"204": {
|
|
506
|
+
"description": "Response returned when the delete was successful."
|
|
507
|
+
},
|
|
508
|
+
"404": {
|
|
509
|
+
"$ref": "#/components/responses/NotFound"
|
|
510
|
+
},
|
|
511
|
+
"500": {
|
|
512
|
+
"$ref": "#/components/responses/ServerError"
|
|
513
|
+
}
|
|
514
|
+
},
|
|
515
|
+
"summary": "Delete a role mapping",
|
|
516
|
+
"tags": [
|
|
517
|
+
"Admin"
|
|
518
|
+
]
|
|
519
|
+
},
|
|
520
|
+
"get": {
|
|
521
|
+
"description": "Gets the details of a single role mapping (by `principalId`).\n\nThis operation can fail for the following reasons:\n\n* No role mapping for the `principalId` exists (HTTP error `404`)\n* A server error occurred (HTTP error `500`)\n",
|
|
522
|
+
"operationId": "getRoleMapping",
|
|
523
|
+
"responses": {
|
|
524
|
+
"200": {
|
|
525
|
+
"content": {
|
|
526
|
+
"application/json": {
|
|
527
|
+
"schema": {
|
|
528
|
+
"$ref": "#/components/schemas/RoleMapping"
|
|
529
|
+
}
|
|
530
|
+
}
|
|
531
|
+
},
|
|
532
|
+
"description": "When successful, returns the details of a role mapping."
|
|
533
|
+
},
|
|
534
|
+
"404": {
|
|
535
|
+
"$ref": "#/components/responses/NotFound"
|
|
536
|
+
},
|
|
537
|
+
"500": {
|
|
538
|
+
"$ref": "#/components/responses/ServerError"
|
|
539
|
+
}
|
|
540
|
+
},
|
|
541
|
+
"summary": "Return a single role mapping",
|
|
542
|
+
"tags": [
|
|
543
|
+
"Admin"
|
|
544
|
+
]
|
|
545
|
+
},
|
|
546
|
+
"parameters": [
|
|
547
|
+
{
|
|
548
|
+
"description": "Unique id of a principal (typically either a user or service account).",
|
|
549
|
+
"in": "path",
|
|
550
|
+
"name": "principalId",
|
|
551
|
+
"required": true,
|
|
552
|
+
"schema": {
|
|
553
|
+
"type": "string"
|
|
554
|
+
}
|
|
555
|
+
}
|
|
556
|
+
],
|
|
557
|
+
"put": {
|
|
558
|
+
"description": "Updates a single role mapping for one user/principal.\n\nThis operation can fail for the following reasons:\n\n* No role mapping for the principalId exists (HTTP error `404`)\n* A server error occurred (HTTP error `500`)\n",
|
|
559
|
+
"operationId": "updateRoleMapping",
|
|
560
|
+
"requestBody": {
|
|
561
|
+
"content": {
|
|
562
|
+
"application/json": {
|
|
563
|
+
"schema": {
|
|
564
|
+
"$ref": "#/components/schemas/UpdateRole"
|
|
565
|
+
}
|
|
566
|
+
}
|
|
567
|
+
},
|
|
568
|
+
"required": true
|
|
569
|
+
},
|
|
570
|
+
"responses": {
|
|
571
|
+
"204": {
|
|
572
|
+
"description": "Response when the update is successful."
|
|
573
|
+
},
|
|
574
|
+
"404": {
|
|
575
|
+
"$ref": "#/components/responses/NotFound"
|
|
576
|
+
},
|
|
577
|
+
"500": {
|
|
578
|
+
"$ref": "#/components/responses/ServerError"
|
|
579
|
+
}
|
|
580
|
+
},
|
|
581
|
+
"summary": "Update a role mapping",
|
|
582
|
+
"tags": [
|
|
583
|
+
"Admin"
|
|
584
|
+
]
|
|
585
|
+
},
|
|
586
|
+
"summary": "Manage the configuration of a single role mapping."
|
|
587
|
+
},
|
|
588
|
+
"/admin/rules": {
|
|
589
|
+
"delete": {
|
|
590
|
+
"description": "Deletes all globally configured rules.\n\nThis operation can fail for the following reasons:\n\n* A server error occurred (HTTP error `500`)\n",
|
|
591
|
+
"operationId": "deleteAllGlobalRules",
|
|
592
|
+
"responses": {
|
|
593
|
+
"204": {
|
|
594
|
+
"description": "All global rules have been removed successfully."
|
|
595
|
+
},
|
|
596
|
+
"500": {
|
|
597
|
+
"$ref": "#/components/responses/ServerError"
|
|
598
|
+
}
|
|
599
|
+
},
|
|
600
|
+
"summary": "Delete all global rules",
|
|
601
|
+
"tags": [
|
|
602
|
+
"Global rules",
|
|
603
|
+
"Admin"
|
|
604
|
+
]
|
|
605
|
+
},
|
|
606
|
+
"get": {
|
|
607
|
+
"description": "Gets a list of all the currently configured global rules (if any).\n\nThis operation can fail for the following reasons:\n\n* A server error occurred (HTTP error `500`)\n",
|
|
608
|
+
"operationId": "listGlobalRules",
|
|
609
|
+
"responses": {
|
|
610
|
+
"200": {
|
|
611
|
+
"content": {
|
|
612
|
+
"application/json": {
|
|
613
|
+
"schema": {
|
|
614
|
+
"items": {
|
|
615
|
+
"$ref": "#/components/schemas/RuleType"
|
|
616
|
+
},
|
|
617
|
+
"type": "array"
|
|
618
|
+
}
|
|
619
|
+
}
|
|
620
|
+
},
|
|
621
|
+
"description": "The list of names of the globally configured rules."
|
|
622
|
+
},
|
|
623
|
+
"500": {
|
|
624
|
+
"$ref": "#/components/responses/ServerError"
|
|
625
|
+
}
|
|
626
|
+
},
|
|
627
|
+
"summary": "List global rules",
|
|
628
|
+
"tags": [
|
|
629
|
+
"Global rules",
|
|
630
|
+
"Admin"
|
|
631
|
+
]
|
|
632
|
+
},
|
|
633
|
+
"post": {
|
|
634
|
+
"description": "Adds a rule to the list of globally configured rules.\n\nThis operation can fail for the following reasons:\n\n* The rule type is unknown (HTTP error `400`)\n* The rule already exists (HTTP error `409`)\n* A server error occurred (HTTP error `500`)\n",
|
|
635
|
+
"operationId": "createGlobalRule",
|
|
636
|
+
"requestBody": {
|
|
637
|
+
"content": {
|
|
638
|
+
"application/json": {
|
|
639
|
+
"schema": {
|
|
640
|
+
"$ref": "#/components/schemas/Rule"
|
|
641
|
+
}
|
|
642
|
+
}
|
|
643
|
+
},
|
|
644
|
+
"required": true
|
|
645
|
+
},
|
|
646
|
+
"responses": {
|
|
647
|
+
"204": {
|
|
648
|
+
"description": "The global rule was added."
|
|
649
|
+
},
|
|
650
|
+
"400": {
|
|
651
|
+
"$ref": "#/components/responses/BadRequest"
|
|
652
|
+
},
|
|
653
|
+
"409": {
|
|
654
|
+
"$ref": "#/components/responses/Conflict"
|
|
655
|
+
},
|
|
656
|
+
"500": {
|
|
657
|
+
"$ref": "#/components/responses/ServerError"
|
|
658
|
+
}
|
|
659
|
+
},
|
|
660
|
+
"summary": "Create global rule",
|
|
661
|
+
"tags": [
|
|
662
|
+
"Global rules",
|
|
663
|
+
"Admin"
|
|
664
|
+
]
|
|
665
|
+
},
|
|
666
|
+
"summary": "Manage the global rules that apply to all artifacts if not otherwise configured."
|
|
667
|
+
},
|
|
668
|
+
"/admin/rules/{rule}": {
|
|
669
|
+
"delete": {
|
|
670
|
+
"description": "Deletes a single global rule. If this is the only rule configured, this is the same\nas deleting **all** rules.\n\nThis operation can fail for the following reasons:\n\n* Invalid rule name/type (HTTP error `400`)\n* No rule with name/type `rule` exists (HTTP error `404`)\n* Rule cannot be deleted (HTTP error `409`)\n* A server error occurred (HTTP error `500`)\n",
|
|
671
|
+
"operationId": "deleteGlobalRule",
|
|
672
|
+
"responses": {
|
|
673
|
+
"204": {
|
|
674
|
+
"description": "The global rule was successfully deleted."
|
|
675
|
+
},
|
|
676
|
+
"404": {
|
|
677
|
+
"$ref": "#/components/responses/NotFound"
|
|
678
|
+
},
|
|
679
|
+
"500": {
|
|
680
|
+
"$ref": "#/components/responses/ServerError"
|
|
681
|
+
}
|
|
682
|
+
},
|
|
683
|
+
"summary": "Delete global rule",
|
|
684
|
+
"tags": [
|
|
685
|
+
"Global rules",
|
|
686
|
+
"Admin"
|
|
687
|
+
]
|
|
688
|
+
},
|
|
689
|
+
"get": {
|
|
690
|
+
"description": "Returns information about the named globally configured rule.\n\nThis operation can fail for the following reasons:\n\n* Invalid rule name/type (HTTP error `400`)\n* No rule with name/type `rule` exists (HTTP error `404`)\n* A server error occurred (HTTP error `500`)\n",
|
|
691
|
+
"operationId": "getGlobalRuleConfig",
|
|
692
|
+
"responses": {
|
|
693
|
+
"200": {
|
|
694
|
+
"content": {
|
|
695
|
+
"application/json": {
|
|
696
|
+
"schema": {
|
|
697
|
+
"$ref": "#/components/schemas/Rule"
|
|
698
|
+
}
|
|
699
|
+
}
|
|
700
|
+
},
|
|
701
|
+
"description": "The global rule's configuration."
|
|
702
|
+
},
|
|
703
|
+
"404": {
|
|
704
|
+
"$ref": "#/components/responses/NotFound"
|
|
705
|
+
},
|
|
706
|
+
"500": {
|
|
707
|
+
"$ref": "#/components/responses/ServerError"
|
|
708
|
+
}
|
|
709
|
+
},
|
|
710
|
+
"summary": "Get global rule configuration",
|
|
711
|
+
"tags": [
|
|
712
|
+
"Global rules",
|
|
713
|
+
"Admin"
|
|
714
|
+
]
|
|
715
|
+
},
|
|
716
|
+
"parameters": [
|
|
717
|
+
{
|
|
718
|
+
"description": "The unique name/type of a rule.",
|
|
719
|
+
"in": "path",
|
|
720
|
+
"name": "rule",
|
|
721
|
+
"required": true,
|
|
722
|
+
"schema": {
|
|
723
|
+
"$ref": "#/components/schemas/RuleType"
|
|
724
|
+
}
|
|
725
|
+
}
|
|
726
|
+
],
|
|
727
|
+
"put": {
|
|
728
|
+
"description": "Updates the configuration for a globally configured rule.\n\nThis operation can fail for the following reasons:\n\n* Invalid rule name/type (HTTP error `400`)\n* No rule with name/type `rule` exists (HTTP error `404`)\n* A server error occurred (HTTP error `500`)\n",
|
|
729
|
+
"operationId": "updateGlobalRuleConfig",
|
|
730
|
+
"requestBody": {
|
|
731
|
+
"content": {
|
|
732
|
+
"application/json": {
|
|
733
|
+
"schema": {
|
|
734
|
+
"$ref": "#/components/schemas/Rule"
|
|
735
|
+
}
|
|
736
|
+
}
|
|
737
|
+
},
|
|
738
|
+
"required": true
|
|
739
|
+
},
|
|
740
|
+
"responses": {
|
|
741
|
+
"200": {
|
|
742
|
+
"content": {
|
|
743
|
+
"application/json": {
|
|
744
|
+
"schema": {
|
|
745
|
+
"$ref": "#/components/schemas/Rule"
|
|
746
|
+
}
|
|
747
|
+
}
|
|
748
|
+
},
|
|
749
|
+
"description": "The global rule's configuration was successfully updated."
|
|
750
|
+
},
|
|
751
|
+
"404": {
|
|
752
|
+
"$ref": "#/components/responses/NotFound"
|
|
753
|
+
},
|
|
754
|
+
"500": {
|
|
755
|
+
"$ref": "#/components/responses/ServerError"
|
|
756
|
+
}
|
|
757
|
+
},
|
|
758
|
+
"summary": "Update global rule configuration",
|
|
759
|
+
"tags": [
|
|
760
|
+
"Global rules",
|
|
761
|
+
"Admin"
|
|
762
|
+
]
|
|
763
|
+
},
|
|
764
|
+
"summary": "Manage the configuration of a single global artifact rule."
|
|
765
|
+
},
|
|
766
|
+
"/groups": {
|
|
767
|
+
"get": {
|
|
768
|
+
"description": "Returns a list of all groups. This list is paged.",
|
|
769
|
+
"operationId": "listGroups",
|
|
770
|
+
"parameters": [
|
|
771
|
+
{
|
|
772
|
+
"description": "The number of groups to return. Defaults to 20.",
|
|
773
|
+
"in": "query",
|
|
774
|
+
"name": "limit",
|
|
775
|
+
"schema": {
|
|
776
|
+
"type": "integer"
|
|
777
|
+
}
|
|
778
|
+
},
|
|
779
|
+
{
|
|
780
|
+
"description": "The number of groups to skip before starting the result set. Defaults to 0.",
|
|
781
|
+
"in": "query",
|
|
782
|
+
"name": "offset",
|
|
783
|
+
"schema": {
|
|
784
|
+
"type": "integer"
|
|
785
|
+
}
|
|
786
|
+
},
|
|
787
|
+
{
|
|
788
|
+
"description": "Sort order, ascending (`asc`) or descending (`desc`).",
|
|
789
|
+
"in": "query",
|
|
790
|
+
"name": "order",
|
|
791
|
+
"schema": {
|
|
792
|
+
"$ref": "#/components/schemas/SortOrder"
|
|
793
|
+
}
|
|
794
|
+
},
|
|
795
|
+
{
|
|
796
|
+
"description": "The field to sort by. Can be one of:\n\n* `name`\n* `createdOn`\n",
|
|
797
|
+
"in": "query",
|
|
798
|
+
"name": "orderby",
|
|
799
|
+
"schema": {
|
|
800
|
+
"$ref": "#/components/schemas/SortBy"
|
|
801
|
+
}
|
|
802
|
+
}
|
|
803
|
+
],
|
|
804
|
+
"responses": {
|
|
805
|
+
"200": {
|
|
806
|
+
"content": {
|
|
807
|
+
"application/json": {
|
|
808
|
+
"schema": {
|
|
809
|
+
"$ref": "#/components/schemas/GroupSearchResults"
|
|
810
|
+
}
|
|
811
|
+
}
|
|
812
|
+
},
|
|
813
|
+
"description": "On a successful response, returns a bounded set of groups."
|
|
814
|
+
},
|
|
815
|
+
"500": {
|
|
816
|
+
"$ref": "#/components/responses/ServerError"
|
|
817
|
+
}
|
|
818
|
+
},
|
|
819
|
+
"summary": "List groups",
|
|
820
|
+
"tags": [
|
|
821
|
+
"Groups"
|
|
822
|
+
]
|
|
823
|
+
},
|
|
824
|
+
"post": {
|
|
825
|
+
"description": "Creates a new group.\n\nThis operation can fail for the following reasons:\n\n* A server error occurred (HTTP error `500`)\n* The group already exist (HTTP error `409`)\n",
|
|
826
|
+
"operationId": "createGroup",
|
|
827
|
+
"requestBody": {
|
|
828
|
+
"content": {
|
|
829
|
+
"application/json": {
|
|
830
|
+
"schema": {
|
|
831
|
+
"$ref": "#/components/schemas/CreateGroupMetaData"
|
|
832
|
+
}
|
|
833
|
+
}
|
|
834
|
+
},
|
|
835
|
+
"required": true
|
|
836
|
+
},
|
|
837
|
+
"responses": {
|
|
838
|
+
"200": {
|
|
839
|
+
"content": {
|
|
840
|
+
"application/json": {
|
|
841
|
+
"schema": {
|
|
842
|
+
"$ref": "#/components/schemas/GroupMetaData"
|
|
843
|
+
}
|
|
844
|
+
}
|
|
845
|
+
},
|
|
846
|
+
"description": "The group has been successfully created."
|
|
847
|
+
},
|
|
848
|
+
"409": {
|
|
849
|
+
"$ref": "#/components/responses/Conflict"
|
|
850
|
+
},
|
|
851
|
+
"500": {
|
|
852
|
+
"$ref": "#/components/responses/ServerError"
|
|
853
|
+
}
|
|
854
|
+
},
|
|
855
|
+
"summary": "Create a new group",
|
|
856
|
+
"tags": [
|
|
857
|
+
"Groups"
|
|
858
|
+
]
|
|
859
|
+
},
|
|
860
|
+
"summary": "Collection of the groups in the registry."
|
|
861
|
+
},
|
|
862
|
+
"/groups/{groupId}": {
|
|
863
|
+
"delete": {
|
|
864
|
+
"description": "Deletes a group by identifier.\n\nThis operation can fail for the following reasons:\n\n* A server error occurred (HTTP error `500`)\n* The group does not exist (HTTP error `404`)\n",
|
|
865
|
+
"operationId": "deleteGroupById",
|
|
866
|
+
"responses": {
|
|
867
|
+
"204": {
|
|
868
|
+
"description": "Empty content indicates a successful deletion."
|
|
869
|
+
},
|
|
870
|
+
"404": {
|
|
871
|
+
"$ref": "#/components/responses/NotFound"
|
|
872
|
+
},
|
|
873
|
+
"500": {
|
|
874
|
+
"$ref": "#/components/responses/ServerError"
|
|
875
|
+
}
|
|
876
|
+
},
|
|
877
|
+
"summary": "Delete a group by the specified ID.",
|
|
878
|
+
"tags": [
|
|
879
|
+
"Groups"
|
|
880
|
+
]
|
|
881
|
+
},
|
|
882
|
+
"get": {
|
|
883
|
+
"description": "Returns a group using the specified id.\n\nThis operation can fail for the following reasons:\n\n* No group exists with the specified ID (HTTP error `404`)\n* A server error occurred (HTTP error `500`)",
|
|
884
|
+
"operationId": "getGroupById",
|
|
885
|
+
"responses": {
|
|
886
|
+
"200": {
|
|
887
|
+
"content": {
|
|
888
|
+
"application/json": {
|
|
889
|
+
"schema": {
|
|
890
|
+
"$ref": "#/components/schemas/GroupMetaData"
|
|
891
|
+
}
|
|
892
|
+
}
|
|
893
|
+
},
|
|
894
|
+
"description": "The group's metadata."
|
|
895
|
+
},
|
|
896
|
+
"404": {
|
|
897
|
+
"$ref": "#/components/responses/NotFound"
|
|
898
|
+
},
|
|
899
|
+
"500": {
|
|
900
|
+
"$ref": "#/components/responses/ServerError"
|
|
901
|
+
}
|
|
902
|
+
},
|
|
903
|
+
"summary": "Get a group by the specified ID.",
|
|
904
|
+
"tags": [
|
|
905
|
+
"Groups"
|
|
906
|
+
]
|
|
907
|
+
},
|
|
908
|
+
"parameters": [
|
|
909
|
+
{
|
|
910
|
+
"description": "The artifact group ID. Must be a string provided by the client, representing the name of the grouping of artifacts.",
|
|
911
|
+
"in": "path",
|
|
912
|
+
"name": "groupId",
|
|
913
|
+
"required": true,
|
|
914
|
+
"schema": {
|
|
915
|
+
"$ref": "#/components/schemas/GroupId"
|
|
916
|
+
}
|
|
917
|
+
}
|
|
918
|
+
],
|
|
919
|
+
"summary": "Collection to manage a single group in the registry."
|
|
920
|
+
},
|
|
921
|
+
"/groups/{groupId}/artifacts": {
|
|
922
|
+
"delete": {
|
|
923
|
+
"description": "Deletes all of the artifacts that exist in a given group.",
|
|
924
|
+
"operationId": "deleteArtifactsInGroup",
|
|
925
|
+
"responses": {
|
|
926
|
+
"204": {
|
|
927
|
+
"description": "When the delete operation is successful, a simple 204 is returned."
|
|
928
|
+
},
|
|
929
|
+
"500": {
|
|
930
|
+
"$ref": "#/components/responses/ServerError"
|
|
931
|
+
}
|
|
932
|
+
},
|
|
933
|
+
"summary": "Delete artifacts in group",
|
|
934
|
+
"tags": [
|
|
935
|
+
"Artifacts"
|
|
936
|
+
]
|
|
937
|
+
},
|
|
938
|
+
"get": {
|
|
939
|
+
"description": "Returns a list of all artifacts in the group. This list is paged.",
|
|
940
|
+
"operationId": "listArtifactsInGroup",
|
|
941
|
+
"parameters": [
|
|
942
|
+
{
|
|
943
|
+
"description": "The number of artifacts to return. Defaults to 20.",
|
|
944
|
+
"in": "query",
|
|
945
|
+
"name": "limit",
|
|
946
|
+
"schema": {
|
|
947
|
+
"type": "integer"
|
|
948
|
+
}
|
|
949
|
+
},
|
|
950
|
+
{
|
|
951
|
+
"description": "The number of artifacts to skip before starting the result set. Defaults to 0.",
|
|
952
|
+
"in": "query",
|
|
953
|
+
"name": "offset",
|
|
954
|
+
"schema": {
|
|
955
|
+
"type": "integer"
|
|
956
|
+
}
|
|
957
|
+
},
|
|
958
|
+
{
|
|
959
|
+
"description": "Sort order, ascending (`asc`) or descending (`desc`).",
|
|
960
|
+
"in": "query",
|
|
961
|
+
"name": "order",
|
|
962
|
+
"schema": {
|
|
963
|
+
"$ref": "#/components/schemas/SortOrder"
|
|
964
|
+
}
|
|
965
|
+
},
|
|
966
|
+
{
|
|
967
|
+
"description": "The field to sort by. Can be one of:\n\n* `name`\n* `createdOn`\n",
|
|
968
|
+
"in": "query",
|
|
969
|
+
"name": "orderby",
|
|
970
|
+
"schema": {
|
|
971
|
+
"$ref": "#/components/schemas/SortBy"
|
|
972
|
+
}
|
|
973
|
+
}
|
|
974
|
+
],
|
|
975
|
+
"responses": {
|
|
976
|
+
"200": {
|
|
977
|
+
"content": {
|
|
978
|
+
"application/json": {
|
|
979
|
+
"schema": {
|
|
980
|
+
"$ref": "#/components/schemas/ArtifactSearchResults"
|
|
981
|
+
}
|
|
982
|
+
}
|
|
983
|
+
},
|
|
984
|
+
"description": "On a successful response, returns a bounded set of artifacts."
|
|
985
|
+
},
|
|
986
|
+
"500": {
|
|
987
|
+
"$ref": "#/components/responses/ServerError"
|
|
988
|
+
}
|
|
989
|
+
},
|
|
990
|
+
"summary": "List artifacts in group",
|
|
991
|
+
"tags": [
|
|
992
|
+
"Artifacts"
|
|
993
|
+
]
|
|
994
|
+
},
|
|
995
|
+
"parameters": [
|
|
996
|
+
{
|
|
997
|
+
"description": "The artifact group ID. Must be a string provided by the client, representing the name of the grouping of artifacts.",
|
|
998
|
+
"in": "path",
|
|
999
|
+
"name": "groupId",
|
|
1000
|
+
"required": true,
|
|
1001
|
+
"schema": {
|
|
1002
|
+
"$ref": "#/components/schemas/GroupId"
|
|
1003
|
+
}
|
|
1004
|
+
}
|
|
1005
|
+
],
|
|
1006
|
+
"post": {
|
|
1007
|
+
"description": "Creates a new artifact by posting the artifact content. The body of the request should\nbe the raw content of the artifact. This is typically in JSON format for *most* of the \nsupported types, but may be in another format for a few (for example, `PROTOBUF`).\n\nThe registry attempts to figure out what kind of artifact is being added from the\nfollowing supported list:\n\n* Avro (`AVRO`)\n* Protobuf (`PROTOBUF`)\n* JSON Schema (`JSON`)\n* Kafka Connect (`KCONNECT`)\n* OpenAPI (`OPENAPI`)\n* AsyncAPI (`ASYNCAPI`)\n* GraphQL (`GRAPHQL`)\n* Web Services Description Language (`WSDL`)\n* XML Schema (`XSD`)\n\nAlternatively, you can specify the artifact type using the `X-Registry-ArtifactType` \nHTTP request header, or include a hint in the request's `Content-Type`. For example:\n\n```\nContent-Type: application/json; artifactType=AVRO\n```\n\nAn artifact is created using the content provided in the body of the request. This\ncontent is created under a unique artifact ID that can be provided in the request\nusing the `X-Registry-ArtifactId` request header. If not provided in the request,\nthe server generates a unique ID for the artifact. It is typically recommended\nthat callers provide the ID, because this is typically a meaningful identifier, \nand for most use cases should be supplied by the caller.\n\nIf an artifact with the provided artifact ID already exists, the default behavior\nis for the server to reject the content with a 409 error. However, the caller can\nsupply the `ifExists` query parameter to alter this default behavior. The `ifExists`\nquery parameter can have one of the following values:\n\n* `FAIL` (*default*) - server rejects the content with a 409 error\n* `UPDATE` - server updates the existing artifact and returns the new metadata\n* `RETURN` - server does not create or add content to the server, but instead \nreturns the metadata for the existing artifact\n* `RETURN_OR_UPDATE` - server returns an existing **version** that matches the \nprovided content if such a version exists, otherwise a new version is created\n\nThis operation may fail for one of the following reasons:\n\n* An invalid `ArtifactType` was indicated (HTTP error `400`)\n* No `ArtifactType` was indicated and the server could not determine one from the content (HTTP error `400`)\n* Provided content (request body) was empty (HTTP error `400`)\n* An artifact with the provided ID already exists (HTTP error `409`)\n* The content violates one of the configured global rules (HTTP error `409`)\n* A server error occurred (HTTP error `500`)\n",
|
|
1008
|
+
"operationId": "createArtifact",
|
|
1009
|
+
"parameters": [
|
|
1010
|
+
{
|
|
1011
|
+
"description": "Specifies the type of the artifact being added. Possible values include:\n\n* Avro (`AVRO`)\n* Protobuf (`PROTOBUF`)\n* JSON Schema (`JSON`)\n* Kafka Connect (`KCONNECT`)\n* OpenAPI (`OPENAPI`)\n* AsyncAPI (`ASYNCAPI`)\n* GraphQL (`GRAPHQL`)\n* Web Services Description Language (`WSDL`)\n* XML Schema (`XSD`)",
|
|
1012
|
+
"in": "header",
|
|
1013
|
+
"name": "X-Registry-ArtifactType",
|
|
1014
|
+
"schema": {
|
|
1015
|
+
"$ref": "#/components/schemas/ArtifactType"
|
|
1016
|
+
}
|
|
1017
|
+
},
|
|
1018
|
+
{
|
|
1019
|
+
"description": "A client-provided, globally unique identifier for the new artifact.",
|
|
1020
|
+
"in": "header",
|
|
1021
|
+
"name": "X-Registry-ArtifactId",
|
|
1022
|
+
"schema": {
|
|
1023
|
+
"type": "string"
|
|
1024
|
+
}
|
|
1025
|
+
},
|
|
1026
|
+
{
|
|
1027
|
+
"description": "Specifies the version number of this initial version of the artifact content. This would typically\nbe a simple integer or a SemVer value. If not provided, the server will assign a version number\nautomatically (starting with version `1`).",
|
|
1028
|
+
"in": "header",
|
|
1029
|
+
"name": "X-Registry-Version",
|
|
1030
|
+
"schema": {
|
|
1031
|
+
"$ref": "#/components/schemas/Version"
|
|
1032
|
+
}
|
|
1033
|
+
},
|
|
1034
|
+
{
|
|
1035
|
+
"description": "Set this option to instruct the server on what to do if the artifact already exists.",
|
|
1036
|
+
"in": "query",
|
|
1037
|
+
"name": "ifExists",
|
|
1038
|
+
"schema": {
|
|
1039
|
+
"$ref": "#/components/schemas/IfExists"
|
|
1040
|
+
}
|
|
1041
|
+
},
|
|
1042
|
+
{
|
|
1043
|
+
"description": "Used only when the `ifExists` query parameter is set to `RETURN_OR_UPDATE`, this parameter can be set to `true` to indicate that the server should \"canonicalize\" the content when searching for a matching version. The canonicalization algorithm is unique to each artifact type, but typically involves removing extra whitespace and formatting the content in a consistent manner.",
|
|
1044
|
+
"in": "query",
|
|
1045
|
+
"name": "canonical",
|
|
1046
|
+
"schema": {
|
|
1047
|
+
"type": "boolean"
|
|
1048
|
+
}
|
|
1049
|
+
},
|
|
1050
|
+
{
|
|
1051
|
+
"description": "Specifies the description of artifact being added. Description must be ASCII-only string. If this is not provided, the server will extract the description from the artifact content.",
|
|
1052
|
+
"in": "header",
|
|
1053
|
+
"name": "X-Registry-Description",
|
|
1054
|
+
"required": false,
|
|
1055
|
+
"schema": {
|
|
1056
|
+
"$ref": "#/components/schemas/ArtifactDescription"
|
|
1057
|
+
}
|
|
1058
|
+
},
|
|
1059
|
+
{
|
|
1060
|
+
"description": "Specifies the description of artifact being added. Value of this must be Base64 encoded string. If this is not provided, the server will extract the description from the artifact content.",
|
|
1061
|
+
"in": "header",
|
|
1062
|
+
"name": "X-Registry-Description-Encoded",
|
|
1063
|
+
"schema": {
|
|
1064
|
+
"$ref": "#/components/schemas/EncodedArtifactDescription"
|
|
1065
|
+
}
|
|
1066
|
+
},
|
|
1067
|
+
{
|
|
1068
|
+
"description": "Specifies the name of artifact being added. Name must be ASCII-only string. If this is not provided, the server will extract the name from the artifact content.",
|
|
1069
|
+
"in": "header",
|
|
1070
|
+
"name": "X-Registry-Name",
|
|
1071
|
+
"schema": {
|
|
1072
|
+
"$ref": "#/components/schemas/ArtifactName"
|
|
1073
|
+
}
|
|
1074
|
+
},
|
|
1075
|
+
{
|
|
1076
|
+
"description": "Specifies the name of artifact being added. Value of this must be Base64 encoded string. If this is not provided, the server will extract the name from the artifact content.",
|
|
1077
|
+
"in": "header",
|
|
1078
|
+
"name": "X-Registry-Name-Encoded",
|
|
1079
|
+
"schema": {
|
|
1080
|
+
"$ref": "#/components/schemas/EncodedArtifactName"
|
|
1081
|
+
}
|
|
1082
|
+
},
|
|
1083
|
+
{
|
|
1084
|
+
"description": "Specifies the (optional) hash of the artifact to be verified.",
|
|
1085
|
+
"in": "header",
|
|
1086
|
+
"name": "X-Registry-Content-Hash",
|
|
1087
|
+
"schema": {
|
|
1088
|
+
"type": "string"
|
|
1089
|
+
}
|
|
1090
|
+
},
|
|
1091
|
+
{
|
|
1092
|
+
"description": "The algorithm to use when checking the content validity. (available: SHA256, MD5; default: SHA256)",
|
|
1093
|
+
"in": "header",
|
|
1094
|
+
"name": "X-Registry-Hash-Algorithm",
|
|
1095
|
+
"schema": {
|
|
1096
|
+
"enum": [
|
|
1097
|
+
"SHA256",
|
|
1098
|
+
"MD5"
|
|
1099
|
+
],
|
|
1100
|
+
"type": "string"
|
|
1101
|
+
}
|
|
1102
|
+
}
|
|
1103
|
+
],
|
|
1104
|
+
"requestBody": {
|
|
1105
|
+
"content": {
|
|
1106
|
+
"*/*": {
|
|
1107
|
+
"examples": {
|
|
1108
|
+
"OpenAPI Example": {
|
|
1109
|
+
"value": {
|
|
1110
|
+
"components": {
|
|
1111
|
+
"schemas": {
|
|
1112
|
+
"Widget": {
|
|
1113
|
+
"description": "A sample data type.",
|
|
1114
|
+
"example": {
|
|
1115
|
+
"property-1": "value1",
|
|
1116
|
+
"property-2": true
|
|
1117
|
+
},
|
|
1118
|
+
"properties": {
|
|
1119
|
+
"property-1": {
|
|
1120
|
+
"type": "string"
|
|
1121
|
+
},
|
|
1122
|
+
"property-2": {
|
|
1123
|
+
"type": "boolean"
|
|
1124
|
+
}
|
|
1125
|
+
},
|
|
1126
|
+
"title": "Root Type for Widget",
|
|
1127
|
+
"type": "object"
|
|
1128
|
+
}
|
|
1129
|
+
}
|
|
1130
|
+
},
|
|
1131
|
+
"info": {
|
|
1132
|
+
"description": "An example API design using OpenAPI.",
|
|
1133
|
+
"title": "Empty API",
|
|
1134
|
+
"version": "1.0.7"
|
|
1135
|
+
},
|
|
1136
|
+
"openapi": "3.0.2",
|
|
1137
|
+
"paths": {
|
|
1138
|
+
"/widgets": {
|
|
1139
|
+
"get": {
|
|
1140
|
+
"responses": {
|
|
1141
|
+
"200": {
|
|
1142
|
+
"content": {
|
|
1143
|
+
"application/json": {
|
|
1144
|
+
"schema": {
|
|
1145
|
+
"items": {
|
|
1146
|
+
"type": "string"
|
|
1147
|
+
},
|
|
1148
|
+
"type": "array"
|
|
1149
|
+
}
|
|
1150
|
+
}
|
|
1151
|
+
},
|
|
1152
|
+
"description": "All widgets"
|
|
1153
|
+
}
|
|
1154
|
+
},
|
|
1155
|
+
"summary": "Get widgets"
|
|
1156
|
+
}
|
|
1157
|
+
}
|
|
1158
|
+
}
|
|
1159
|
+
}
|
|
1160
|
+
}
|
|
1161
|
+
},
|
|
1162
|
+
"schema": {
|
|
1163
|
+
"$ref": "#/components/schemas/FileContent"
|
|
1164
|
+
}
|
|
1165
|
+
},
|
|
1166
|
+
"application/create.extended+json": {
|
|
1167
|
+
"schema": {
|
|
1168
|
+
"$ref": "#/components/schemas/ContentCreateRequest"
|
|
1169
|
+
}
|
|
1170
|
+
},
|
|
1171
|
+
"application/vnd.create.extended+json": {
|
|
1172
|
+
"schema": {
|
|
1173
|
+
"$ref": "#/components/schemas/ContentCreateRequest"
|
|
1174
|
+
}
|
|
1175
|
+
}
|
|
1176
|
+
},
|
|
1177
|
+
"description": "The content of the artifact being created. This is often, but not always, JSON data\nrepresenting one of the supported artifact types:\n\n* Avro (`AVRO`)\n* Protobuf (`PROTOBUF`)\n* JSON Schema (`JSON`)\n* Kafka Connect (`KCONNECT`)\n* OpenAPI (`OPENAPI`)\n* AsyncAPI (`ASYNCAPI`)\n* GraphQL (`GRAPHQL`)\n* Web Services Description Language (`WSDL`)\n* XML Schema (`XSD`)\n",
|
|
1178
|
+
"required": true
|
|
1179
|
+
},
|
|
1180
|
+
"responses": {
|
|
1181
|
+
"200": {
|
|
1182
|
+
"content": {
|
|
1183
|
+
"application/json": {
|
|
1184
|
+
"schema": {
|
|
1185
|
+
"$ref": "#/components/schemas/ArtifactMetaData"
|
|
1186
|
+
}
|
|
1187
|
+
}
|
|
1188
|
+
},
|
|
1189
|
+
"description": "Artifact was successfully created."
|
|
1190
|
+
},
|
|
1191
|
+
"400": {
|
|
1192
|
+
"$ref": "#/components/responses/BadRequest"
|
|
1193
|
+
},
|
|
1194
|
+
"409": {
|
|
1195
|
+
"$ref": "#/components/responses/RuleViolationConflict"
|
|
1196
|
+
},
|
|
1197
|
+
"500": {
|
|
1198
|
+
"$ref": "#/components/responses/ServerError"
|
|
1199
|
+
}
|
|
1200
|
+
},
|
|
1201
|
+
"summary": "Create artifact",
|
|
1202
|
+
"tags": [
|
|
1203
|
+
"Artifacts"
|
|
1204
|
+
]
|
|
1205
|
+
},
|
|
1206
|
+
"summary": "Manage the collection of artifacts within a single group in the registry."
|
|
1207
|
+
},
|
|
1208
|
+
"/groups/{groupId}/artifacts/{artifactId}": {
|
|
1209
|
+
"delete": {
|
|
1210
|
+
"description": "Deletes an artifact completely, resulting in all versions of the artifact also being\ndeleted. This may fail for one of the following reasons:\n\n* No artifact with the `artifactId` exists (HTTP error `404`)\n* A server error occurred (HTTP error `500`)",
|
|
1211
|
+
"operationId": "deleteArtifact",
|
|
1212
|
+
"responses": {
|
|
1213
|
+
"204": {
|
|
1214
|
+
"description": "Returned when the artifact was successfully deleted."
|
|
1215
|
+
},
|
|
1216
|
+
"404": {
|
|
1217
|
+
"$ref": "#/components/responses/NotFound"
|
|
1218
|
+
},
|
|
1219
|
+
"500": {
|
|
1220
|
+
"$ref": "#/components/responses/ServerError"
|
|
1221
|
+
}
|
|
1222
|
+
},
|
|
1223
|
+
"summary": "Delete artifact",
|
|
1224
|
+
"tags": [
|
|
1225
|
+
"Artifacts"
|
|
1226
|
+
]
|
|
1227
|
+
},
|
|
1228
|
+
"get": {
|
|
1229
|
+
"description": "Returns the latest version of the artifact in its raw form. The `Content-Type` of the\nresponse depends on the artifact type. In most cases, this is `application/json`, but \nfor some types it may be different (for example, `PROTOBUF`).\n\nThis operation may fail for one of the following reasons:\n\n* No artifact with this `artifactId` exists (HTTP error `404`)\n* A server error occurred (HTTP error `500`)\n",
|
|
1230
|
+
"operationId": "getLatestArtifact",
|
|
1231
|
+
"parameters": [
|
|
1232
|
+
{
|
|
1233
|
+
"description": "Allows the user to specify if the content should be dereferenced when being returned",
|
|
1234
|
+
"in": "query",
|
|
1235
|
+
"name": "dereference",
|
|
1236
|
+
"required": false,
|
|
1237
|
+
"schema": {
|
|
1238
|
+
"type": "boolean"
|
|
1239
|
+
}
|
|
1240
|
+
}
|
|
1241
|
+
],
|
|
1242
|
+
"responses": {
|
|
1243
|
+
"200": {
|
|
1244
|
+
"$ref": "#/components/responses/ArtifactContent"
|
|
1245
|
+
},
|
|
1246
|
+
"404": {
|
|
1247
|
+
"$ref": "#/components/responses/NotFound"
|
|
1248
|
+
},
|
|
1249
|
+
"500": {
|
|
1250
|
+
"$ref": "#/components/responses/ServerError"
|
|
1251
|
+
}
|
|
1252
|
+
},
|
|
1253
|
+
"summary": "Get latest artifact",
|
|
1254
|
+
"tags": [
|
|
1255
|
+
"Artifacts"
|
|
1256
|
+
]
|
|
1257
|
+
},
|
|
1258
|
+
"parameters": [
|
|
1259
|
+
{
|
|
1260
|
+
"description": "The artifact group ID. Must be a string provided by the client, representing the name of the grouping of artifacts.",
|
|
1261
|
+
"in": "path",
|
|
1262
|
+
"name": "groupId",
|
|
1263
|
+
"required": true,
|
|
1264
|
+
"schema": {
|
|
1265
|
+
"$ref": "#/components/schemas/GroupId"
|
|
1266
|
+
}
|
|
1267
|
+
},
|
|
1268
|
+
{
|
|
1269
|
+
"description": "The artifact ID. Can be a string (client-provided) or UUID (server-generated), representing the unique artifact identifier.",
|
|
1270
|
+
"in": "path",
|
|
1271
|
+
"name": "artifactId",
|
|
1272
|
+
"required": true,
|
|
1273
|
+
"schema": {
|
|
1274
|
+
"$ref": "#/components/schemas/ArtifactId"
|
|
1275
|
+
}
|
|
1276
|
+
}
|
|
1277
|
+
],
|
|
1278
|
+
"put": {
|
|
1279
|
+
"description": "Updates an artifact by uploading new content. The body of the request can\nbe the raw content of the artifact or a JSON object containing both the raw content and\na set of references to other artifacts.. This is typically in JSON format for *most*\nof the supported types, but may be in another format for a few (for example, `PROTOBUF`).\nThe type of the content should be compatible with the artifact's type (it would be\nan error to update an `AVRO` artifact with new `OPENAPI` content, for example).\n\nThe update could fail for a number of reasons including:\n\n* Provided content (request body) was empty (HTTP error `400`)\n* No artifact with the `artifactId` exists (HTTP error `404`)\n* The new content violates one of the rules configured for the artifact (HTTP error `409`)\n* A server error occurred (HTTP error `500`)\n\nWhen successful, this creates a new version of the artifact, making it the most recent\n(and therefore official) version of the artifact.",
|
|
1280
|
+
"operationId": "updateArtifact",
|
|
1281
|
+
"parameters": [
|
|
1282
|
+
{
|
|
1283
|
+
"description": "Specifies the version number of this new version of the artifact content. This would typically\nbe a simple integer or a SemVer value. If not provided, the server will assign a version number\nautomatically.",
|
|
1284
|
+
"in": "header",
|
|
1285
|
+
"name": "X-Registry-Version",
|
|
1286
|
+
"schema": {
|
|
1287
|
+
"$ref": "#/components/schemas/Version"
|
|
1288
|
+
}
|
|
1289
|
+
},
|
|
1290
|
+
{
|
|
1291
|
+
"description": "Specifies the artifact name of this new version of the artifact content. Name must be ASCII-only string. If this is not\nprovided, the server will extract the name from the artifact content.",
|
|
1292
|
+
"in": "header",
|
|
1293
|
+
"name": "X-Registry-Name",
|
|
1294
|
+
"schema": {
|
|
1295
|
+
"$ref": "#/components/schemas/ArtifactName"
|
|
1296
|
+
}
|
|
1297
|
+
},
|
|
1298
|
+
{
|
|
1299
|
+
"description": "Specifies the artifact name of this new version of the artifact content. Value of this must be Base64 encoded string. If this is not provided, the server will extract the name from the artifact content.",
|
|
1300
|
+
"in": "header",
|
|
1301
|
+
"name": "X-Registry-Name-Encoded",
|
|
1302
|
+
"schema": {
|
|
1303
|
+
"$ref": "#/components/schemas/EncodedArtifactName"
|
|
1304
|
+
}
|
|
1305
|
+
},
|
|
1306
|
+
{
|
|
1307
|
+
"description": "Specifies the artifact description of this new version of the artifact content. Description must be ASCII-only string. If this is not provided, the server will extract the description from the artifact content.",
|
|
1308
|
+
"in": "header",
|
|
1309
|
+
"name": "X-Registry-Description",
|
|
1310
|
+
"schema": {
|
|
1311
|
+
"$ref": "#/components/schemas/ArtifactDescription"
|
|
1312
|
+
}
|
|
1313
|
+
},
|
|
1314
|
+
{
|
|
1315
|
+
"description": "Specifies the artifact description of this new version of the artifact content. Value of this must be Base64 encoded string. If this is not provided, the server will extract the description from the artifact content.",
|
|
1316
|
+
"in": "header",
|
|
1317
|
+
"name": "X-Registry-Description-Encoded",
|
|
1318
|
+
"schema": {
|
|
1319
|
+
"$ref": "#/components/schemas/EncodedArtifactDescription"
|
|
1320
|
+
}
|
|
1321
|
+
}
|
|
1322
|
+
],
|
|
1323
|
+
"requestBody": {
|
|
1324
|
+
"content": {
|
|
1325
|
+
"*/*": {
|
|
1326
|
+
"examples": {
|
|
1327
|
+
"OpenAPI Example": {
|
|
1328
|
+
"value": {
|
|
1329
|
+
"components": {
|
|
1330
|
+
"schemas": {
|
|
1331
|
+
"Widget": {
|
|
1332
|
+
"description": "A sample data type.",
|
|
1333
|
+
"example": {
|
|
1334
|
+
"property-1": "value1",
|
|
1335
|
+
"property-2": true
|
|
1336
|
+
},
|
|
1337
|
+
"properties": {
|
|
1338
|
+
"property-1": {
|
|
1339
|
+
"type": "string"
|
|
1340
|
+
},
|
|
1341
|
+
"property-2": {
|
|
1342
|
+
"type": "boolean"
|
|
1343
|
+
}
|
|
1344
|
+
},
|
|
1345
|
+
"title": "Root Type for Widget",
|
|
1346
|
+
"type": "object"
|
|
1347
|
+
}
|
|
1348
|
+
}
|
|
1349
|
+
},
|
|
1350
|
+
"info": {
|
|
1351
|
+
"description": "An example API design using OpenAPI.",
|
|
1352
|
+
"title": "Empty API",
|
|
1353
|
+
"version": "1.0.7"
|
|
1354
|
+
},
|
|
1355
|
+
"openapi": "3.0.2",
|
|
1356
|
+
"paths": {
|
|
1357
|
+
"/widgets": {
|
|
1358
|
+
"get": {
|
|
1359
|
+
"responses": {
|
|
1360
|
+
"200": {
|
|
1361
|
+
"content": {
|
|
1362
|
+
"application/json": {
|
|
1363
|
+
"schema": {
|
|
1364
|
+
"items": {
|
|
1365
|
+
"type": "string"
|
|
1366
|
+
},
|
|
1367
|
+
"type": "array"
|
|
1368
|
+
}
|
|
1369
|
+
}
|
|
1370
|
+
},
|
|
1371
|
+
"description": "All widgets"
|
|
1372
|
+
}
|
|
1373
|
+
},
|
|
1374
|
+
"summary": "Get widgets"
|
|
1375
|
+
}
|
|
1376
|
+
}
|
|
1377
|
+
}
|
|
1378
|
+
}
|
|
1379
|
+
}
|
|
1380
|
+
},
|
|
1381
|
+
"schema": {
|
|
1382
|
+
"$ref": "#/components/schemas/FileContent"
|
|
1383
|
+
}
|
|
1384
|
+
},
|
|
1385
|
+
"application/create.extended+json": {
|
|
1386
|
+
"schema": {
|
|
1387
|
+
"$ref": "#/components/schemas/ContentCreateRequest"
|
|
1388
|
+
}
|
|
1389
|
+
},
|
|
1390
|
+
"application/vnd.create.extended+json": {
|
|
1391
|
+
"schema": {
|
|
1392
|
+
"$ref": "#/components/schemas/ContentCreateRequest"
|
|
1393
|
+
}
|
|
1394
|
+
}
|
|
1395
|
+
},
|
|
1396
|
+
"description": "The new content of the artifact being updated. This is often, but not always, JSON data\nrepresenting one of the supported artifact types:\n\n* Avro (`AVRO`)\n* Protobuf (`PROTOBUF`)\n* JSON Schema (`JSON`)\n* Kafka Connect (`KCONNECT`)\n* OpenAPI (`OPENAPI`)\n* AsyncAPI (`ASYNCAPI`)\n* GraphQL (`GRAPHQL`)\n* Web Services Description Language (`WSDL`)\n* XML Schema (`XSD`)\n",
|
|
1397
|
+
"required": true
|
|
1398
|
+
},
|
|
1399
|
+
"responses": {
|
|
1400
|
+
"200": {
|
|
1401
|
+
"content": {
|
|
1402
|
+
"application/json": {
|
|
1403
|
+
"schema": {
|
|
1404
|
+
"$ref": "#/components/schemas/ArtifactMetaData"
|
|
1405
|
+
}
|
|
1406
|
+
}
|
|
1407
|
+
},
|
|
1408
|
+
"description": "When successful, returns the updated artifact metadata."
|
|
1409
|
+
},
|
|
1410
|
+
"404": {
|
|
1411
|
+
"$ref": "#/components/responses/NotFound"
|
|
1412
|
+
},
|
|
1413
|
+
"409": {
|
|
1414
|
+
"$ref": "#/components/responses/Conflict"
|
|
1415
|
+
},
|
|
1416
|
+
"500": {
|
|
1417
|
+
"$ref": "#/components/responses/ServerError"
|
|
1418
|
+
}
|
|
1419
|
+
},
|
|
1420
|
+
"summary": "Update artifact",
|
|
1421
|
+
"tags": [
|
|
1422
|
+
"Artifacts"
|
|
1423
|
+
]
|
|
1424
|
+
},
|
|
1425
|
+
"summary": "Manage a single artifact."
|
|
1426
|
+
},
|
|
1427
|
+
"/groups/{groupId}/artifacts/{artifactId}/meta": {
|
|
1428
|
+
"get": {
|
|
1429
|
+
"description": "Gets the metadata for an artifact in the registry. The returned metadata includes\nboth generated (read-only) and editable metadata (such as name and description).\n\nThis operation can fail for the following reasons:\n\n* No artifact with this `artifactId` exists (HTTP error `404`)\n* A server error occurred (HTTP error `500`)",
|
|
1430
|
+
"operationId": "getArtifactMetaData",
|
|
1431
|
+
"responses": {
|
|
1432
|
+
"200": {
|
|
1433
|
+
"content": {
|
|
1434
|
+
"application/json": {
|
|
1435
|
+
"schema": {
|
|
1436
|
+
"$ref": "#/components/schemas/ArtifactMetaData"
|
|
1437
|
+
}
|
|
1438
|
+
}
|
|
1439
|
+
},
|
|
1440
|
+
"description": "The artifact's metadata."
|
|
1441
|
+
},
|
|
1442
|
+
"404": {
|
|
1443
|
+
"$ref": "#/components/responses/NotFound"
|
|
1444
|
+
},
|
|
1445
|
+
"500": {
|
|
1446
|
+
"$ref": "#/components/responses/ServerError"
|
|
1447
|
+
}
|
|
1448
|
+
},
|
|
1449
|
+
"summary": "Get artifact metadata",
|
|
1450
|
+
"tags": [
|
|
1451
|
+
"Metadata"
|
|
1452
|
+
]
|
|
1453
|
+
},
|
|
1454
|
+
"parameters": [
|
|
1455
|
+
{
|
|
1456
|
+
"description": "The artifact group ID. Must be a string provided by the client, representing the name of the grouping of artifacts.",
|
|
1457
|
+
"in": "path",
|
|
1458
|
+
"name": "groupId",
|
|
1459
|
+
"required": true,
|
|
1460
|
+
"schema": {
|
|
1461
|
+
"$ref": "#/components/schemas/GroupId"
|
|
1462
|
+
}
|
|
1463
|
+
},
|
|
1464
|
+
{
|
|
1465
|
+
"description": "The artifact ID. Can be a string (client-provided) or UUID (server-generated), representing the unique artifact identifier.",
|
|
1466
|
+
"in": "path",
|
|
1467
|
+
"name": "artifactId",
|
|
1468
|
+
"required": true,
|
|
1469
|
+
"schema": {
|
|
1470
|
+
"$ref": "#/components/schemas/ArtifactId"
|
|
1471
|
+
}
|
|
1472
|
+
}
|
|
1473
|
+
],
|
|
1474
|
+
"post": {
|
|
1475
|
+
"description": "Gets the metadata for an artifact that matches the raw content. Searches the registry\nfor a version of the given artifact matching the content provided in the body of the\nPOST.\n\nThis operation can fail for the following reasons:\n\n* Provided content (request body) was empty (HTTP error `400`)\n* No artifact with the `artifactId` exists (HTTP error `404`)\n* No artifact version matching the provided content exists (HTTP error `404`)\n* A server error occurred (HTTP error `500`)\n",
|
|
1476
|
+
"operationId": "getArtifactVersionMetaDataByContent",
|
|
1477
|
+
"parameters": [
|
|
1478
|
+
{
|
|
1479
|
+
"description": "Parameter that can be set to `true` to indicate that the server should \"canonicalize\" the content when searching for a matching version. Canonicalization is unique to each artifact type, but typically involves removing any extra whitespace and formatting the content in a consistent manner.",
|
|
1480
|
+
"in": "query",
|
|
1481
|
+
"name": "canonical",
|
|
1482
|
+
"schema": {
|
|
1483
|
+
"type": "boolean"
|
|
1484
|
+
}
|
|
1485
|
+
}
|
|
1486
|
+
],
|
|
1487
|
+
"requestBody": {
|
|
1488
|
+
"content": {
|
|
1489
|
+
"*/*": {
|
|
1490
|
+
"examples": {
|
|
1491
|
+
"OpenAPI": {
|
|
1492
|
+
"value": {
|
|
1493
|
+
"components": {
|
|
1494
|
+
"schemas": {
|
|
1495
|
+
"Widget": {
|
|
1496
|
+
"description": "A sample data type.",
|
|
1497
|
+
"example": {
|
|
1498
|
+
"property-1": "value1",
|
|
1499
|
+
"property-2": true
|
|
1500
|
+
},
|
|
1501
|
+
"properties": {
|
|
1502
|
+
"property-1": {
|
|
1503
|
+
"type": "string"
|
|
1504
|
+
},
|
|
1505
|
+
"property-2": {
|
|
1506
|
+
"type": "boolean"
|
|
1507
|
+
}
|
|
1508
|
+
},
|
|
1509
|
+
"title": "Root Type for Widget",
|
|
1510
|
+
"type": "object"
|
|
1511
|
+
}
|
|
1512
|
+
}
|
|
1513
|
+
},
|
|
1514
|
+
"info": {
|
|
1515
|
+
"description": "An example API design using OpenAPI.",
|
|
1516
|
+
"title": "Empty API",
|
|
1517
|
+
"version": "1.0.7"
|
|
1518
|
+
},
|
|
1519
|
+
"openapi": "3.0.2",
|
|
1520
|
+
"paths": {
|
|
1521
|
+
"/widgets": {
|
|
1522
|
+
"get": {
|
|
1523
|
+
"responses": {
|
|
1524
|
+
"200": {
|
|
1525
|
+
"content": {
|
|
1526
|
+
"application/json": {
|
|
1527
|
+
"schema": {
|
|
1528
|
+
"items": {
|
|
1529
|
+
"type": "string"
|
|
1530
|
+
},
|
|
1531
|
+
"type": "array"
|
|
1532
|
+
}
|
|
1533
|
+
}
|
|
1534
|
+
},
|
|
1535
|
+
"description": "All widgets"
|
|
1536
|
+
}
|
|
1537
|
+
},
|
|
1538
|
+
"summary": "Get widgets"
|
|
1539
|
+
}
|
|
1540
|
+
}
|
|
1541
|
+
}
|
|
1542
|
+
}
|
|
1543
|
+
}
|
|
1544
|
+
},
|
|
1545
|
+
"schema": {
|
|
1546
|
+
"$ref": "#/components/schemas/FileContent"
|
|
1547
|
+
}
|
|
1548
|
+
}
|
|
1549
|
+
},
|
|
1550
|
+
"description": "The content of an artifact version.",
|
|
1551
|
+
"required": true
|
|
1552
|
+
},
|
|
1553
|
+
"responses": {
|
|
1554
|
+
"200": {
|
|
1555
|
+
"content": {
|
|
1556
|
+
"application/json": {
|
|
1557
|
+
"schema": {
|
|
1558
|
+
"$ref": "#/components/schemas/VersionMetaData"
|
|
1559
|
+
}
|
|
1560
|
+
}
|
|
1561
|
+
},
|
|
1562
|
+
"description": "The metadata of the artifact version matching the provided content."
|
|
1563
|
+
},
|
|
1564
|
+
"404": {
|
|
1565
|
+
"$ref": "#/components/responses/NotFound"
|
|
1566
|
+
},
|
|
1567
|
+
"500": {
|
|
1568
|
+
"$ref": "#/components/responses/ServerError"
|
|
1569
|
+
}
|
|
1570
|
+
},
|
|
1571
|
+
"summary": "Get artifact version metadata by content",
|
|
1572
|
+
"tags": [
|
|
1573
|
+
"Metadata"
|
|
1574
|
+
]
|
|
1575
|
+
},
|
|
1576
|
+
"put": {
|
|
1577
|
+
"description": "Updates the editable parts of the artifact's metadata. Not all metadata fields can\nbe updated. For example, `createdOn` and `createdBy` are both read-only properties.\n\nThis operation can fail for the following reasons:\n\n* No artifact with the `artifactId` exists (HTTP error `404`)\n* A server error occurred (HTTP error `500`)",
|
|
1578
|
+
"operationId": "updateArtifactMetaData",
|
|
1579
|
+
"requestBody": {
|
|
1580
|
+
"content": {
|
|
1581
|
+
"application/json": {
|
|
1582
|
+
"schema": {
|
|
1583
|
+
"$ref": "#/components/schemas/EditableMetaData"
|
|
1584
|
+
}
|
|
1585
|
+
}
|
|
1586
|
+
},
|
|
1587
|
+
"description": "Updated artifact metadata.",
|
|
1588
|
+
"required": true
|
|
1589
|
+
},
|
|
1590
|
+
"responses": {
|
|
1591
|
+
"204": {
|
|
1592
|
+
"description": "The artifact's metadata was updated."
|
|
1593
|
+
},
|
|
1594
|
+
"404": {
|
|
1595
|
+
"$ref": "#/components/responses/NotFound"
|
|
1596
|
+
},
|
|
1597
|
+
"500": {
|
|
1598
|
+
"$ref": "#/components/responses/ServerError"
|
|
1599
|
+
}
|
|
1600
|
+
},
|
|
1601
|
+
"summary": "Update artifact metadata",
|
|
1602
|
+
"tags": [
|
|
1603
|
+
"Metadata"
|
|
1604
|
+
]
|
|
1605
|
+
},
|
|
1606
|
+
"summary": "Manage the metadata of a single artifact."
|
|
1607
|
+
},
|
|
1608
|
+
"/groups/{groupId}/artifacts/{artifactId}/owner": {
|
|
1609
|
+
"get": {
|
|
1610
|
+
"description": "Gets the owner of an artifact in the registry.\n\nThis operation can fail for the following reasons:\n\n* No artifact with this `artifactId` exists (HTTP error `404`)\n* A server error occurred (HTTP error `500`)",
|
|
1611
|
+
"operationId": "getArtifactOwner",
|
|
1612
|
+
"responses": {
|
|
1613
|
+
"200": {
|
|
1614
|
+
"content": {
|
|
1615
|
+
"application/json": {
|
|
1616
|
+
"schema": {
|
|
1617
|
+
"$ref": "#/components/schemas/ArtifactOwner"
|
|
1618
|
+
}
|
|
1619
|
+
}
|
|
1620
|
+
},
|
|
1621
|
+
"description": "The artifact's owner."
|
|
1622
|
+
},
|
|
1623
|
+
"404": {
|
|
1624
|
+
"$ref": "#/components/responses/NotFound"
|
|
1625
|
+
},
|
|
1626
|
+
"500": {
|
|
1627
|
+
"$ref": "#/components/responses/ServerError"
|
|
1628
|
+
}
|
|
1629
|
+
},
|
|
1630
|
+
"summary": "Get artifact owner",
|
|
1631
|
+
"tags": [
|
|
1632
|
+
"Metadata"
|
|
1633
|
+
]
|
|
1634
|
+
},
|
|
1635
|
+
"parameters": [
|
|
1636
|
+
{
|
|
1637
|
+
"description": "The artifact group ID. Must be a string provided by the client, representing the name of the grouping of artifacts.",
|
|
1638
|
+
"in": "path",
|
|
1639
|
+
"name": "groupId",
|
|
1640
|
+
"required": true,
|
|
1641
|
+
"schema": {
|
|
1642
|
+
"$ref": "#/components/schemas/GroupId"
|
|
1643
|
+
}
|
|
1644
|
+
},
|
|
1645
|
+
{
|
|
1646
|
+
"description": "The artifact ID. Can be a string (client-provided) or UUID (server-generated), representing the unique artifact identifier.",
|
|
1647
|
+
"in": "path",
|
|
1648
|
+
"name": "artifactId",
|
|
1649
|
+
"required": true,
|
|
1650
|
+
"schema": {
|
|
1651
|
+
"$ref": "#/components/schemas/ArtifactId"
|
|
1652
|
+
}
|
|
1653
|
+
}
|
|
1654
|
+
],
|
|
1655
|
+
"put": {
|
|
1656
|
+
"description": "Changes the ownership of an artifact.\n\nThis operation can fail for the following reasons:\n\n* No artifact with this `artifactId` exists (HTTP error `404`)\n* A server error occurred (HTTP error `500`)",
|
|
1657
|
+
"operationId": "updateArtifactOwner",
|
|
1658
|
+
"requestBody": {
|
|
1659
|
+
"content": {
|
|
1660
|
+
"application/json": {
|
|
1661
|
+
"schema": {
|
|
1662
|
+
"$ref": "#/components/schemas/ArtifactOwner"
|
|
1663
|
+
}
|
|
1664
|
+
}
|
|
1665
|
+
},
|
|
1666
|
+
"required": true
|
|
1667
|
+
},
|
|
1668
|
+
"responses": {
|
|
1669
|
+
"204": {
|
|
1670
|
+
"description": "The owner was successfully changed."
|
|
1671
|
+
},
|
|
1672
|
+
"404": {
|
|
1673
|
+
"$ref": "#/components/responses/NotFound"
|
|
1674
|
+
},
|
|
1675
|
+
"500": {
|
|
1676
|
+
"$ref": "#/components/responses/ServerError"
|
|
1677
|
+
}
|
|
1678
|
+
},
|
|
1679
|
+
"summary": "Update artifact owner",
|
|
1680
|
+
"tags": [
|
|
1681
|
+
"Metadata"
|
|
1682
|
+
]
|
|
1683
|
+
},
|
|
1684
|
+
"summary": "Manage the ownership of a single artifact."
|
|
1685
|
+
},
|
|
1686
|
+
"/groups/{groupId}/artifacts/{artifactId}/rules": {
|
|
1687
|
+
"delete": {
|
|
1688
|
+
"description": "Deletes all of the rules configured for the artifact. After this is done, the global\nrules apply to the artifact again.\n\nThis operation can fail for the following reasons:\n\n* No artifact with this `artifactId` exists (HTTP error `404`)\n* A server error occurred (HTTP error `500`)",
|
|
1689
|
+
"operationId": "deleteArtifactRules",
|
|
1690
|
+
"responses": {
|
|
1691
|
+
"204": {
|
|
1692
|
+
"description": "The rules were successfully deleted."
|
|
1693
|
+
},
|
|
1694
|
+
"404": {
|
|
1695
|
+
"$ref": "#/components/responses/NotFound"
|
|
1696
|
+
},
|
|
1697
|
+
"500": {
|
|
1698
|
+
"$ref": "#/components/responses/ServerError"
|
|
1699
|
+
}
|
|
1700
|
+
},
|
|
1701
|
+
"summary": "Delete artifact rules",
|
|
1702
|
+
"tags": [
|
|
1703
|
+
"Artifact rules"
|
|
1704
|
+
]
|
|
1705
|
+
},
|
|
1706
|
+
"get": {
|
|
1707
|
+
"description": "Returns a list of all rules configured for the artifact. The set of rules determines\nhow the content of an artifact can evolve over time. If no rules are configured for\nan artifact, the set of globally configured rules are used. If no global rules \nare defined, there are no restrictions on content evolution.\n\nThis operation can fail for the following reasons:\n\n* No artifact with this `artifactId` exists (HTTP error `404`)\n* A server error occurred (HTTP error `500`)",
|
|
1708
|
+
"operationId": "listArtifactRules",
|
|
1709
|
+
"responses": {
|
|
1710
|
+
"200": {
|
|
1711
|
+
"content": {
|
|
1712
|
+
"application/json": {
|
|
1713
|
+
"schema": {
|
|
1714
|
+
"items": {
|
|
1715
|
+
"$ref": "#/components/schemas/RuleType"
|
|
1716
|
+
},
|
|
1717
|
+
"type": "array"
|
|
1718
|
+
}
|
|
1719
|
+
}
|
|
1720
|
+
},
|
|
1721
|
+
"description": "Returns the names of the rules configured for the artifact."
|
|
1722
|
+
},
|
|
1723
|
+
"404": {
|
|
1724
|
+
"$ref": "#/components/responses/NotFound"
|
|
1725
|
+
},
|
|
1726
|
+
"500": {
|
|
1727
|
+
"$ref": "#/components/responses/ServerError"
|
|
1728
|
+
}
|
|
1729
|
+
},
|
|
1730
|
+
"summary": "List artifact rules",
|
|
1731
|
+
"tags": [
|
|
1732
|
+
"Artifact rules"
|
|
1733
|
+
]
|
|
1734
|
+
},
|
|
1735
|
+
"parameters": [
|
|
1736
|
+
{
|
|
1737
|
+
"description": "The artifact group ID. Must be a string provided by the client, representing the name of the grouping of artifacts.",
|
|
1738
|
+
"in": "path",
|
|
1739
|
+
"name": "groupId",
|
|
1740
|
+
"required": true,
|
|
1741
|
+
"schema": {
|
|
1742
|
+
"$ref": "#/components/schemas/GroupId"
|
|
1743
|
+
}
|
|
1744
|
+
},
|
|
1745
|
+
{
|
|
1746
|
+
"description": "The artifact ID. Can be a string (client-provided) or UUID (server-generated), representing the unique artifact identifier.",
|
|
1747
|
+
"in": "path",
|
|
1748
|
+
"name": "artifactId",
|
|
1749
|
+
"required": true,
|
|
1750
|
+
"schema": {
|
|
1751
|
+
"$ref": "#/components/schemas/ArtifactId"
|
|
1752
|
+
}
|
|
1753
|
+
}
|
|
1754
|
+
],
|
|
1755
|
+
"post": {
|
|
1756
|
+
"description": "Adds a rule to the list of rules that get applied to the artifact when adding new\nversions. All configured rules must pass to successfully add a new artifact version.\n\nThis operation can fail for the following reasons:\n\n* No artifact with this `artifactId` exists (HTTP error `404`)\n* Rule (named in the request body) is unknown (HTTP error `400`)\n* A server error occurred (HTTP error `500`)",
|
|
1757
|
+
"operationId": "createArtifactRule",
|
|
1758
|
+
"requestBody": {
|
|
1759
|
+
"content": {
|
|
1760
|
+
"application/json": {
|
|
1761
|
+
"schema": {
|
|
1762
|
+
"$ref": "#/components/schemas/Rule"
|
|
1763
|
+
}
|
|
1764
|
+
}
|
|
1765
|
+
},
|
|
1766
|
+
"required": true
|
|
1767
|
+
},
|
|
1768
|
+
"responses": {
|
|
1769
|
+
"204": {
|
|
1770
|
+
"description": "The rule was added."
|
|
1771
|
+
},
|
|
1772
|
+
"400": {
|
|
1773
|
+
"$ref": "#/components/responses/BadRequest"
|
|
1774
|
+
},
|
|
1775
|
+
"404": {
|
|
1776
|
+
"$ref": "#/components/responses/NotFound"
|
|
1777
|
+
},
|
|
1778
|
+
"500": {
|
|
1779
|
+
"$ref": "#/components/responses/ServerError"
|
|
1780
|
+
}
|
|
1781
|
+
},
|
|
1782
|
+
"summary": "Create artifact rule",
|
|
1783
|
+
"tags": [
|
|
1784
|
+
"Artifact rules"
|
|
1785
|
+
]
|
|
1786
|
+
},
|
|
1787
|
+
"summary": "Manage the rules for a single artifact."
|
|
1788
|
+
},
|
|
1789
|
+
"/groups/{groupId}/artifacts/{artifactId}/rules/{rule}": {
|
|
1790
|
+
"delete": {
|
|
1791
|
+
"description": "Deletes a rule from the artifact. This results in the rule no longer applying for\nthis artifact. If this is the only rule configured for the artifact, this is the \nsame as deleting **all** rules, and the globally configured rules now apply to\nthis artifact.\n\nThis operation can fail for the following reasons:\n\n* No artifact with this `artifactId` exists (HTTP error `404`)\n* No rule with this name/type is configured for this artifact (HTTP error `404`)\n* Invalid rule type (HTTP error `400`)\n* A server error occurred (HTTP error `500`)",
|
|
1792
|
+
"operationId": "deleteArtifactRule",
|
|
1793
|
+
"responses": {
|
|
1794
|
+
"204": {
|
|
1795
|
+
"description": "The rule was successfully deleted."
|
|
1796
|
+
},
|
|
1797
|
+
"404": {
|
|
1798
|
+
"$ref": "#/components/responses/NotFound"
|
|
1799
|
+
},
|
|
1800
|
+
"500": {
|
|
1801
|
+
"$ref": "#/components/responses/ServerError"
|
|
1802
|
+
}
|
|
1803
|
+
},
|
|
1804
|
+
"summary": "Delete artifact rule",
|
|
1805
|
+
"tags": [
|
|
1806
|
+
"Artifact rules"
|
|
1807
|
+
]
|
|
1808
|
+
},
|
|
1809
|
+
"get": {
|
|
1810
|
+
"description": "Returns information about a single rule configured for an artifact. This is useful\nwhen you want to know what the current configuration settings are for a specific rule.\n\nThis operation can fail for the following reasons:\n\n* No artifact with this `artifactId` exists (HTTP error `404`)\n* No rule with this name/type is configured for this artifact (HTTP error `404`)\n* Invalid rule type (HTTP error `400`)\n* A server error occurred (HTTP error `500`)",
|
|
1811
|
+
"operationId": "getArtifactRuleConfig",
|
|
1812
|
+
"responses": {
|
|
1813
|
+
"200": {
|
|
1814
|
+
"content": {
|
|
1815
|
+
"application/json": {
|
|
1816
|
+
"schema": {
|
|
1817
|
+
"$ref": "#/components/schemas/Rule"
|
|
1818
|
+
}
|
|
1819
|
+
}
|
|
1820
|
+
},
|
|
1821
|
+
"description": "Information about a rule."
|
|
1822
|
+
},
|
|
1823
|
+
"404": {
|
|
1824
|
+
"$ref": "#/components/responses/NotFound"
|
|
1825
|
+
},
|
|
1826
|
+
"500": {
|
|
1827
|
+
"$ref": "#/components/responses/ServerError"
|
|
1828
|
+
}
|
|
1829
|
+
},
|
|
1830
|
+
"summary": "Get artifact rule configuration",
|
|
1831
|
+
"tags": [
|
|
1832
|
+
"Artifact rules"
|
|
1833
|
+
]
|
|
1834
|
+
},
|
|
1835
|
+
"parameters": [
|
|
1836
|
+
{
|
|
1837
|
+
"description": "The artifact group ID. Must be a string provided by the client, representing the name of the grouping of artifacts.",
|
|
1838
|
+
"in": "path",
|
|
1839
|
+
"name": "groupId",
|
|
1840
|
+
"required": true,
|
|
1841
|
+
"schema": {
|
|
1842
|
+
"$ref": "#/components/schemas/GroupId"
|
|
1843
|
+
}
|
|
1844
|
+
},
|
|
1845
|
+
{
|
|
1846
|
+
"description": "The artifact ID. Can be a string (client-provided) or UUID (server-generated), representing the unique artifact identifier.",
|
|
1847
|
+
"in": "path",
|
|
1848
|
+
"name": "artifactId",
|
|
1849
|
+
"required": true,
|
|
1850
|
+
"schema": {
|
|
1851
|
+
"$ref": "#/components/schemas/ArtifactId"
|
|
1852
|
+
}
|
|
1853
|
+
},
|
|
1854
|
+
{
|
|
1855
|
+
"description": "The unique name/type of a rule.",
|
|
1856
|
+
"in": "path",
|
|
1857
|
+
"name": "rule",
|
|
1858
|
+
"required": true,
|
|
1859
|
+
"schema": {
|
|
1860
|
+
"enum": [
|
|
1861
|
+
"VALIDITY",
|
|
1862
|
+
"COMPATIBILITY"
|
|
1863
|
+
],
|
|
1864
|
+
"type": "string"
|
|
1865
|
+
}
|
|
1866
|
+
}
|
|
1867
|
+
],
|
|
1868
|
+
"put": {
|
|
1869
|
+
"description": "Updates the configuration of a single rule for the artifact. The configuration data\nis specific to each rule type, so the configuration of the `COMPATIBILITY` rule \nis in a different format from the configuration of the `VALIDITY` rule.\n\nThis operation can fail for the following reasons:\n\n* No artifact with this `artifactId` exists (HTTP error `404`)\n* No rule with this name/type is configured for this artifact (HTTP error `404`)\n* Invalid rule type (HTTP error `400`)\n* A server error occurred (HTTP error `500`)\n",
|
|
1870
|
+
"operationId": "updateArtifactRuleConfig",
|
|
1871
|
+
"requestBody": {
|
|
1872
|
+
"content": {
|
|
1873
|
+
"application/json": {
|
|
1874
|
+
"schema": {
|
|
1875
|
+
"$ref": "#/components/schemas/Rule"
|
|
1876
|
+
}
|
|
1877
|
+
}
|
|
1878
|
+
},
|
|
1879
|
+
"required": true
|
|
1880
|
+
},
|
|
1881
|
+
"responses": {
|
|
1882
|
+
"200": {
|
|
1883
|
+
"content": {
|
|
1884
|
+
"application/json": {
|
|
1885
|
+
"schema": {
|
|
1886
|
+
"$ref": "#/components/schemas/Rule"
|
|
1887
|
+
}
|
|
1888
|
+
}
|
|
1889
|
+
},
|
|
1890
|
+
"description": "Rule configuration was updated."
|
|
1891
|
+
},
|
|
1892
|
+
"404": {
|
|
1893
|
+
"$ref": "#/components/responses/NotFound"
|
|
1894
|
+
},
|
|
1895
|
+
"500": {
|
|
1896
|
+
"$ref": "#/components/responses/ServerError"
|
|
1897
|
+
}
|
|
1898
|
+
},
|
|
1899
|
+
"summary": "Update artifact rule configuration",
|
|
1900
|
+
"tags": [
|
|
1901
|
+
"Artifact rules"
|
|
1902
|
+
]
|
|
1903
|
+
},
|
|
1904
|
+
"summary": "Manage the configuration of a single artifact rule."
|
|
1905
|
+
},
|
|
1906
|
+
"/groups/{groupId}/artifacts/{artifactId}/state": {
|
|
1907
|
+
"parameters": [
|
|
1908
|
+
{
|
|
1909
|
+
"description": "The artifact group ID. Must be a string provided by the client, representing the name of the grouping of artifacts.",
|
|
1910
|
+
"in": "path",
|
|
1911
|
+
"name": "groupId",
|
|
1912
|
+
"required": true,
|
|
1913
|
+
"schema": {
|
|
1914
|
+
"$ref": "#/components/schemas/GroupId"
|
|
1915
|
+
}
|
|
1916
|
+
},
|
|
1917
|
+
{
|
|
1918
|
+
"description": "The artifact ID. Can be a string (client-provided) or UUID (server-generated), representing the unique artifact identifier.",
|
|
1919
|
+
"in": "path",
|
|
1920
|
+
"name": "artifactId",
|
|
1921
|
+
"required": true,
|
|
1922
|
+
"schema": {
|
|
1923
|
+
"$ref": "#/components/schemas/ArtifactId"
|
|
1924
|
+
}
|
|
1925
|
+
}
|
|
1926
|
+
],
|
|
1927
|
+
"put": {
|
|
1928
|
+
"description": "Updates the state of the artifact. For example, you can use this to mark the latest\nversion of an artifact as `DEPRECATED`. The operation changes the state of the latest \nversion of the artifact. If multiple versions exist, only the most recent is changed.\n\nThis operation can fail for the following reasons:\n\n* No artifact with this `artifactId` exists (HTTP error `404`)\n* A server error occurred (HTTP error `500`)\n",
|
|
1929
|
+
"operationId": "updateArtifactState",
|
|
1930
|
+
"requestBody": {
|
|
1931
|
+
"content": {
|
|
1932
|
+
"application/json": {
|
|
1933
|
+
"schema": {
|
|
1934
|
+
"$ref": "#/components/schemas/UpdateState"
|
|
1935
|
+
}
|
|
1936
|
+
}
|
|
1937
|
+
},
|
|
1938
|
+
"required": true
|
|
1939
|
+
},
|
|
1940
|
+
"responses": {
|
|
1941
|
+
"204": {
|
|
1942
|
+
"description": "Returned when the operation was successful."
|
|
1943
|
+
},
|
|
1944
|
+
"400": {
|
|
1945
|
+
"$ref": "#/components/responses/BadRequest"
|
|
1946
|
+
},
|
|
1947
|
+
"404": {
|
|
1948
|
+
"$ref": "#/components/responses/NotFound"
|
|
1949
|
+
},
|
|
1950
|
+
"500": {
|
|
1951
|
+
"$ref": "#/components/responses/ServerError"
|
|
1952
|
+
}
|
|
1953
|
+
},
|
|
1954
|
+
"summary": "Update artifact state",
|
|
1955
|
+
"tags": [
|
|
1956
|
+
"Artifacts"
|
|
1957
|
+
]
|
|
1958
|
+
},
|
|
1959
|
+
"summary": "Manage the state of an artifact."
|
|
1960
|
+
},
|
|
1961
|
+
"/groups/{groupId}/artifacts/{artifactId}/test": {
|
|
1962
|
+
"parameters": [
|
|
1963
|
+
{
|
|
1964
|
+
"description": "The artifact group ID. Must be a string provided by the client, representing the name of the grouping of artifacts.",
|
|
1965
|
+
"in": "path",
|
|
1966
|
+
"name": "groupId",
|
|
1967
|
+
"required": true,
|
|
1968
|
+
"schema": {
|
|
1969
|
+
"$ref": "#/components/schemas/GroupId"
|
|
1970
|
+
}
|
|
1971
|
+
},
|
|
1972
|
+
{
|
|
1973
|
+
"description": "The artifact ID. Can be a string (client-provided) or UUID (server-generated), representing the unique artifact identifier.",
|
|
1974
|
+
"in": "path",
|
|
1975
|
+
"name": "artifactId",
|
|
1976
|
+
"required": true,
|
|
1977
|
+
"schema": {
|
|
1978
|
+
"$ref": "#/components/schemas/ArtifactId"
|
|
1979
|
+
}
|
|
1980
|
+
}
|
|
1981
|
+
],
|
|
1982
|
+
"put": {
|
|
1983
|
+
"description": "Tests whether an update to the artifact's content *would* succeed for the provided content.\nUltimately, this applies any rules configured for the artifact against the given content\nto determine whether the rules would pass or fail, but without actually updating the artifact\ncontent.\n\nThe body of the request should be the raw content of the artifact. This is typically in \nJSON format for *most* of the supported types, but may be in another format for a few \n(for example, `PROTOBUF`).\n\nThe update could fail for a number of reasons including:\n\n* Provided content (request body) was empty (HTTP error `400`)\n* No artifact with the `artifactId` exists (HTTP error `404`)\n* The new content violates one of the rules configured for the artifact (HTTP error `409`)\n* The provided artifact type is not recognized (HTTP error `404`)\n* A server error occurred (HTTP error `500`)\n\nWhen successful, this operation simply returns a *No Content* response. This response\nindicates that the content is valid against the configured content rules for the \nartifact (or the global rules if no artifact rules are enabled).",
|
|
1984
|
+
"operationId": "testUpdateArtifact",
|
|
1985
|
+
"requestBody": {
|
|
1986
|
+
"content": {
|
|
1987
|
+
"*/*": {
|
|
1988
|
+
"schema": {
|
|
1989
|
+
"$ref": "#/components/schemas/FileContent"
|
|
1990
|
+
}
|
|
1991
|
+
}
|
|
1992
|
+
},
|
|
1993
|
+
"description": "The content of the artifact being tested. This is often, but not always, JSON data\nrepresenting one of the supported artifact types:\n\n* Avro (`AVRO`)\n* Protobuf (`PROTOBUF`)\n* JSON Schema (`JSON`)\n* Kafka Connect (`KCONNECT`)\n* OpenAPI (`OPENAPI`)\n* AsyncAPI (`ASYNCAPI`)\n* GraphQL (`GRAPHQL`)\n* Web Services Description Language (`WSDL`)\n* XML Schema (`XSD`)\n",
|
|
1994
|
+
"required": true
|
|
1995
|
+
},
|
|
1996
|
+
"responses": {
|
|
1997
|
+
"204": {
|
|
1998
|
+
"description": "When successful, returns \"No Content\" to indicate that the rules passed, and the\ncontent was not updated."
|
|
1999
|
+
},
|
|
2000
|
+
"404": {
|
|
2001
|
+
"$ref": "#/components/responses/NotFound"
|
|
2002
|
+
},
|
|
2003
|
+
"409": {
|
|
2004
|
+
"$ref": "#/components/responses/RuleViolationConflict"
|
|
2005
|
+
},
|
|
2006
|
+
"500": {
|
|
2007
|
+
"$ref": "#/components/responses/ServerError"
|
|
2008
|
+
}
|
|
2009
|
+
},
|
|
2010
|
+
"summary": "Test update artifact",
|
|
2011
|
+
"tags": [
|
|
2012
|
+
"Artifact rules"
|
|
2013
|
+
]
|
|
2014
|
+
},
|
|
2015
|
+
"summary": "Test whether content would pass update rules."
|
|
2016
|
+
},
|
|
2017
|
+
"/groups/{groupId}/artifacts/{artifactId}/versions": {
|
|
2018
|
+
"get": {
|
|
2019
|
+
"description": "Returns a list of all versions of the artifact. The result set is paged.\n\nThis operation can fail for the following reasons:\n\n* No artifact with this `artifactId` exists (HTTP error `404`)\n* A server error occurred (HTTP error `500`)\n",
|
|
2020
|
+
"operationId": "listArtifactVersions",
|
|
2021
|
+
"parameters": [
|
|
2022
|
+
{
|
|
2023
|
+
"description": "The number of versions to skip before starting to collect the result set. Defaults to 0.",
|
|
2024
|
+
"in": "query",
|
|
2025
|
+
"name": "offset",
|
|
2026
|
+
"required": false,
|
|
2027
|
+
"schema": {
|
|
2028
|
+
"type": "integer"
|
|
2029
|
+
}
|
|
2030
|
+
},
|
|
2031
|
+
{
|
|
2032
|
+
"description": "The number of versions to return. Defaults to 20.",
|
|
2033
|
+
"in": "query",
|
|
2034
|
+
"name": "limit",
|
|
2035
|
+
"required": false,
|
|
2036
|
+
"schema": {
|
|
2037
|
+
"type": "integer"
|
|
2038
|
+
}
|
|
2039
|
+
}
|
|
2040
|
+
],
|
|
2041
|
+
"responses": {
|
|
2042
|
+
"200": {
|
|
2043
|
+
"content": {
|
|
2044
|
+
"application/json": {
|
|
2045
|
+
"examples": {
|
|
2046
|
+
"All Versions": {
|
|
2047
|
+
"value": [
|
|
2048
|
+
5,
|
|
2049
|
+
6,
|
|
2050
|
+
10,
|
|
2051
|
+
103
|
|
2052
|
+
]
|
|
2053
|
+
}
|
|
2054
|
+
},
|
|
2055
|
+
"schema": {
|
|
2056
|
+
"$ref": "#/components/schemas/VersionSearchResults"
|
|
2057
|
+
}
|
|
2058
|
+
}
|
|
2059
|
+
},
|
|
2060
|
+
"description": "List of all artifact versions."
|
|
2061
|
+
},
|
|
2062
|
+
"404": {
|
|
2063
|
+
"$ref": "#/components/responses/NotFound"
|
|
2064
|
+
},
|
|
2065
|
+
"500": {
|
|
2066
|
+
"$ref": "#/components/responses/ServerError"
|
|
2067
|
+
}
|
|
2068
|
+
},
|
|
2069
|
+
"summary": "List artifact versions",
|
|
2070
|
+
"tags": [
|
|
2071
|
+
"Versions"
|
|
2072
|
+
]
|
|
2073
|
+
},
|
|
2074
|
+
"parameters": [
|
|
2075
|
+
{
|
|
2076
|
+
"description": "The artifact group ID. Must be a string provided by the client, representing the name of the grouping of artifacts.",
|
|
2077
|
+
"in": "path",
|
|
2078
|
+
"name": "groupId",
|
|
2079
|
+
"required": true,
|
|
2080
|
+
"schema": {
|
|
2081
|
+
"$ref": "#/components/schemas/GroupId"
|
|
2082
|
+
}
|
|
2083
|
+
},
|
|
2084
|
+
{
|
|
2085
|
+
"description": "The artifact ID. Can be a string (client-provided) or UUID (server-generated), representing the unique artifact identifier.",
|
|
2086
|
+
"in": "path",
|
|
2087
|
+
"name": "artifactId",
|
|
2088
|
+
"required": true,
|
|
2089
|
+
"schema": {
|
|
2090
|
+
"$ref": "#/components/schemas/ArtifactId"
|
|
2091
|
+
}
|
|
2092
|
+
}
|
|
2093
|
+
],
|
|
2094
|
+
"post": {
|
|
2095
|
+
"description": "Creates a new version of the artifact by uploading new content. The configured rules for\nthe artifact are applied, and if they all pass, the new content is added as the most recent \nversion of the artifact. If any of the rules fail, an error is returned.\n\nThe body of the request can be the raw content of the new artifact version, or the raw content \nand a set of references pointing to other artifacts, and the type\nof that content should match the artifact's type (for example if the artifact type is `AVRO`\nthen the content of the request should be an Apache Avro document).\n\nThis operation can fail for the following reasons:\n\n* Provided content (request body) was empty (HTTP error `400`)\n* No artifact with this `artifactId` exists (HTTP error `404`)\n* The new content violates one of the rules configured for the artifact (HTTP error `409`)\n* A server error occurred (HTTP error `500`)\n",
|
|
2096
|
+
"operationId": "createArtifactVersion",
|
|
2097
|
+
"parameters": [
|
|
2098
|
+
{
|
|
2099
|
+
"description": "Specifies the version number of this new version of the artifact content. This would typically\nbe a simple integer or a SemVer value. It must be unique within the artifact. If this is not\nprovided, the server will generate a new, unique version number for this new updated content.",
|
|
2100
|
+
"in": "header",
|
|
2101
|
+
"name": "X-Registry-Version",
|
|
2102
|
+
"schema": {
|
|
2103
|
+
"$ref": "#/components/schemas/Version"
|
|
2104
|
+
}
|
|
2105
|
+
},
|
|
2106
|
+
{
|
|
2107
|
+
"description": "Specifies the artifact name of this new version of the artifact content. Name must be ASCII-only string. If this is not\nprovided, the server will extract the name from the artifact content.",
|
|
2108
|
+
"in": "header",
|
|
2109
|
+
"name": "X-Registry-Name",
|
|
2110
|
+
"schema": {
|
|
2111
|
+
"$ref": "#/components/schemas/ArtifactName"
|
|
2112
|
+
}
|
|
2113
|
+
},
|
|
2114
|
+
{
|
|
2115
|
+
"description": "Specifies the artifact description of this new version of the artifact content. Description must be ASCII-only string. If this is not provided, the server will extract the description from the artifact content.",
|
|
2116
|
+
"in": "header",
|
|
2117
|
+
"name": "X-Registry-Description",
|
|
2118
|
+
"schema": {
|
|
2119
|
+
"$ref": "#/components/schemas/ArtifactDescription"
|
|
2120
|
+
}
|
|
2121
|
+
},
|
|
2122
|
+
{
|
|
2123
|
+
"description": "Specifies the artifact description of this new version of the artifact content. Value of this must be Base64 encoded string. If this is not provided, the server will extract the description from the artifact content.",
|
|
2124
|
+
"in": "header",
|
|
2125
|
+
"name": "X-Registry-Description-Encoded",
|
|
2126
|
+
"schema": {
|
|
2127
|
+
"$ref": "#/components/schemas/EncodedArtifactDescription"
|
|
2128
|
+
}
|
|
2129
|
+
},
|
|
2130
|
+
{
|
|
2131
|
+
"description": "Specifies the artifact name of this new version of the artifact content. Value of this must be Base64 encoded string. If this is not provided, the server will extract the name from the artifact content.",
|
|
2132
|
+
"in": "header",
|
|
2133
|
+
"name": "X-Registry-Name-Encoded",
|
|
2134
|
+
"schema": {
|
|
2135
|
+
"$ref": "#/components/schemas/EncodedArtifactName"
|
|
2136
|
+
}
|
|
2137
|
+
}
|
|
2138
|
+
],
|
|
2139
|
+
"requestBody": {
|
|
2140
|
+
"content": {
|
|
2141
|
+
"*/*": {
|
|
2142
|
+
"examples": {
|
|
2143
|
+
"OpenAPI Example": {
|
|
2144
|
+
"value": {
|
|
2145
|
+
"components": {
|
|
2146
|
+
"schemas": {
|
|
2147
|
+
"Widget": {
|
|
2148
|
+
"description": "A sample data type.",
|
|
2149
|
+
"example": {
|
|
2150
|
+
"property-1": "value1",
|
|
2151
|
+
"property-2": true
|
|
2152
|
+
},
|
|
2153
|
+
"properties": {
|
|
2154
|
+
"property-1": {
|
|
2155
|
+
"type": "string"
|
|
2156
|
+
},
|
|
2157
|
+
"property-2": {
|
|
2158
|
+
"type": "boolean"
|
|
2159
|
+
}
|
|
2160
|
+
},
|
|
2161
|
+
"title": "Root Type for Widget",
|
|
2162
|
+
"type": "object"
|
|
2163
|
+
}
|
|
2164
|
+
}
|
|
2165
|
+
},
|
|
2166
|
+
"info": {
|
|
2167
|
+
"description": "An example API design using OpenAPI.",
|
|
2168
|
+
"title": "Empty API",
|
|
2169
|
+
"version": "1.0.7"
|
|
2170
|
+
},
|
|
2171
|
+
"openapi": "3.0.2",
|
|
2172
|
+
"paths": {
|
|
2173
|
+
"/widgets": {
|
|
2174
|
+
"get": {
|
|
2175
|
+
"responses": {
|
|
2176
|
+
"200": {
|
|
2177
|
+
"content": {
|
|
2178
|
+
"application/json": {
|
|
2179
|
+
"schema": {
|
|
2180
|
+
"items": {
|
|
2181
|
+
"type": "string"
|
|
2182
|
+
},
|
|
2183
|
+
"type": "array"
|
|
2184
|
+
}
|
|
2185
|
+
}
|
|
2186
|
+
},
|
|
2187
|
+
"description": "All widgets"
|
|
2188
|
+
}
|
|
2189
|
+
},
|
|
2190
|
+
"summary": "Get widgets"
|
|
2191
|
+
}
|
|
2192
|
+
}
|
|
2193
|
+
}
|
|
2194
|
+
}
|
|
2195
|
+
}
|
|
2196
|
+
},
|
|
2197
|
+
"schema": {
|
|
2198
|
+
"$ref": "#/components/schemas/FileContent"
|
|
2199
|
+
}
|
|
2200
|
+
},
|
|
2201
|
+
"application/create.extended+json": {
|
|
2202
|
+
"schema": {
|
|
2203
|
+
"$ref": "#/components/schemas/ContentCreateRequest"
|
|
2204
|
+
}
|
|
2205
|
+
},
|
|
2206
|
+
"application/vnd.create.extended+json": {
|
|
2207
|
+
"schema": {
|
|
2208
|
+
"$ref": "#/components/schemas/ContentCreateRequest"
|
|
2209
|
+
}
|
|
2210
|
+
}
|
|
2211
|
+
},
|
|
2212
|
+
"description": "The content of the artifact version being created or the content and a set of references to other artifacts. This is often, but not always, JSON data\nrepresenting one of the supported artifact types:\n\n* Avro (`AVRO`)\n* Protobuf (`PROTOBUF`)\n* JSON Schema (`JSON`)\n* Kafka Connect (`KCONNECT`)\n* OpenAPI (`OPENAPI`)\n* AsyncAPI (`ASYNCAPI`)\n* GraphQL (`GRAPHQL`)\n* Web Services Description Language (`WSDL`)\n* XML Schema (`XSD`)\n",
|
|
2213
|
+
"required": true
|
|
2214
|
+
},
|
|
2215
|
+
"responses": {
|
|
2216
|
+
"200": {
|
|
2217
|
+
"content": {
|
|
2218
|
+
"application/json": {
|
|
2219
|
+
"schema": {
|
|
2220
|
+
"$ref": "#/components/schemas/VersionMetaData"
|
|
2221
|
+
}
|
|
2222
|
+
}
|
|
2223
|
+
},
|
|
2224
|
+
"description": "The artifact version was successfully created."
|
|
2225
|
+
},
|
|
2226
|
+
"404": {
|
|
2227
|
+
"$ref": "#/components/responses/NotFound"
|
|
2228
|
+
},
|
|
2229
|
+
"409": {
|
|
2230
|
+
"$ref": "#/components/responses/RuleViolationConflict"
|
|
2231
|
+
},
|
|
2232
|
+
"500": {
|
|
2233
|
+
"$ref": "#/components/responses/ServerError"
|
|
2234
|
+
}
|
|
2235
|
+
},
|
|
2236
|
+
"summary": "Create artifact version",
|
|
2237
|
+
"tags": [
|
|
2238
|
+
"Versions"
|
|
2239
|
+
]
|
|
2240
|
+
},
|
|
2241
|
+
"summary": "Manage all the versions of an artifact in the registry."
|
|
2242
|
+
},
|
|
2243
|
+
"/groups/{groupId}/artifacts/{artifactId}/versions/{version}": {
|
|
2244
|
+
"get": {
|
|
2245
|
+
"description": "Retrieves a single version of the artifact content. Both the `artifactId` and the\nunique `version` number must be provided. The `Content-Type` of the response depends \non the artifact type. In most cases, this is `application/json`, but for some types \nit may be different (for example, `PROTOBUF`).\n\nThis operation can fail for the following reasons:\n\n* No artifact with this `artifactId` exists (HTTP error `404`)\n* No version with this `version` exists (HTTP error `404`)\n* A server error occurred (HTTP error `500`)\n",
|
|
2246
|
+
"operationId": "getArtifactVersion",
|
|
2247
|
+
"parameters": [
|
|
2248
|
+
{
|
|
2249
|
+
"description": "Allows the user to specify if the content should be dereferenced when being returned",
|
|
2250
|
+
"in": "query",
|
|
2251
|
+
"name": "dereference",
|
|
2252
|
+
"schema": {
|
|
2253
|
+
"type": "boolean"
|
|
2254
|
+
}
|
|
2255
|
+
}
|
|
2256
|
+
],
|
|
2257
|
+
"responses": {
|
|
2258
|
+
"200": {
|
|
2259
|
+
"$ref": "#/components/responses/ArtifactContent"
|
|
2260
|
+
},
|
|
2261
|
+
"404": {
|
|
2262
|
+
"$ref": "#/components/responses/NotFound"
|
|
2263
|
+
},
|
|
2264
|
+
"500": {
|
|
2265
|
+
"$ref": "#/components/responses/ServerError"
|
|
2266
|
+
}
|
|
2267
|
+
},
|
|
2268
|
+
"summary": "Get artifact version",
|
|
2269
|
+
"tags": [
|
|
2270
|
+
"Versions"
|
|
2271
|
+
]
|
|
2272
|
+
},
|
|
2273
|
+
"parameters": [
|
|
2274
|
+
{
|
|
2275
|
+
"description": "The artifact group ID. Must be a string provided by the client, representing the name of the grouping of artifacts.",
|
|
2276
|
+
"in": "path",
|
|
2277
|
+
"name": "groupId",
|
|
2278
|
+
"required": true,
|
|
2279
|
+
"schema": {
|
|
2280
|
+
"$ref": "#/components/schemas/GroupId"
|
|
2281
|
+
}
|
|
2282
|
+
},
|
|
2283
|
+
{
|
|
2284
|
+
"description": "The artifact ID. Can be a string (client-provided) or UUID (server-generated), representing the unique artifact identifier.",
|
|
2285
|
+
"in": "path",
|
|
2286
|
+
"name": "artifactId",
|
|
2287
|
+
"required": true,
|
|
2288
|
+
"schema": {
|
|
2289
|
+
"$ref": "#/components/schemas/ArtifactId"
|
|
2290
|
+
}
|
|
2291
|
+
},
|
|
2292
|
+
{
|
|
2293
|
+
"description": "The unique identifier of a specific version of the artifact content.",
|
|
2294
|
+
"in": "path",
|
|
2295
|
+
"name": "version",
|
|
2296
|
+
"required": true,
|
|
2297
|
+
"schema": {
|
|
2298
|
+
"$ref": "#/components/schemas/Version"
|
|
2299
|
+
}
|
|
2300
|
+
}
|
|
2301
|
+
],
|
|
2302
|
+
"summary": "Manage a single version of a single artifact in the registry."
|
|
2303
|
+
},
|
|
2304
|
+
"/groups/{groupId}/artifacts/{artifactId}/versions/{version}/meta": {
|
|
2305
|
+
"delete": {
|
|
2306
|
+
"description": "Deletes the user-editable metadata properties of the artifact version. Any properties\nthat are not user-editable are preserved.\n\nThis operation can fail for the following reasons:\n\n* No artifact with this `artifactId` exists (HTTP error `404`)\n* No version with this `version` exists (HTTP error `404`)\n* A server error occurred (HTTP error `500`)\n",
|
|
2307
|
+
"operationId": "deleteArtifactVersionMetaData",
|
|
2308
|
+
"responses": {
|
|
2309
|
+
"204": {
|
|
2310
|
+
"description": "The artifact version's user-editable metadata was successfully deleted."
|
|
2311
|
+
},
|
|
2312
|
+
"404": {
|
|
2313
|
+
"$ref": "#/components/responses/NotFound"
|
|
2314
|
+
},
|
|
2315
|
+
"500": {
|
|
2316
|
+
"$ref": "#/components/responses/ServerError"
|
|
2317
|
+
}
|
|
2318
|
+
},
|
|
2319
|
+
"summary": "Delete artifact version metadata",
|
|
2320
|
+
"tags": [
|
|
2321
|
+
"Metadata"
|
|
2322
|
+
]
|
|
2323
|
+
},
|
|
2324
|
+
"get": {
|
|
2325
|
+
"description": "Retrieves the metadata for a single version of the artifact. The version metadata is \na subset of the artifact metadata and only includes the metadata that is specific to\nthe version (for example, this doesn't include `modifiedOn`).\n\nThis operation can fail for the following reasons:\n\n* No artifact with this `artifactId` exists (HTTP error `404`)\n* No version with this `version` exists (HTTP error `404`)\n* A server error occurred (HTTP error `500`)\n",
|
|
2326
|
+
"operationId": "getArtifactVersionMetaData",
|
|
2327
|
+
"responses": {
|
|
2328
|
+
"200": {
|
|
2329
|
+
"content": {
|
|
2330
|
+
"application/json": {
|
|
2331
|
+
"schema": {
|
|
2332
|
+
"$ref": "#/components/schemas/VersionMetaData"
|
|
2333
|
+
}
|
|
2334
|
+
}
|
|
2335
|
+
},
|
|
2336
|
+
"description": "The artifact version's metadata."
|
|
2337
|
+
},
|
|
2338
|
+
"404": {
|
|
2339
|
+
"$ref": "#/components/responses/NotFound"
|
|
2340
|
+
},
|
|
2341
|
+
"500": {
|
|
2342
|
+
"$ref": "#/components/responses/ServerError"
|
|
2343
|
+
}
|
|
2344
|
+
},
|
|
2345
|
+
"summary": "Get artifact version metadata",
|
|
2346
|
+
"tags": [
|
|
2347
|
+
"Metadata"
|
|
2348
|
+
]
|
|
2349
|
+
},
|
|
2350
|
+
"parameters": [
|
|
2351
|
+
{
|
|
2352
|
+
"description": "The artifact group ID. Must be a string provided by the client, representing the name of the grouping of artifacts.",
|
|
2353
|
+
"in": "path",
|
|
2354
|
+
"name": "groupId",
|
|
2355
|
+
"required": true,
|
|
2356
|
+
"schema": {
|
|
2357
|
+
"$ref": "#/components/schemas/GroupId"
|
|
2358
|
+
}
|
|
2359
|
+
},
|
|
2360
|
+
{
|
|
2361
|
+
"description": "The artifact ID. Can be a string (client-provided) or UUID (server-generated), representing the unique artifact identifier.",
|
|
2362
|
+
"in": "path",
|
|
2363
|
+
"name": "artifactId",
|
|
2364
|
+
"required": true,
|
|
2365
|
+
"schema": {
|
|
2366
|
+
"$ref": "#/components/schemas/ArtifactId"
|
|
2367
|
+
}
|
|
2368
|
+
},
|
|
2369
|
+
{
|
|
2370
|
+
"description": "The unique identifier of a specific version of the artifact content.",
|
|
2371
|
+
"in": "path",
|
|
2372
|
+
"name": "version",
|
|
2373
|
+
"required": true,
|
|
2374
|
+
"schema": {
|
|
2375
|
+
"$ref": "#/components/schemas/Version"
|
|
2376
|
+
}
|
|
2377
|
+
}
|
|
2378
|
+
],
|
|
2379
|
+
"put": {
|
|
2380
|
+
"description": "Updates the user-editable portion of the artifact version's metadata. Only some of \nthe metadata fields are editable by the user. For example, `description` is editable, \nbut `createdOn` is not.\n\nThis operation can fail for the following reasons:\n\n* No artifact with this `artifactId` exists (HTTP error `404`)\n* No version with this `version` exists (HTTP error `404`)\n* A server error occurred (HTTP error `500`)\n",
|
|
2381
|
+
"operationId": "updateArtifactVersionMetaData",
|
|
2382
|
+
"requestBody": {
|
|
2383
|
+
"content": {
|
|
2384
|
+
"application/json": {
|
|
2385
|
+
"schema": {
|
|
2386
|
+
"$ref": "#/components/schemas/EditableMetaData"
|
|
2387
|
+
}
|
|
2388
|
+
}
|
|
2389
|
+
},
|
|
2390
|
+
"required": true
|
|
2391
|
+
},
|
|
2392
|
+
"responses": {
|
|
2393
|
+
"204": {
|
|
2394
|
+
"description": "The artifact version's metadata was successfully updated."
|
|
2395
|
+
},
|
|
2396
|
+
"404": {
|
|
2397
|
+
"$ref": "#/components/responses/NotFound"
|
|
2398
|
+
},
|
|
2399
|
+
"500": {
|
|
2400
|
+
"$ref": "#/components/responses/ServerError"
|
|
2401
|
+
}
|
|
2402
|
+
},
|
|
2403
|
+
"summary": "Update artifact version metadata",
|
|
2404
|
+
"tags": [
|
|
2405
|
+
"Metadata"
|
|
2406
|
+
]
|
|
2407
|
+
},
|
|
2408
|
+
"summary": "Manage the metadata for a single version of an artifact in the registry."
|
|
2409
|
+
},
|
|
2410
|
+
"/groups/{groupId}/artifacts/{artifactId}/versions/{version}/references": {
|
|
2411
|
+
"get": {
|
|
2412
|
+
"description": "Retrieves a single version of the artifact content. Both the `artifactId` and the\nunique `version` number must be provided. The `Content-Type` of the response depends \non the artifact type. In most cases, this is `application/json`, but for some types \nit may be different (for example, `PROTOBUF`).\n\nThis operation can fail for the following reasons:\n\n* No artifact with this `artifactId` exists (HTTP error `404`)\n* No version with this `version` exists (HTTP error `404`)\n* A server error occurred (HTTP error `500`)\n",
|
|
2413
|
+
"operationId": "getArtifactVersionReferences",
|
|
2414
|
+
"responses": {
|
|
2415
|
+
"200": {
|
|
2416
|
+
"content": {
|
|
2417
|
+
"application/json": {
|
|
2418
|
+
"schema": {
|
|
2419
|
+
"items": {
|
|
2420
|
+
"$ref": "#/components/schemas/ArtifactReference"
|
|
2421
|
+
},
|
|
2422
|
+
"type": "array"
|
|
2423
|
+
}
|
|
2424
|
+
}
|
|
2425
|
+
},
|
|
2426
|
+
"description": "List of all the artifact references for this artifact."
|
|
2427
|
+
},
|
|
2428
|
+
"404": {
|
|
2429
|
+
"$ref": "#/components/responses/NotFound"
|
|
2430
|
+
},
|
|
2431
|
+
"500": {
|
|
2432
|
+
"$ref": "#/components/responses/ServerError"
|
|
2433
|
+
}
|
|
2434
|
+
},
|
|
2435
|
+
"summary": "Get artifact version",
|
|
2436
|
+
"tags": [
|
|
2437
|
+
"Versions"
|
|
2438
|
+
]
|
|
2439
|
+
},
|
|
2440
|
+
"parameters": [
|
|
2441
|
+
{
|
|
2442
|
+
"description": "The artifact group ID. Must be a string provided by the client, representing the name of the grouping of artifacts.",
|
|
2443
|
+
"in": "path",
|
|
2444
|
+
"name": "groupId",
|
|
2445
|
+
"required": true,
|
|
2446
|
+
"schema": {
|
|
2447
|
+
"$ref": "#/components/schemas/GroupId"
|
|
2448
|
+
}
|
|
2449
|
+
},
|
|
2450
|
+
{
|
|
2451
|
+
"description": "The artifact ID. Can be a string (client-provided) or UUID (server-generated), representing the unique artifact identifier.",
|
|
2452
|
+
"in": "path",
|
|
2453
|
+
"name": "artifactId",
|
|
2454
|
+
"required": true,
|
|
2455
|
+
"schema": {
|
|
2456
|
+
"$ref": "#/components/schemas/ArtifactId"
|
|
2457
|
+
}
|
|
2458
|
+
},
|
|
2459
|
+
{
|
|
2460
|
+
"description": "The unique identifier of a specific version of the artifact content.",
|
|
2461
|
+
"in": "path",
|
|
2462
|
+
"name": "version",
|
|
2463
|
+
"required": true,
|
|
2464
|
+
"schema": {
|
|
2465
|
+
"$ref": "#/components/schemas/Version"
|
|
2466
|
+
}
|
|
2467
|
+
}
|
|
2468
|
+
],
|
|
2469
|
+
"summary": "Manage the references for a single version of an artifact in the registry."
|
|
2470
|
+
},
|
|
2471
|
+
"/groups/{groupId}/artifacts/{artifactId}/versions/{version}/state": {
|
|
2472
|
+
"parameters": [
|
|
2473
|
+
{
|
|
2474
|
+
"description": "The artifact group ID. Must be a string provided by the client, representing the name of the grouping of artifacts.",
|
|
2475
|
+
"in": "path",
|
|
2476
|
+
"name": "groupId",
|
|
2477
|
+
"required": true,
|
|
2478
|
+
"schema": {
|
|
2479
|
+
"$ref": "#/components/schemas/GroupId"
|
|
2480
|
+
}
|
|
2481
|
+
},
|
|
2482
|
+
{
|
|
2483
|
+
"description": "The artifact ID. Can be a string (client-provided) or UUID (server-generated), representing the unique artifact identifier.",
|
|
2484
|
+
"in": "path",
|
|
2485
|
+
"name": "artifactId",
|
|
2486
|
+
"required": true,
|
|
2487
|
+
"schema": {
|
|
2488
|
+
"$ref": "#/components/schemas/ArtifactId"
|
|
2489
|
+
}
|
|
2490
|
+
},
|
|
2491
|
+
{
|
|
2492
|
+
"description": "The unique identifier of a specific version of the artifact content.",
|
|
2493
|
+
"in": "path",
|
|
2494
|
+
"name": "version",
|
|
2495
|
+
"required": true,
|
|
2496
|
+
"schema": {
|
|
2497
|
+
"$ref": "#/components/schemas/Version"
|
|
2498
|
+
}
|
|
2499
|
+
}
|
|
2500
|
+
],
|
|
2501
|
+
"put": {
|
|
2502
|
+
"description": "Updates the state of a specific version of an artifact. For example, you can use \nthis operation to disable a specific version.\n\nThis operation can fail for the following reasons:\n\n* No artifact with this `artifactId` exists (HTTP error `404`)\n* No version with this `version` exists (HTTP error `404`)\n* A server error occurred (HTTP error `500`)\n",
|
|
2503
|
+
"operationId": "updateArtifactVersionState",
|
|
2504
|
+
"requestBody": {
|
|
2505
|
+
"content": {
|
|
2506
|
+
"application/json": {
|
|
2507
|
+
"schema": {
|
|
2508
|
+
"$ref": "#/components/schemas/UpdateState"
|
|
2509
|
+
}
|
|
2510
|
+
}
|
|
2511
|
+
},
|
|
2512
|
+
"required": true
|
|
2513
|
+
},
|
|
2514
|
+
"responses": {
|
|
2515
|
+
"204": {
|
|
2516
|
+
"description": "Returned when the update was successful."
|
|
2517
|
+
},
|
|
2518
|
+
"400": {
|
|
2519
|
+
"$ref": "#/components/responses/BadRequest"
|
|
2520
|
+
},
|
|
2521
|
+
"404": {
|
|
2522
|
+
"$ref": "#/components/responses/NotFound"
|
|
2523
|
+
},
|
|
2524
|
+
"500": {
|
|
2525
|
+
"$ref": "#/components/responses/ServerError"
|
|
2526
|
+
}
|
|
2527
|
+
},
|
|
2528
|
+
"summary": "Update artifact version state",
|
|
2529
|
+
"tags": [
|
|
2530
|
+
"Versions"
|
|
2531
|
+
]
|
|
2532
|
+
},
|
|
2533
|
+
"summary": "Manage the state of a specific artifact version."
|
|
2534
|
+
},
|
|
2535
|
+
"/ids/contentHashes/{contentHash}/": {
|
|
2536
|
+
"get": {
|
|
2537
|
+
"description": "Gets the content for an artifact version in the registry using the \nSHA-256 hash of the content. This content hash may be shared by multiple artifact\nversions in the case where the artifact versions have identical content.\n\nThis operation may fail for one of the following reasons:\n\n* No content with this `contentHash` exists (HTTP error `404`)\n* A server error occurred (HTTP error `500`)\n",
|
|
2538
|
+
"operationId": "getContentByHash",
|
|
2539
|
+
"responses": {
|
|
2540
|
+
"200": {
|
|
2541
|
+
"$ref": "#/components/responses/ArtifactContent"
|
|
2542
|
+
},
|
|
2543
|
+
"404": {
|
|
2544
|
+
"$ref": "#/components/responses/NotFound"
|
|
2545
|
+
},
|
|
2546
|
+
"500": {
|
|
2547
|
+
"$ref": "#/components/responses/ServerError"
|
|
2548
|
+
}
|
|
2549
|
+
},
|
|
2550
|
+
"summary": "Get artifact content by SHA-256 hash",
|
|
2551
|
+
"tags": [
|
|
2552
|
+
"Artifacts"
|
|
2553
|
+
]
|
|
2554
|
+
},
|
|
2555
|
+
"parameters": [
|
|
2556
|
+
{
|
|
2557
|
+
"description": "SHA-256 content hash for a single artifact content.",
|
|
2558
|
+
"in": "path",
|
|
2559
|
+
"name": "contentHash",
|
|
2560
|
+
"required": true,
|
|
2561
|
+
"schema": {
|
|
2562
|
+
"type": "string"
|
|
2563
|
+
}
|
|
2564
|
+
}
|
|
2565
|
+
],
|
|
2566
|
+
"summary": "Access artifact content utilizing the SHA-256 hash of the content."
|
|
2567
|
+
},
|
|
2568
|
+
"/ids/contentHashes/{contentHash}/references": {
|
|
2569
|
+
"get": {
|
|
2570
|
+
"description": "Returns a list containing all the artifact references using the artifact content hash.\n\nThis operation may fail for one of the following reasons:\n\n* A server error occurred (HTTP error `500`)\n",
|
|
2571
|
+
"operationId": "referencesByContentHash",
|
|
2572
|
+
"responses": {
|
|
2573
|
+
"200": {
|
|
2574
|
+
"content": {
|
|
2575
|
+
"application/json": {
|
|
2576
|
+
"schema": {
|
|
2577
|
+
"items": {
|
|
2578
|
+
"$ref": "#/components/schemas/ArtifactReference"
|
|
2579
|
+
},
|
|
2580
|
+
"type": "array"
|
|
2581
|
+
}
|
|
2582
|
+
}
|
|
2583
|
+
},
|
|
2584
|
+
"description": "A list containing all the references for the artifact with the given content hash."
|
|
2585
|
+
}
|
|
2586
|
+
},
|
|
2587
|
+
"summary": "List artifact references by hash",
|
|
2588
|
+
"tags": [
|
|
2589
|
+
"Artifacts"
|
|
2590
|
+
]
|
|
2591
|
+
},
|
|
2592
|
+
"parameters": [
|
|
2593
|
+
{
|
|
2594
|
+
"description": "SHA-256 content hash for a single artifact content.",
|
|
2595
|
+
"in": "path",
|
|
2596
|
+
"name": "contentHash",
|
|
2597
|
+
"required": true,
|
|
2598
|
+
"schema": {
|
|
2599
|
+
"type": "string"
|
|
2600
|
+
}
|
|
2601
|
+
}
|
|
2602
|
+
]
|
|
2603
|
+
},
|
|
2604
|
+
"/ids/contentIds/{contentId}/": {
|
|
2605
|
+
"get": {
|
|
2606
|
+
"description": "Gets the content for an artifact version in the registry using the unique content\nidentifier for that content. This content ID may be shared by multiple artifact\nversions in the case where the artifact versions are identical.\n\nThis operation may fail for one of the following reasons:\n\n* No content with this `contentId` exists (HTTP error `404`)\n* A server error occurred (HTTP error `500`)\n",
|
|
2607
|
+
"operationId": "getContentById",
|
|
2608
|
+
"responses": {
|
|
2609
|
+
"200": {
|
|
2610
|
+
"$ref": "#/components/responses/ArtifactContent"
|
|
2611
|
+
},
|
|
2612
|
+
"404": {
|
|
2613
|
+
"$ref": "#/components/responses/NotFound"
|
|
2614
|
+
},
|
|
2615
|
+
"500": {
|
|
2616
|
+
"$ref": "#/components/responses/ServerError"
|
|
2617
|
+
}
|
|
2618
|
+
},
|
|
2619
|
+
"summary": "Get artifact content by ID",
|
|
2620
|
+
"tags": [
|
|
2621
|
+
"Artifacts"
|
|
2622
|
+
]
|
|
2623
|
+
},
|
|
2624
|
+
"parameters": [
|
|
2625
|
+
{
|
|
2626
|
+
"description": "Global identifier for a single artifact content.",
|
|
2627
|
+
"in": "path",
|
|
2628
|
+
"name": "contentId",
|
|
2629
|
+
"required": true,
|
|
2630
|
+
"schema": {
|
|
2631
|
+
"format": "int64",
|
|
2632
|
+
"type": "integer"
|
|
2633
|
+
}
|
|
2634
|
+
}
|
|
2635
|
+
],
|
|
2636
|
+
"summary": "Access artifact content utilizing the unique content identifier for that content."
|
|
2637
|
+
},
|
|
2638
|
+
"/ids/contentIds/{contentId}/references": {
|
|
2639
|
+
"get": {
|
|
2640
|
+
"description": "Returns a list containing all the artifact references using the artifact content ID.\n\nThis operation may fail for one of the following reasons:\n\n* A server error occurred (HTTP error `500`)",
|
|
2641
|
+
"operationId": "referencesByContentId",
|
|
2642
|
+
"responses": {
|
|
2643
|
+
"200": {
|
|
2644
|
+
"content": {
|
|
2645
|
+
"application/json": {
|
|
2646
|
+
"schema": {
|
|
2647
|
+
"items": {
|
|
2648
|
+
"$ref": "#/components/schemas/ArtifactReference"
|
|
2649
|
+
},
|
|
2650
|
+
"type": "array"
|
|
2651
|
+
}
|
|
2652
|
+
}
|
|
2653
|
+
},
|
|
2654
|
+
"description": "A list containing all the references for the artifact with the given content id."
|
|
2655
|
+
}
|
|
2656
|
+
},
|
|
2657
|
+
"summary": "List artifact references by content ID",
|
|
2658
|
+
"tags": [
|
|
2659
|
+
"Artifacts"
|
|
2660
|
+
]
|
|
2661
|
+
},
|
|
2662
|
+
"parameters": [
|
|
2663
|
+
{
|
|
2664
|
+
"description": "Global identifier for a single artifact content.",
|
|
2665
|
+
"in": "path",
|
|
2666
|
+
"name": "contentId",
|
|
2667
|
+
"required": true,
|
|
2668
|
+
"schema": {
|
|
2669
|
+
"format": "int64",
|
|
2670
|
+
"type": "integer"
|
|
2671
|
+
}
|
|
2672
|
+
}
|
|
2673
|
+
]
|
|
2674
|
+
},
|
|
2675
|
+
"/ids/globalIds/{globalId}": {
|
|
2676
|
+
"get": {
|
|
2677
|
+
"description": "Gets the content for an artifact version in the registry using its globally unique\nidentifier.\n\nThis operation may fail for one of the following reasons:\n\n* No artifact version with this `globalId` exists (HTTP error `404`)\n* A server error occurred (HTTP error `500`)\n",
|
|
2678
|
+
"operationId": "getContentByGlobalId",
|
|
2679
|
+
"parameters": [
|
|
2680
|
+
{
|
|
2681
|
+
"description": "Allows the user to specify if the content should be dereferenced when being returned",
|
|
2682
|
+
"in": "query",
|
|
2683
|
+
"name": "dereference",
|
|
2684
|
+
"schema": {
|
|
2685
|
+
"type": "boolean"
|
|
2686
|
+
}
|
|
2687
|
+
}
|
|
2688
|
+
],
|
|
2689
|
+
"responses": {
|
|
2690
|
+
"200": {
|
|
2691
|
+
"$ref": "#/components/responses/ArtifactContent"
|
|
2692
|
+
},
|
|
2693
|
+
"404": {
|
|
2694
|
+
"$ref": "#/components/responses/NotFound"
|
|
2695
|
+
},
|
|
2696
|
+
"500": {
|
|
2697
|
+
"$ref": "#/components/responses/ServerError"
|
|
2698
|
+
}
|
|
2699
|
+
},
|
|
2700
|
+
"summary": "Get artifact by global ID",
|
|
2701
|
+
"tags": [
|
|
2702
|
+
"Artifacts"
|
|
2703
|
+
]
|
|
2704
|
+
},
|
|
2705
|
+
"parameters": [
|
|
2706
|
+
{
|
|
2707
|
+
"description": "Global identifier for an artifact version.",
|
|
2708
|
+
"in": "path",
|
|
2709
|
+
"name": "globalId",
|
|
2710
|
+
"required": true,
|
|
2711
|
+
"schema": {
|
|
2712
|
+
"format": "int64",
|
|
2713
|
+
"type": "integer"
|
|
2714
|
+
}
|
|
2715
|
+
}
|
|
2716
|
+
],
|
|
2717
|
+
"summary": "Access artifact content utilizing an artifact version's globally unique identifier."
|
|
2718
|
+
},
|
|
2719
|
+
"/ids/globalIds/{globalId}/references": {
|
|
2720
|
+
"get": {
|
|
2721
|
+
"description": "Returns a list containing all the artifact references using the artifact global ID.\n\nThis operation may fail for one of the following reasons:\n\n* A server error occurred (HTTP error `500`)",
|
|
2722
|
+
"operationId": "referencesByGlobalId",
|
|
2723
|
+
"responses": {
|
|
2724
|
+
"200": {
|
|
2725
|
+
"content": {
|
|
2726
|
+
"application/json": {
|
|
2727
|
+
"schema": {
|
|
2728
|
+
"items": {
|
|
2729
|
+
"$ref": "#/components/schemas/ArtifactReference"
|
|
2730
|
+
},
|
|
2731
|
+
"type": "array"
|
|
2732
|
+
}
|
|
2733
|
+
}
|
|
2734
|
+
},
|
|
2735
|
+
"description": "A list containing all the references for the artifact with the given global id."
|
|
2736
|
+
}
|
|
2737
|
+
},
|
|
2738
|
+
"summary": "List artifact references by global ID",
|
|
2739
|
+
"tags": [
|
|
2740
|
+
"Artifacts"
|
|
2741
|
+
]
|
|
2742
|
+
},
|
|
2743
|
+
"parameters": [
|
|
2744
|
+
{
|
|
2745
|
+
"description": "Global identifier for an artifact version.",
|
|
2746
|
+
"in": "path",
|
|
2747
|
+
"name": "globalId",
|
|
2748
|
+
"required": true,
|
|
2749
|
+
"schema": {
|
|
2750
|
+
"format": "int64",
|
|
2751
|
+
"type": "integer"
|
|
2752
|
+
}
|
|
2753
|
+
}
|
|
2754
|
+
]
|
|
2755
|
+
},
|
|
2756
|
+
"/search/artifacts": {
|
|
2757
|
+
"get": {
|
|
2758
|
+
"description": "Returns a paginated list of all artifacts that match the provided filter criteria.\n",
|
|
2759
|
+
"operationId": "searchArtifacts",
|
|
2760
|
+
"parameters": [
|
|
2761
|
+
{
|
|
2762
|
+
"description": "Filter by artifact name.",
|
|
2763
|
+
"in": "query",
|
|
2764
|
+
"name": "name",
|
|
2765
|
+
"schema": {
|
|
2766
|
+
"type": "string"
|
|
2767
|
+
}
|
|
2768
|
+
},
|
|
2769
|
+
{
|
|
2770
|
+
"description": "The number of artifacts to skip before starting to collect the result set. Defaults to 0.",
|
|
2771
|
+
"in": "query",
|
|
2772
|
+
"name": "offset",
|
|
2773
|
+
"required": false,
|
|
2774
|
+
"schema": {
|
|
2775
|
+
"default": 0,
|
|
2776
|
+
"type": "integer"
|
|
2777
|
+
}
|
|
2778
|
+
},
|
|
2779
|
+
{
|
|
2780
|
+
"description": "The number of artifacts to return. Defaults to 20.",
|
|
2781
|
+
"in": "query",
|
|
2782
|
+
"name": "limit",
|
|
2783
|
+
"required": false,
|
|
2784
|
+
"schema": {
|
|
2785
|
+
"default": 20,
|
|
2786
|
+
"type": "integer"
|
|
2787
|
+
}
|
|
2788
|
+
},
|
|
2789
|
+
{
|
|
2790
|
+
"description": "Sort order, ascending (`asc`) or descending (`desc`).",
|
|
2791
|
+
"in": "query",
|
|
2792
|
+
"name": "order",
|
|
2793
|
+
"schema": {
|
|
2794
|
+
"$ref": "#/components/schemas/SortOrder"
|
|
2795
|
+
}
|
|
2796
|
+
},
|
|
2797
|
+
{
|
|
2798
|
+
"description": "The field to sort by. Can be one of:\n\n* `name`\n* `createdOn`\n",
|
|
2799
|
+
"in": "query",
|
|
2800
|
+
"name": "orderby",
|
|
2801
|
+
"schema": {
|
|
2802
|
+
"$ref": "#/components/schemas/SortBy"
|
|
2803
|
+
}
|
|
2804
|
+
},
|
|
2805
|
+
{
|
|
2806
|
+
"description": "Filter by label. Include one or more label to only return artifacts containing all of the\nspecified labels.",
|
|
2807
|
+
"in": "query",
|
|
2808
|
+
"name": "labels",
|
|
2809
|
+
"schema": {
|
|
2810
|
+
"items": {
|
|
2811
|
+
"type": "string"
|
|
2812
|
+
},
|
|
2813
|
+
"type": "array"
|
|
2814
|
+
}
|
|
2815
|
+
},
|
|
2816
|
+
{
|
|
2817
|
+
"description": "Filter by one or more name/value property. Separate each name/value pair using a colon. For\nexample `properties=foo:bar` will return only artifacts with a custom property named `foo`\nand value `bar`.",
|
|
2818
|
+
"in": "query",
|
|
2819
|
+
"name": "properties",
|
|
2820
|
+
"schema": {
|
|
2821
|
+
"items": {
|
|
2822
|
+
"type": "string"
|
|
2823
|
+
},
|
|
2824
|
+
"type": "array"
|
|
2825
|
+
}
|
|
2826
|
+
},
|
|
2827
|
+
{
|
|
2828
|
+
"description": "Filter by description.",
|
|
2829
|
+
"in": "query",
|
|
2830
|
+
"name": "description",
|
|
2831
|
+
"schema": {
|
|
2832
|
+
"type": "string"
|
|
2833
|
+
}
|
|
2834
|
+
},
|
|
2835
|
+
{
|
|
2836
|
+
"description": "Filter by artifact group.",
|
|
2837
|
+
"in": "query",
|
|
2838
|
+
"name": "group",
|
|
2839
|
+
"schema": {
|
|
2840
|
+
"type": "string"
|
|
2841
|
+
}
|
|
2842
|
+
},
|
|
2843
|
+
{
|
|
2844
|
+
"description": "Filter by globalId.",
|
|
2845
|
+
"in": "query",
|
|
2846
|
+
"name": "globalId",
|
|
2847
|
+
"schema": {
|
|
2848
|
+
"format": "int64",
|
|
2849
|
+
"type": "integer"
|
|
2850
|
+
}
|
|
2851
|
+
},
|
|
2852
|
+
{
|
|
2853
|
+
"description": "Filter by contentId.",
|
|
2854
|
+
"in": "query",
|
|
2855
|
+
"name": "contentId",
|
|
2856
|
+
"required": false,
|
|
2857
|
+
"schema": {
|
|
2858
|
+
"format": "int64",
|
|
2859
|
+
"type": "integer"
|
|
2860
|
+
}
|
|
2861
|
+
}
|
|
2862
|
+
],
|
|
2863
|
+
"responses": {
|
|
2864
|
+
"200": {
|
|
2865
|
+
"content": {
|
|
2866
|
+
"application/json": {
|
|
2867
|
+
"schema": {
|
|
2868
|
+
"$ref": "#/components/schemas/ArtifactSearchResults"
|
|
2869
|
+
}
|
|
2870
|
+
}
|
|
2871
|
+
},
|
|
2872
|
+
"description": "On a successful response, returns a result set of artifacts - one for each artifact\nin the registry that matches the criteria."
|
|
2873
|
+
},
|
|
2874
|
+
"500": {
|
|
2875
|
+
"$ref": "#/components/responses/ServerError"
|
|
2876
|
+
}
|
|
2877
|
+
},
|
|
2878
|
+
"summary": "Search for artifacts",
|
|
2879
|
+
"tags": [
|
|
2880
|
+
"Search",
|
|
2881
|
+
"Artifacts"
|
|
2882
|
+
]
|
|
2883
|
+
},
|
|
2884
|
+
"post": {
|
|
2885
|
+
"description": "Returns a paginated list of all artifacts with at least one version that matches the\nposted content.\n",
|
|
2886
|
+
"operationId": "searchArtifactsByContent",
|
|
2887
|
+
"parameters": [
|
|
2888
|
+
{
|
|
2889
|
+
"description": "Parameter that can be set to `true` to indicate that the server should \"canonicalize\" the content when searching for matching artifacts. Canonicalization is unique to each artifact type, but typically involves removing any extra whitespace and formatting the content in a consistent manner. Must be used along with the `artifactType` query parameter.",
|
|
2890
|
+
"in": "query",
|
|
2891
|
+
"name": "canonical",
|
|
2892
|
+
"schema": {
|
|
2893
|
+
"type": "boolean"
|
|
2894
|
+
}
|
|
2895
|
+
},
|
|
2896
|
+
{
|
|
2897
|
+
"description": "Indicates the type of artifact represented by the content being used for the search. This is only needed when using the `canonical` query parameter, so that the server knows how to canonicalize the content prior to searching for matching artifacts.",
|
|
2898
|
+
"in": "query",
|
|
2899
|
+
"name": "artifactType",
|
|
2900
|
+
"schema": {
|
|
2901
|
+
"$ref": "#/components/schemas/ArtifactType"
|
|
2902
|
+
}
|
|
2903
|
+
},
|
|
2904
|
+
{
|
|
2905
|
+
"description": "The number of artifacts to skip before starting to collect the result set. Defaults to 0.",
|
|
2906
|
+
"in": "query",
|
|
2907
|
+
"name": "offset",
|
|
2908
|
+
"required": false,
|
|
2909
|
+
"schema": {
|
|
2910
|
+
"default": 0,
|
|
2911
|
+
"type": "integer"
|
|
2912
|
+
}
|
|
2913
|
+
},
|
|
2914
|
+
{
|
|
2915
|
+
"description": "The number of artifacts to return. Defaults to 20.",
|
|
2916
|
+
"in": "query",
|
|
2917
|
+
"name": "limit",
|
|
2918
|
+
"required": false,
|
|
2919
|
+
"schema": {
|
|
2920
|
+
"default": 20,
|
|
2921
|
+
"type": "integer"
|
|
2922
|
+
}
|
|
2923
|
+
},
|
|
2924
|
+
{
|
|
2925
|
+
"description": "Sort order, ascending (`asc`) or descending (`desc`).",
|
|
2926
|
+
"in": "query",
|
|
2927
|
+
"name": "order",
|
|
2928
|
+
"schema": {
|
|
2929
|
+
"enum": [
|
|
2930
|
+
"asc",
|
|
2931
|
+
"desc"
|
|
2932
|
+
],
|
|
2933
|
+
"type": "string"
|
|
2934
|
+
}
|
|
2935
|
+
},
|
|
2936
|
+
{
|
|
2937
|
+
"description": "The field to sort by. Can be one of:\n\n* `name`\n* `createdOn`\n",
|
|
2938
|
+
"in": "query",
|
|
2939
|
+
"name": "orderby",
|
|
2940
|
+
"schema": {
|
|
2941
|
+
"enum": [
|
|
2942
|
+
"name",
|
|
2943
|
+
"createdOn"
|
|
2944
|
+
],
|
|
2945
|
+
"type": "string"
|
|
2946
|
+
}
|
|
2947
|
+
}
|
|
2948
|
+
],
|
|
2949
|
+
"requestBody": {
|
|
2950
|
+
"content": {
|
|
2951
|
+
"*/*": {
|
|
2952
|
+
"schema": {
|
|
2953
|
+
"$ref": "#/components/schemas/FileContent"
|
|
2954
|
+
}
|
|
2955
|
+
}
|
|
2956
|
+
},
|
|
2957
|
+
"description": "The content to search for.",
|
|
2958
|
+
"required": true
|
|
2959
|
+
},
|
|
2960
|
+
"responses": {
|
|
2961
|
+
"200": {
|
|
2962
|
+
"content": {
|
|
2963
|
+
"application/json": {
|
|
2964
|
+
"schema": {
|
|
2965
|
+
"$ref": "#/components/schemas/ArtifactSearchResults"
|
|
2966
|
+
}
|
|
2967
|
+
}
|
|
2968
|
+
},
|
|
2969
|
+
"description": "On a successful response, returns a result set of artifacts - one for each artifact\nin the registry that matches the criteria."
|
|
2970
|
+
},
|
|
2971
|
+
"500": {
|
|
2972
|
+
"$ref": "#/components/responses/ServerError"
|
|
2973
|
+
}
|
|
2974
|
+
},
|
|
2975
|
+
"summary": "Search for artifacts by content",
|
|
2976
|
+
"tags": [
|
|
2977
|
+
"Search",
|
|
2978
|
+
"Artifacts"
|
|
2979
|
+
]
|
|
2980
|
+
},
|
|
2981
|
+
"summary": "Search for artifacts in the registry."
|
|
2982
|
+
},
|
|
2983
|
+
"/system/info": {
|
|
2984
|
+
"get": {
|
|
2985
|
+
"description": "This operation retrieves information about the running registry system, such as the version\nof the software and when it was built.",
|
|
2986
|
+
"operationId": "getSystemInfo",
|
|
2987
|
+
"responses": {
|
|
2988
|
+
"200": {
|
|
2989
|
+
"content": {
|
|
2990
|
+
"application/json": {
|
|
2991
|
+
"schema": {
|
|
2992
|
+
"$ref": "#/components/schemas/SystemInfo"
|
|
2993
|
+
}
|
|
2994
|
+
}
|
|
2995
|
+
},
|
|
2996
|
+
"description": "On success, returns the system information."
|
|
2997
|
+
},
|
|
2998
|
+
"500": {
|
|
2999
|
+
"$ref": "#/components/responses/ServerError"
|
|
3000
|
+
}
|
|
3001
|
+
},
|
|
3002
|
+
"summary": "Get system information",
|
|
3003
|
+
"tags": [
|
|
3004
|
+
"System"
|
|
3005
|
+
]
|
|
3006
|
+
},
|
|
3007
|
+
"summary": "Retrieve system information"
|
|
3008
|
+
},
|
|
3009
|
+
"/system/limits": {
|
|
3010
|
+
"get": {
|
|
3011
|
+
"description": "This operation retrieves the list of limitations on used resources, that are applied on the current instance of Registry.",
|
|
3012
|
+
"operationId": "getResourceLimits",
|
|
3013
|
+
"responses": {
|
|
3014
|
+
"200": {
|
|
3015
|
+
"content": {
|
|
3016
|
+
"application/json": {
|
|
3017
|
+
"schema": {
|
|
3018
|
+
"$ref": "#/components/schemas/Limits"
|
|
3019
|
+
}
|
|
3020
|
+
}
|
|
3021
|
+
},
|
|
3022
|
+
"description": "On success, returns resource limits"
|
|
3023
|
+
},
|
|
3024
|
+
"500": {
|
|
3025
|
+
"$ref": "#/components/responses/ServerError"
|
|
3026
|
+
}
|
|
3027
|
+
},
|
|
3028
|
+
"summary": "Get resource limits information",
|
|
3029
|
+
"tags": [
|
|
3030
|
+
"System"
|
|
3031
|
+
]
|
|
3032
|
+
},
|
|
3033
|
+
"summary": "Retrieve resource limits information"
|
|
3034
|
+
},
|
|
3035
|
+
"/users/me": {
|
|
3036
|
+
"get": {
|
|
3037
|
+
"description": "Returns information about the currently authenticated user.",
|
|
3038
|
+
"operationId": "getCurrentUserInfo",
|
|
3039
|
+
"responses": {
|
|
3040
|
+
"200": {
|
|
3041
|
+
"content": {
|
|
3042
|
+
"application/json": {
|
|
3043
|
+
"schema": {
|
|
3044
|
+
"$ref": "#/components/schemas/UserInfo"
|
|
3045
|
+
}
|
|
3046
|
+
}
|
|
3047
|
+
},
|
|
3048
|
+
"description": "Response when the endpoint is successfully invoked."
|
|
3049
|
+
},
|
|
3050
|
+
"500": {
|
|
3051
|
+
"$ref": "#/components/responses/ServerError"
|
|
3052
|
+
}
|
|
3053
|
+
},
|
|
3054
|
+
"summary": "Get current user",
|
|
3055
|
+
"tags": [
|
|
3056
|
+
"Users"
|
|
3057
|
+
]
|
|
3058
|
+
},
|
|
3059
|
+
"summary": "Retrieves information about the current user"
|
|
3060
|
+
},
|
|
3061
|
+
"x-codegen-contextRoot": "/apis/registry/v2"
|
|
3062
|
+
},
|
|
3063
|
+
"components": {
|
|
3064
|
+
"responses": {
|
|
3065
|
+
"ArtifactContent": {
|
|
3066
|
+
"content": {
|
|
3067
|
+
"*/*": {
|
|
3068
|
+
"examples": {
|
|
3069
|
+
"OpenAPI": {
|
|
3070
|
+
"value": {
|
|
3071
|
+
"info": {
|
|
3072
|
+
"description": "An example API design using OpenAPI.",
|
|
3073
|
+
"title": "Empty API",
|
|
3074
|
+
"version": "1.0.0"
|
|
3075
|
+
},
|
|
3076
|
+
"openapi": "3.0.2"
|
|
3077
|
+
}
|
|
3078
|
+
}
|
|
3079
|
+
},
|
|
3080
|
+
"schema": {
|
|
3081
|
+
"$ref": "#/components/schemas/FileContent"
|
|
3082
|
+
}
|
|
3083
|
+
}
|
|
3084
|
+
},
|
|
3085
|
+
"description": "The content of one version of one artifact."
|
|
3086
|
+
},
|
|
3087
|
+
"BadRequest": {
|
|
3088
|
+
"content": {
|
|
3089
|
+
"application/json": {
|
|
3090
|
+
"schema": {
|
|
3091
|
+
"$ref": "#/components/schemas/Error"
|
|
3092
|
+
}
|
|
3093
|
+
}
|
|
3094
|
+
},
|
|
3095
|
+
"description": "Common response for all operations that can return a `400` error."
|
|
3096
|
+
},
|
|
3097
|
+
"Conflict": {
|
|
3098
|
+
"content": {
|
|
3099
|
+
"application/json": {
|
|
3100
|
+
"examples": {
|
|
3101
|
+
"ConflictExample": {
|
|
3102
|
+
"value": {
|
|
3103
|
+
"error_code": 409,
|
|
3104
|
+
"message": "The artifact content was invalid."
|
|
3105
|
+
}
|
|
3106
|
+
}
|
|
3107
|
+
},
|
|
3108
|
+
"schema": {
|
|
3109
|
+
"$ref": "#/components/schemas/Error"
|
|
3110
|
+
}
|
|
3111
|
+
}
|
|
3112
|
+
},
|
|
3113
|
+
"description": "Common response used when an input conflicts with existing data."
|
|
3114
|
+
},
|
|
3115
|
+
"NotFound": {
|
|
3116
|
+
"content": {
|
|
3117
|
+
"application/json": {
|
|
3118
|
+
"examples": {
|
|
3119
|
+
"NotFoundExample": {
|
|
3120
|
+
"value": {
|
|
3121
|
+
"error_code": 404,
|
|
3122
|
+
"message": "No artifact with id 'Topic-1/Inbound' could be found."
|
|
3123
|
+
}
|
|
3124
|
+
}
|
|
3125
|
+
},
|
|
3126
|
+
"schema": {
|
|
3127
|
+
"$ref": "#/components/schemas/Error"
|
|
3128
|
+
}
|
|
3129
|
+
}
|
|
3130
|
+
},
|
|
3131
|
+
"description": "Common response for all operations that can return a `404` error."
|
|
3132
|
+
},
|
|
3133
|
+
"RuleViolationConflict": {
|
|
3134
|
+
"content": {
|
|
3135
|
+
"application/json": {
|
|
3136
|
+
"examples": {
|
|
3137
|
+
"RuleViolationConflictExample": {
|
|
3138
|
+
"value": {
|
|
3139
|
+
"causes": [
|
|
3140
|
+
{
|
|
3141
|
+
"context": "/info[title]",
|
|
3142
|
+
"description": "API is missing a title"
|
|
3143
|
+
},
|
|
3144
|
+
{
|
|
3145
|
+
"context": "/paths[/invoices]/put[operationId]",
|
|
3146
|
+
"description": "Operation IDs must be unique"
|
|
3147
|
+
}
|
|
3148
|
+
],
|
|
3149
|
+
"error_code": 409,
|
|
3150
|
+
"message": "The artifact content was invalid"
|
|
3151
|
+
}
|
|
3152
|
+
}
|
|
3153
|
+
},
|
|
3154
|
+
"schema": {
|
|
3155
|
+
"$ref": "#/components/schemas/RuleViolationError"
|
|
3156
|
+
}
|
|
3157
|
+
}
|
|
3158
|
+
},
|
|
3159
|
+
"description": "Common response used when an input conflicts with existing data."
|
|
3160
|
+
},
|
|
3161
|
+
"ServerError": {
|
|
3162
|
+
"content": {
|
|
3163
|
+
"application/json": {
|
|
3164
|
+
"examples": {
|
|
3165
|
+
"ErrorExample": {
|
|
3166
|
+
"value": {
|
|
3167
|
+
"error_code": 500,
|
|
3168
|
+
"message": "Lost connection to the database."
|
|
3169
|
+
}
|
|
3170
|
+
}
|
|
3171
|
+
},
|
|
3172
|
+
"schema": {
|
|
3173
|
+
"$ref": "#/components/schemas/Error"
|
|
3174
|
+
}
|
|
3175
|
+
}
|
|
3176
|
+
},
|
|
3177
|
+
"description": "Common response for all operations that can fail with an unexpected server error."
|
|
3178
|
+
}
|
|
3179
|
+
},
|
|
3180
|
+
"schemas": {
|
|
3181
|
+
"ArtifactDescription": {
|
|
3182
|
+
"description": "Description of the artifact.",
|
|
3183
|
+
"example": "\"Artifact description\"",
|
|
3184
|
+
"type": "string",
|
|
3185
|
+
"x-codegen-inline": true
|
|
3186
|
+
},
|
|
3187
|
+
"ArtifactId": {
|
|
3188
|
+
"description": "The ID of a single artifact.",
|
|
3189
|
+
"example": "\"example-artifact\"",
|
|
3190
|
+
"type": "string"
|
|
3191
|
+
},
|
|
3192
|
+
"ArtifactMetaData": {
|
|
3193
|
+
"description": "",
|
|
3194
|
+
"example": {
|
|
3195
|
+
"contentId": 82736,
|
|
3196
|
+
"createdBy": "user1",
|
|
3197
|
+
"createdOn": "2019-03-22T12:51:19Z",
|
|
3198
|
+
"description": "Description of the artifact",
|
|
3199
|
+
"globalId": 12984719247,
|
|
3200
|
+
"groupId": "My-Group",
|
|
3201
|
+
"id": "Procurement-Invoice",
|
|
3202
|
+
"labels": [
|
|
3203
|
+
"label-1",
|
|
3204
|
+
"label-2"
|
|
3205
|
+
],
|
|
3206
|
+
"modifiedBy": "user2",
|
|
3207
|
+
"modifiedOn": "2019-07-19T15:09:00Z",
|
|
3208
|
+
"name": "Artifact Name",
|
|
3209
|
+
"properties": {
|
|
3210
|
+
"custom-1": "foo",
|
|
3211
|
+
"custom-2": "bar"
|
|
3212
|
+
},
|
|
3213
|
+
"references": [
|
|
3214
|
+
{
|
|
3215
|
+
"artifactId": "13842090-2ce3-11ec-8d3d-0242ac130003",
|
|
3216
|
+
"groupId": "mygroup",
|
|
3217
|
+
"name": "foo.bar.Open",
|
|
3218
|
+
"version": 2
|
|
3219
|
+
}
|
|
3220
|
+
],
|
|
3221
|
+
"type": "AVRO",
|
|
3222
|
+
"version": 18
|
|
3223
|
+
},
|
|
3224
|
+
"properties": {
|
|
3225
|
+
"contentId": {
|
|
3226
|
+
"description": "",
|
|
3227
|
+
"format": "int64",
|
|
3228
|
+
"type": "integer"
|
|
3229
|
+
},
|
|
3230
|
+
"createdBy": {
|
|
3231
|
+
"type": "string"
|
|
3232
|
+
},
|
|
3233
|
+
"createdOn": {
|
|
3234
|
+
"format": "date-time",
|
|
3235
|
+
"type": "string"
|
|
3236
|
+
},
|
|
3237
|
+
"description": {
|
|
3238
|
+
"type": "string"
|
|
3239
|
+
},
|
|
3240
|
+
"globalId": {
|
|
3241
|
+
"description": "",
|
|
3242
|
+
"format": "int64",
|
|
3243
|
+
"type": "integer"
|
|
3244
|
+
},
|
|
3245
|
+
"groupId": {
|
|
3246
|
+
"$ref": "#/components/schemas/GroupId",
|
|
3247
|
+
"description": ""
|
|
3248
|
+
},
|
|
3249
|
+
"id": {
|
|
3250
|
+
"$ref": "#/components/schemas/ArtifactId",
|
|
3251
|
+
"description": ""
|
|
3252
|
+
},
|
|
3253
|
+
"labels": {
|
|
3254
|
+
"description": "",
|
|
3255
|
+
"items": {
|
|
3256
|
+
"type": "string"
|
|
3257
|
+
},
|
|
3258
|
+
"type": "array"
|
|
3259
|
+
},
|
|
3260
|
+
"modifiedBy": {
|
|
3261
|
+
"type": "string"
|
|
3262
|
+
},
|
|
3263
|
+
"modifiedOn": {
|
|
3264
|
+
"format": "date-time",
|
|
3265
|
+
"type": "string"
|
|
3266
|
+
},
|
|
3267
|
+
"name": {
|
|
3268
|
+
"type": "string"
|
|
3269
|
+
},
|
|
3270
|
+
"properties": {
|
|
3271
|
+
"$ref": "#/components/schemas/Properties",
|
|
3272
|
+
"description": ""
|
|
3273
|
+
},
|
|
3274
|
+
"references": {
|
|
3275
|
+
"description": "",
|
|
3276
|
+
"items": {
|
|
3277
|
+
"$ref": "#/components/schemas/ArtifactReference"
|
|
3278
|
+
},
|
|
3279
|
+
"type": "array"
|
|
3280
|
+
},
|
|
3281
|
+
"state": {
|
|
3282
|
+
"$ref": "#/components/schemas/ArtifactState",
|
|
3283
|
+
"description": ""
|
|
3284
|
+
},
|
|
3285
|
+
"type": {
|
|
3286
|
+
"$ref": "#/components/schemas/ArtifactType",
|
|
3287
|
+
"description": ""
|
|
3288
|
+
},
|
|
3289
|
+
"version": {
|
|
3290
|
+
"description": "",
|
|
3291
|
+
"type": "string"
|
|
3292
|
+
}
|
|
3293
|
+
},
|
|
3294
|
+
"required": [
|
|
3295
|
+
"id",
|
|
3296
|
+
"createdBy",
|
|
3297
|
+
"createdOn",
|
|
3298
|
+
"modifiedBy",
|
|
3299
|
+
"modifiedOn",
|
|
3300
|
+
"version",
|
|
3301
|
+
"type",
|
|
3302
|
+
"globalId",
|
|
3303
|
+
"state",
|
|
3304
|
+
"group",
|
|
3305
|
+
"contentId"
|
|
3306
|
+
],
|
|
3307
|
+
"title": "Root Type for ArtifactMetaData",
|
|
3308
|
+
"type": "object"
|
|
3309
|
+
},
|
|
3310
|
+
"ArtifactName": {
|
|
3311
|
+
"description": "Name of the artifact.",
|
|
3312
|
+
"example": "\"Artifact name\"",
|
|
3313
|
+
"type": "string",
|
|
3314
|
+
"x-codegen-inline": true
|
|
3315
|
+
},
|
|
3316
|
+
"ArtifactOwner": {
|
|
3317
|
+
"description": "Describes the ownership of an artifact.",
|
|
3318
|
+
"example": {
|
|
3319
|
+
"owner": "bwayne"
|
|
3320
|
+
},
|
|
3321
|
+
"properties": {
|
|
3322
|
+
"owner": {
|
|
3323
|
+
"type": "string"
|
|
3324
|
+
}
|
|
3325
|
+
},
|
|
3326
|
+
"title": "Root Type for ArtifactOwner",
|
|
3327
|
+
"type": "object"
|
|
3328
|
+
},
|
|
3329
|
+
"ArtifactReference": {
|
|
3330
|
+
"description": "A reference to a different artifact. Typically used with artifact types that can have dependencies like Protobuf.",
|
|
3331
|
+
"example": {
|
|
3332
|
+
"artifactId": "13842090-2ce3-11ec-8d3d-0242ac130003",
|
|
3333
|
+
"groupId": "mygroup",
|
|
3334
|
+
"name": "foo.bar.Open",
|
|
3335
|
+
"version": "2"
|
|
3336
|
+
},
|
|
3337
|
+
"properties": {
|
|
3338
|
+
"artifactId": {
|
|
3339
|
+
"type": "string"
|
|
3340
|
+
},
|
|
3341
|
+
"groupId": {
|
|
3342
|
+
"type": "string"
|
|
3343
|
+
},
|
|
3344
|
+
"name": {
|
|
3345
|
+
"type": "string"
|
|
3346
|
+
},
|
|
3347
|
+
"version": {
|
|
3348
|
+
"type": "string"
|
|
3349
|
+
}
|
|
3350
|
+
},
|
|
3351
|
+
"required": [
|
|
3352
|
+
"artifactId",
|
|
3353
|
+
"groupId",
|
|
3354
|
+
"name"
|
|
3355
|
+
],
|
|
3356
|
+
"title": "Root Type for ArtifactReference",
|
|
3357
|
+
"type": "object"
|
|
3358
|
+
},
|
|
3359
|
+
"ArtifactSearchResults": {
|
|
3360
|
+
"description": "Describes the response received when searching for artifacts.",
|
|
3361
|
+
"properties": {
|
|
3362
|
+
"artifacts": {
|
|
3363
|
+
"description": "The artifacts returned in the result set.",
|
|
3364
|
+
"items": {
|
|
3365
|
+
"$ref": "#/components/schemas/SearchedArtifact"
|
|
3366
|
+
},
|
|
3367
|
+
"type": "array"
|
|
3368
|
+
},
|
|
3369
|
+
"count": {
|
|
3370
|
+
"description": "The total number of artifacts that matched the query that produced the result set (may be \nmore than the number of artifacts in the result set).",
|
|
3371
|
+
"type": "integer"
|
|
3372
|
+
}
|
|
3373
|
+
},
|
|
3374
|
+
"required": [
|
|
3375
|
+
"count",
|
|
3376
|
+
"artifacts"
|
|
3377
|
+
],
|
|
3378
|
+
"type": "object"
|
|
3379
|
+
},
|
|
3380
|
+
"ArtifactState": {
|
|
3381
|
+
"description": "Describes the state of an artifact or artifact version. The following states\nare possible:\n\n* ENABLED\n* DISABLED\n* DEPRECATED\n",
|
|
3382
|
+
"enum": [
|
|
3383
|
+
"ENABLED",
|
|
3384
|
+
"DISABLED",
|
|
3385
|
+
"DEPRECATED"
|
|
3386
|
+
],
|
|
3387
|
+
"type": "string",
|
|
3388
|
+
"x-codegen-package": "io.apicurio.registry.types"
|
|
3389
|
+
},
|
|
3390
|
+
"ArtifactType": {
|
|
3391
|
+
"description": "",
|
|
3392
|
+
"example": "AVRO",
|
|
3393
|
+
"type": "string",
|
|
3394
|
+
"x-codegen-package": "io.apicurio.registry.types"
|
|
3395
|
+
},
|
|
3396
|
+
"ArtifactTypeInfo": {
|
|
3397
|
+
"description": "",
|
|
3398
|
+
"example": {
|
|
3399
|
+
"name": "AVRO"
|
|
3400
|
+
},
|
|
3401
|
+
"properties": {
|
|
3402
|
+
"name": {
|
|
3403
|
+
"type": "string"
|
|
3404
|
+
}
|
|
3405
|
+
},
|
|
3406
|
+
"type": "object"
|
|
3407
|
+
},
|
|
3408
|
+
"ConfigurationProperty": {
|
|
3409
|
+
"description": "",
|
|
3410
|
+
"example": {
|
|
3411
|
+
"description": "When enabled, the registry will allow only the artifact owner (creator) to modify an artifact.",
|
|
3412
|
+
"label": "Owner Only Authorization",
|
|
3413
|
+
"name": "registry.auth.owner-only-authorization",
|
|
3414
|
+
"type": "boolean",
|
|
3415
|
+
"value": "true"
|
|
3416
|
+
},
|
|
3417
|
+
"properties": {
|
|
3418
|
+
"description": {
|
|
3419
|
+
"description": "",
|
|
3420
|
+
"type": "string"
|
|
3421
|
+
},
|
|
3422
|
+
"label": {
|
|
3423
|
+
"description": "",
|
|
3424
|
+
"type": "string"
|
|
3425
|
+
},
|
|
3426
|
+
"name": {
|
|
3427
|
+
"type": "string"
|
|
3428
|
+
},
|
|
3429
|
+
"type": {
|
|
3430
|
+
"description": "",
|
|
3431
|
+
"type": "string"
|
|
3432
|
+
},
|
|
3433
|
+
"value": {
|
|
3434
|
+
"type": "string"
|
|
3435
|
+
}
|
|
3436
|
+
},
|
|
3437
|
+
"required": [
|
|
3438
|
+
"name",
|
|
3439
|
+
"value",
|
|
3440
|
+
"type",
|
|
3441
|
+
"label",
|
|
3442
|
+
"description"
|
|
3443
|
+
],
|
|
3444
|
+
"title": "Root Type for ConfigurationProperty",
|
|
3445
|
+
"type": "object"
|
|
3446
|
+
},
|
|
3447
|
+
"ContentCreateRequest": {
|
|
3448
|
+
"description": "",
|
|
3449
|
+
"properties": {
|
|
3450
|
+
"content": {
|
|
3451
|
+
"description": "Raw content of the artifact or a valid (and accessible) URL where the content can be found.",
|
|
3452
|
+
"example": "",
|
|
3453
|
+
"type": "string"
|
|
3454
|
+
},
|
|
3455
|
+
"references": {
|
|
3456
|
+
"description": "Collection of references to other artifacts.",
|
|
3457
|
+
"items": {
|
|
3458
|
+
"$ref": "#/components/schemas/ArtifactReference"
|
|
3459
|
+
},
|
|
3460
|
+
"type": "array"
|
|
3461
|
+
}
|
|
3462
|
+
},
|
|
3463
|
+
"required": [
|
|
3464
|
+
"content",
|
|
3465
|
+
"references"
|
|
3466
|
+
],
|
|
3467
|
+
"type": "object"
|
|
3468
|
+
},
|
|
3469
|
+
"CreateGroupMetaData": {
|
|
3470
|
+
"description": "",
|
|
3471
|
+
"example": {
|
|
3472
|
+
"description": "The description of the artifact.",
|
|
3473
|
+
"id": "group-identifier",
|
|
3474
|
+
"properties": {
|
|
3475
|
+
"custom-1": "foo",
|
|
3476
|
+
"custom-2": "bar"
|
|
3477
|
+
}
|
|
3478
|
+
},
|
|
3479
|
+
"properties": {
|
|
3480
|
+
"description": {
|
|
3481
|
+
"type": "string"
|
|
3482
|
+
},
|
|
3483
|
+
"id": {
|
|
3484
|
+
"description": "",
|
|
3485
|
+
"type": "string"
|
|
3486
|
+
},
|
|
3487
|
+
"properties": {
|
|
3488
|
+
"$ref": "#/components/schemas/Properties",
|
|
3489
|
+
"description": ""
|
|
3490
|
+
}
|
|
3491
|
+
},
|
|
3492
|
+
"required": [
|
|
3493
|
+
"id"
|
|
3494
|
+
],
|
|
3495
|
+
"title": "Root Type for CreateGroupMetaData",
|
|
3496
|
+
"type": "object"
|
|
3497
|
+
},
|
|
3498
|
+
"DownloadRef": {
|
|
3499
|
+
"description": "Models a download \"link\". Useful for browser use-cases.",
|
|
3500
|
+
"example": {
|
|
3501
|
+
"downloadId": "247-4987490-297845",
|
|
3502
|
+
"href": "https://54321.registry.examples.org/apis/registry/v2/downloads/247-4987490-297845"
|
|
3503
|
+
},
|
|
3504
|
+
"properties": {
|
|
3505
|
+
"downloadId": {
|
|
3506
|
+
"type": "string"
|
|
3507
|
+
},
|
|
3508
|
+
"href": {
|
|
3509
|
+
"type": "string"
|
|
3510
|
+
}
|
|
3511
|
+
},
|
|
3512
|
+
"required": [
|
|
3513
|
+
"downloadId"
|
|
3514
|
+
],
|
|
3515
|
+
"title": "Root Type for Download",
|
|
3516
|
+
"type": "object"
|
|
3517
|
+
},
|
|
3518
|
+
"EditableMetaData": {
|
|
3519
|
+
"description": "",
|
|
3520
|
+
"example": {
|
|
3521
|
+
"description": "The description of the artifact.",
|
|
3522
|
+
"labels": [
|
|
3523
|
+
"regional",
|
|
3524
|
+
"global"
|
|
3525
|
+
],
|
|
3526
|
+
"name": "Artifact Name",
|
|
3527
|
+
"properties": {
|
|
3528
|
+
"custom-1": "foo",
|
|
3529
|
+
"custom-2": "bar"
|
|
3530
|
+
}
|
|
3531
|
+
},
|
|
3532
|
+
"properties": {
|
|
3533
|
+
"description": {
|
|
3534
|
+
"type": "string"
|
|
3535
|
+
},
|
|
3536
|
+
"labels": {
|
|
3537
|
+
"description": "",
|
|
3538
|
+
"items": {
|
|
3539
|
+
"type": "string"
|
|
3540
|
+
},
|
|
3541
|
+
"type": "array"
|
|
3542
|
+
},
|
|
3543
|
+
"name": {
|
|
3544
|
+
"type": "string"
|
|
3545
|
+
},
|
|
3546
|
+
"properties": {
|
|
3547
|
+
"$ref": "#/components/schemas/Properties",
|
|
3548
|
+
"description": ""
|
|
3549
|
+
}
|
|
3550
|
+
},
|
|
3551
|
+
"title": "Root Type for EditableArtifactMetaData",
|
|
3552
|
+
"type": "object"
|
|
3553
|
+
},
|
|
3554
|
+
"EncodedArtifactDescription": {
|
|
3555
|
+
"description": "Base64 encoded description of the artifact.",
|
|
3556
|
+
"example": "\"QXJ0aWZhY3QgZGVzY3JpcHRpb24K\"",
|
|
3557
|
+
"type": "string",
|
|
3558
|
+
"x-codegen-inline": true
|
|
3559
|
+
},
|
|
3560
|
+
"EncodedArtifactName": {
|
|
3561
|
+
"description": "Base64 encoded name of the artifact.",
|
|
3562
|
+
"example": "\"QXJ0aWZhY3QgbmFtZQo=\"",
|
|
3563
|
+
"type": "string",
|
|
3564
|
+
"x-codegen-inline": true
|
|
3565
|
+
},
|
|
3566
|
+
"Error": {
|
|
3567
|
+
"description": "All error responses, whether `4xx` or `5xx` will include one of these as the response\nbody.",
|
|
3568
|
+
"example": {
|
|
3569
|
+
"error_code": 500,
|
|
3570
|
+
"message": "An error occurred somewhere."
|
|
3571
|
+
},
|
|
3572
|
+
"properties": {
|
|
3573
|
+
"detail": {
|
|
3574
|
+
"description": "Full details about the error. This might contain a server stack trace, for example.",
|
|
3575
|
+
"type": "string"
|
|
3576
|
+
},
|
|
3577
|
+
"error_code": {
|
|
3578
|
+
"description": "The server-side error code.",
|
|
3579
|
+
"format": "int32",
|
|
3580
|
+
"type": "integer"
|
|
3581
|
+
},
|
|
3582
|
+
"message": {
|
|
3583
|
+
"description": "The short error message.",
|
|
3584
|
+
"type": "string"
|
|
3585
|
+
},
|
|
3586
|
+
"name": {
|
|
3587
|
+
"description": "The error name - typically the classname of the exception thrown by the server.",
|
|
3588
|
+
"type": "string"
|
|
3589
|
+
}
|
|
3590
|
+
},
|
|
3591
|
+
"title": "Root Type for Error",
|
|
3592
|
+
"type": "object"
|
|
3593
|
+
},
|
|
3594
|
+
"FileContent": {
|
|
3595
|
+
"format": "binary",
|
|
3596
|
+
"type": "string",
|
|
3597
|
+
"x-codegen-inline": true
|
|
3598
|
+
},
|
|
3599
|
+
"GroupId": {
|
|
3600
|
+
"description": "An ID of a single artifact group.",
|
|
3601
|
+
"example": "\"my-group\"",
|
|
3602
|
+
"type": "string"
|
|
3603
|
+
},
|
|
3604
|
+
"GroupMetaData": {
|
|
3605
|
+
"description": "",
|
|
3606
|
+
"example": {
|
|
3607
|
+
"artifactsType": "AVRO",
|
|
3608
|
+
"createdBy": "user1",
|
|
3609
|
+
"createdOn": "2019-03-22T12:51:19Z",
|
|
3610
|
+
"description": "Description of the group",
|
|
3611
|
+
"id": "group-identifier",
|
|
3612
|
+
"modifiedBy": "user2",
|
|
3613
|
+
"modifiedOn": "2019-07-19T15:09:00Z",
|
|
3614
|
+
"properties": {
|
|
3615
|
+
"custom-1": "foo",
|
|
3616
|
+
"custom-2": "bar"
|
|
3617
|
+
}
|
|
3618
|
+
},
|
|
3619
|
+
"properties": {
|
|
3620
|
+
"createdBy": {
|
|
3621
|
+
"type": "string"
|
|
3622
|
+
},
|
|
3623
|
+
"createdOn": {
|
|
3624
|
+
"format": "date-time",
|
|
3625
|
+
"type": "string"
|
|
3626
|
+
},
|
|
3627
|
+
"description": {
|
|
3628
|
+
"type": "string"
|
|
3629
|
+
},
|
|
3630
|
+
"id": {
|
|
3631
|
+
"$ref": "#/components/schemas/GroupId",
|
|
3632
|
+
"description": ""
|
|
3633
|
+
},
|
|
3634
|
+
"modifiedBy": {
|
|
3635
|
+
"type": "string"
|
|
3636
|
+
},
|
|
3637
|
+
"modifiedOn": {
|
|
3638
|
+
"format": "date-time",
|
|
3639
|
+
"type": "string"
|
|
3640
|
+
},
|
|
3641
|
+
"properties": {
|
|
3642
|
+
"$ref": "#/components/schemas/Properties",
|
|
3643
|
+
"description": ""
|
|
3644
|
+
}
|
|
3645
|
+
},
|
|
3646
|
+
"required": [
|
|
3647
|
+
"id",
|
|
3648
|
+
"description",
|
|
3649
|
+
"createdBy",
|
|
3650
|
+
"createdOn",
|
|
3651
|
+
"modifiedBy",
|
|
3652
|
+
"modifiedOn",
|
|
3653
|
+
"properties"
|
|
3654
|
+
],
|
|
3655
|
+
"title": "Root Type for GroupMetaData",
|
|
3656
|
+
"type": "object"
|
|
3657
|
+
},
|
|
3658
|
+
"GroupSearchResults": {
|
|
3659
|
+
"description": "Describes the response received when searching for groups.",
|
|
3660
|
+
"properties": {
|
|
3661
|
+
"count": {
|
|
3662
|
+
"description": "The total number of groups that matched the query that produced the result set (may be \nmore than the number of groups in the result set).",
|
|
3663
|
+
"type": "integer"
|
|
3664
|
+
},
|
|
3665
|
+
"groups": {
|
|
3666
|
+
"description": "The groups returned in the result set.",
|
|
3667
|
+
"items": {
|
|
3668
|
+
"$ref": "#/components/schemas/SearchedGroup"
|
|
3669
|
+
},
|
|
3670
|
+
"type": "array"
|
|
3671
|
+
}
|
|
3672
|
+
},
|
|
3673
|
+
"required": [
|
|
3674
|
+
"count",
|
|
3675
|
+
"groups"
|
|
3676
|
+
],
|
|
3677
|
+
"type": "object"
|
|
3678
|
+
},
|
|
3679
|
+
"IfExists": {
|
|
3680
|
+
"description": "",
|
|
3681
|
+
"enum": [
|
|
3682
|
+
"FAIL",
|
|
3683
|
+
"UPDATE",
|
|
3684
|
+
"RETURN",
|
|
3685
|
+
"RETURN_OR_UPDATE"
|
|
3686
|
+
],
|
|
3687
|
+
"type": "string"
|
|
3688
|
+
},
|
|
3689
|
+
"Limits": {
|
|
3690
|
+
"description": "List of limitations on used resources, that are applied on the current instance of Registry.\nKeys represent the resource type and are suffixed by the corresponding unit.\nValues are integers. Only non-negative values are allowed, with the exception of -1, which means that the limit is not applied.",
|
|
3691
|
+
"example": {
|
|
3692
|
+
"maxArtifactDescriptionLengthChars": -1,
|
|
3693
|
+
"maxArtifactLabelsCount": -1,
|
|
3694
|
+
"maxArtifactNameLengthChars": -1,
|
|
3695
|
+
"maxArtifactPropertiesCount": -1,
|
|
3696
|
+
"maxArtifactsCount": -1,
|
|
3697
|
+
"maxLabelSizeBytes": -1,
|
|
3698
|
+
"maxPropertyKeySizeBytes": -1,
|
|
3699
|
+
"maxPropertyValueSizeBytes": -1,
|
|
3700
|
+
"maxRequestsPerSecondCount": -1,
|
|
3701
|
+
"maxSchemaSizeBytes": -1,
|
|
3702
|
+
"maxTotalSchemasCount": -1,
|
|
3703
|
+
"maxVersionsPerArtifactCount": -1
|
|
3704
|
+
},
|
|
3705
|
+
"properties": {
|
|
3706
|
+
"maxArtifactDescriptionLengthChars": {
|
|
3707
|
+
"format": "int64",
|
|
3708
|
+
"type": "integer"
|
|
3709
|
+
},
|
|
3710
|
+
"maxArtifactLabelsCount": {
|
|
3711
|
+
"format": "int64",
|
|
3712
|
+
"type": "integer"
|
|
3713
|
+
},
|
|
3714
|
+
"maxArtifactNameLengthChars": {
|
|
3715
|
+
"format": "int64",
|
|
3716
|
+
"type": "integer"
|
|
3717
|
+
},
|
|
3718
|
+
"maxArtifactPropertiesCount": {
|
|
3719
|
+
"format": "int64",
|
|
3720
|
+
"type": "integer"
|
|
3721
|
+
},
|
|
3722
|
+
"maxArtifactsCount": {
|
|
3723
|
+
"format": "int64",
|
|
3724
|
+
"type": "integer"
|
|
3725
|
+
},
|
|
3726
|
+
"maxLabelSizeBytes": {
|
|
3727
|
+
"format": "int64",
|
|
3728
|
+
"type": "integer"
|
|
3729
|
+
},
|
|
3730
|
+
"maxPropertyKeySizeBytes": {
|
|
3731
|
+
"format": "int64",
|
|
3732
|
+
"type": "integer"
|
|
3733
|
+
},
|
|
3734
|
+
"maxPropertyValueSizeBytes": {
|
|
3735
|
+
"format": "int64",
|
|
3736
|
+
"type": "integer"
|
|
3737
|
+
},
|
|
3738
|
+
"maxRequestsPerSecondCount": {
|
|
3739
|
+
"format": "int64",
|
|
3740
|
+
"type": "integer"
|
|
3741
|
+
},
|
|
3742
|
+
"maxSchemaSizeBytes": {
|
|
3743
|
+
"format": "int64",
|
|
3744
|
+
"type": "integer"
|
|
3745
|
+
},
|
|
3746
|
+
"maxTotalSchemasCount": {
|
|
3747
|
+
"format": "int64",
|
|
3748
|
+
"type": "integer"
|
|
3749
|
+
},
|
|
3750
|
+
"maxVersionsPerArtifactCount": {
|
|
3751
|
+
"format": "int64",
|
|
3752
|
+
"type": "integer"
|
|
3753
|
+
}
|
|
3754
|
+
},
|
|
3755
|
+
"title": "Root Type for Limits",
|
|
3756
|
+
"type": "object"
|
|
3757
|
+
},
|
|
3758
|
+
"LogConfiguration": {
|
|
3759
|
+
"description": "",
|
|
3760
|
+
"properties": {
|
|
3761
|
+
"level": {
|
|
3762
|
+
"$ref": "#/components/schemas/LogLevel",
|
|
3763
|
+
"description": ""
|
|
3764
|
+
}
|
|
3765
|
+
},
|
|
3766
|
+
"required": [
|
|
3767
|
+
"level"
|
|
3768
|
+
],
|
|
3769
|
+
"type": "object"
|
|
3770
|
+
},
|
|
3771
|
+
"LogLevel": {
|
|
3772
|
+
"description": "",
|
|
3773
|
+
"enum": [
|
|
3774
|
+
"DEBUG",
|
|
3775
|
+
"TRACE",
|
|
3776
|
+
"WARN",
|
|
3777
|
+
"ERROR",
|
|
3778
|
+
"SEVERE",
|
|
3779
|
+
"WARNING",
|
|
3780
|
+
"INFO",
|
|
3781
|
+
"CONFIG",
|
|
3782
|
+
"FINE",
|
|
3783
|
+
"FINER",
|
|
3784
|
+
"FINEST"
|
|
3785
|
+
],
|
|
3786
|
+
"type": "string",
|
|
3787
|
+
"x-codegen-package": "io.apicurio.registry.types"
|
|
3788
|
+
},
|
|
3789
|
+
"NamedLogConfiguration": {
|
|
3790
|
+
"allOf": [
|
|
3791
|
+
{
|
|
3792
|
+
"properties": {
|
|
3793
|
+
"name": {
|
|
3794
|
+
"description": "",
|
|
3795
|
+
"type": "string"
|
|
3796
|
+
}
|
|
3797
|
+
},
|
|
3798
|
+
"required": [
|
|
3799
|
+
"name"
|
|
3800
|
+
],
|
|
3801
|
+
"type": "object"
|
|
3802
|
+
},
|
|
3803
|
+
{
|
|
3804
|
+
"$ref": "#/components/schemas/LogConfiguration"
|
|
3805
|
+
}
|
|
3806
|
+
],
|
|
3807
|
+
"description": "",
|
|
3808
|
+
"type": "object"
|
|
3809
|
+
},
|
|
3810
|
+
"Properties": {
|
|
3811
|
+
"additionalProperties": {
|
|
3812
|
+
"type": "string"
|
|
3813
|
+
},
|
|
3814
|
+
"description": "User-defined name-value pairs. Name and value must be strings.",
|
|
3815
|
+
"type": "object",
|
|
3816
|
+
"x-codegen-inline": true,
|
|
3817
|
+
"x-codegen-type": "StringMap"
|
|
3818
|
+
},
|
|
3819
|
+
"RoleMapping": {
|
|
3820
|
+
"description": "The mapping between a user/principal and their role.",
|
|
3821
|
+
"example": {
|
|
3822
|
+
"principalId": "svc_account_84874587_123484",
|
|
3823
|
+
"principalName": "famartin-svc-account",
|
|
3824
|
+
"role": "READ_ONLY"
|
|
3825
|
+
},
|
|
3826
|
+
"properties": {
|
|
3827
|
+
"principalId": {
|
|
3828
|
+
"description": "",
|
|
3829
|
+
"type": "string"
|
|
3830
|
+
},
|
|
3831
|
+
"principalName": {
|
|
3832
|
+
"description": "A friendly name for the principal.",
|
|
3833
|
+
"type": "string"
|
|
3834
|
+
},
|
|
3835
|
+
"role": {
|
|
3836
|
+
"$ref": "#/components/schemas/RoleType",
|
|
3837
|
+
"description": ""
|
|
3838
|
+
}
|
|
3839
|
+
},
|
|
3840
|
+
"required": [
|
|
3841
|
+
"principalId",
|
|
3842
|
+
"role"
|
|
3843
|
+
],
|
|
3844
|
+
"type": "object"
|
|
3845
|
+
},
|
|
3846
|
+
"RoleType": {
|
|
3847
|
+
"description": "",
|
|
3848
|
+
"enum": [
|
|
3849
|
+
"READ_ONLY",
|
|
3850
|
+
"DEVELOPER",
|
|
3851
|
+
"ADMIN"
|
|
3852
|
+
],
|
|
3853
|
+
"type": "string",
|
|
3854
|
+
"x-codegen-package": "io.apicurio.registry.types"
|
|
3855
|
+
},
|
|
3856
|
+
"Rule": {
|
|
3857
|
+
"description": "",
|
|
3858
|
+
"example": {
|
|
3859
|
+
"config": "FULL",
|
|
3860
|
+
"type": "VALIDITY"
|
|
3861
|
+
},
|
|
3862
|
+
"properties": {
|
|
3863
|
+
"config": {
|
|
3864
|
+
"type": "string"
|
|
3865
|
+
},
|
|
3866
|
+
"type": {
|
|
3867
|
+
"$ref": "#/components/schemas/RuleType"
|
|
3868
|
+
}
|
|
3869
|
+
},
|
|
3870
|
+
"required": [
|
|
3871
|
+
"config"
|
|
3872
|
+
],
|
|
3873
|
+
"title": "Root Type for Rule",
|
|
3874
|
+
"type": "object"
|
|
3875
|
+
},
|
|
3876
|
+
"RuleType": {
|
|
3877
|
+
"description": "",
|
|
3878
|
+
"enum": [
|
|
3879
|
+
"VALIDITY",
|
|
3880
|
+
"COMPATIBILITY"
|
|
3881
|
+
],
|
|
3882
|
+
"example": "VALIDITY",
|
|
3883
|
+
"type": "string",
|
|
3884
|
+
"x-codegen-package": "io.apicurio.registry.types"
|
|
3885
|
+
},
|
|
3886
|
+
"RuleViolationCause": {
|
|
3887
|
+
"description": "",
|
|
3888
|
+
"example": {
|
|
3889
|
+
"context": "/info/externalDocs[url]",
|
|
3890
|
+
"description": "External documentation URL is not valid (it must be formatted as a URL)."
|
|
3891
|
+
},
|
|
3892
|
+
"properties": {
|
|
3893
|
+
"context": {
|
|
3894
|
+
"type": "string"
|
|
3895
|
+
},
|
|
3896
|
+
"description": {
|
|
3897
|
+
"type": "string"
|
|
3898
|
+
}
|
|
3899
|
+
},
|
|
3900
|
+
"title": "Root Type for RuleViolationCause",
|
|
3901
|
+
"type": "object"
|
|
3902
|
+
},
|
|
3903
|
+
"RuleViolationError": {
|
|
3904
|
+
"allOf": [
|
|
3905
|
+
{
|
|
3906
|
+
"properties": {
|
|
3907
|
+
"causes": {
|
|
3908
|
+
"description": "List of rule violation causes.",
|
|
3909
|
+
"items": {
|
|
3910
|
+
"$ref": "#/components/schemas/RuleViolationCause"
|
|
3911
|
+
},
|
|
3912
|
+
"type": "array"
|
|
3913
|
+
}
|
|
3914
|
+
},
|
|
3915
|
+
"required": [
|
|
3916
|
+
"causes"
|
|
3917
|
+
],
|
|
3918
|
+
"type": "object"
|
|
3919
|
+
},
|
|
3920
|
+
{
|
|
3921
|
+
"$ref": "#/components/schemas/Error"
|
|
3922
|
+
}
|
|
3923
|
+
],
|
|
3924
|
+
"description": "All error responses, whether `4xx` or `5xx` will include one of these as the response\nbody.",
|
|
3925
|
+
"example": {
|
|
3926
|
+
"causes": [
|
|
3927
|
+
{
|
|
3928
|
+
"context": "/info[title]",
|
|
3929
|
+
"description": "API is missing a title"
|
|
3930
|
+
},
|
|
3931
|
+
{
|
|
3932
|
+
"context": "/paths[/invoices]/put[operationId]",
|
|
3933
|
+
"description": "Operation IDs must be unique"
|
|
3934
|
+
}
|
|
3935
|
+
],
|
|
3936
|
+
"error_code": 409,
|
|
3937
|
+
"message": "Artifact failed validation"
|
|
3938
|
+
},
|
|
3939
|
+
"title": "Root Type for Error",
|
|
3940
|
+
"type": "object",
|
|
3941
|
+
"x-codegen-extendsClass": "io.apicurio.registry.rest.v2.beans.Error"
|
|
3942
|
+
},
|
|
3943
|
+
"SearchedArtifact": {
|
|
3944
|
+
"description": "Models a single artifact from the result set returned when searching for artifacts.",
|
|
3945
|
+
"example": {
|
|
3946
|
+
"createdBy": "user1",
|
|
3947
|
+
"createdOn": "2019-03-22T12:51:19Z",
|
|
3948
|
+
"description": "Description of the artifact",
|
|
3949
|
+
"groupId": "My-Group",
|
|
3950
|
+
"id": "Procurement-Invoice",
|
|
3951
|
+
"labels": [
|
|
3952
|
+
"current",
|
|
3953
|
+
"internal"
|
|
3954
|
+
],
|
|
3955
|
+
"name": "Artifact Name",
|
|
3956
|
+
"state": "ENABLED",
|
|
3957
|
+
"type": "AVRO"
|
|
3958
|
+
},
|
|
3959
|
+
"properties": {
|
|
3960
|
+
"createdBy": {
|
|
3961
|
+
"description": "",
|
|
3962
|
+
"type": "string"
|
|
3963
|
+
},
|
|
3964
|
+
"createdOn": {
|
|
3965
|
+
"description": "",
|
|
3966
|
+
"format": "date-time",
|
|
3967
|
+
"type": "string"
|
|
3968
|
+
},
|
|
3969
|
+
"description": {
|
|
3970
|
+
"description": "",
|
|
3971
|
+
"type": "string"
|
|
3972
|
+
},
|
|
3973
|
+
"groupId": {
|
|
3974
|
+
"$ref": "#/components/schemas/GroupId",
|
|
3975
|
+
"description": ""
|
|
3976
|
+
},
|
|
3977
|
+
"id": {
|
|
3978
|
+
"$ref": "#/components/schemas/ArtifactId",
|
|
3979
|
+
"description": ""
|
|
3980
|
+
},
|
|
3981
|
+
"labels": {
|
|
3982
|
+
"description": "",
|
|
3983
|
+
"items": {
|
|
3984
|
+
"type": "string"
|
|
3985
|
+
},
|
|
3986
|
+
"type": "array"
|
|
3987
|
+
},
|
|
3988
|
+
"modifiedBy": {
|
|
3989
|
+
"description": "",
|
|
3990
|
+
"type": "string"
|
|
3991
|
+
},
|
|
3992
|
+
"modifiedOn": {
|
|
3993
|
+
"description": "",
|
|
3994
|
+
"format": "date-time",
|
|
3995
|
+
"type": "string"
|
|
3996
|
+
},
|
|
3997
|
+
"name": {
|
|
3998
|
+
"description": "",
|
|
3999
|
+
"type": "string"
|
|
4000
|
+
},
|
|
4001
|
+
"state": {
|
|
4002
|
+
"$ref": "#/components/schemas/ArtifactState",
|
|
4003
|
+
"description": ""
|
|
4004
|
+
},
|
|
4005
|
+
"type": {
|
|
4006
|
+
"$ref": "#/components/schemas/ArtifactType",
|
|
4007
|
+
"description": ""
|
|
4008
|
+
}
|
|
4009
|
+
},
|
|
4010
|
+
"required": [
|
|
4011
|
+
"createdBy",
|
|
4012
|
+
"createdOn",
|
|
4013
|
+
"id",
|
|
4014
|
+
"type",
|
|
4015
|
+
"state",
|
|
4016
|
+
"group"
|
|
4017
|
+
],
|
|
4018
|
+
"type": "object"
|
|
4019
|
+
},
|
|
4020
|
+
"SearchedGroup": {
|
|
4021
|
+
"description": "Models a single group from the result set returned when searching for groups.",
|
|
4022
|
+
"example": {
|
|
4023
|
+
"createdBy": "user1",
|
|
4024
|
+
"createdOn": "2019-03-22T12:51:19Z",
|
|
4025
|
+
"description": "Description of the group",
|
|
4026
|
+
"id": "My-Group",
|
|
4027
|
+
"modifiedBy": "user1",
|
|
4028
|
+
"modifiedOn": "2019-03-22T12:51:19Z",
|
|
4029
|
+
"name": "Group Name"
|
|
4030
|
+
},
|
|
4031
|
+
"properties": {
|
|
4032
|
+
"createdBy": {
|
|
4033
|
+
"description": "",
|
|
4034
|
+
"type": "string"
|
|
4035
|
+
},
|
|
4036
|
+
"createdOn": {
|
|
4037
|
+
"description": "",
|
|
4038
|
+
"format": "date-time",
|
|
4039
|
+
"type": "string"
|
|
4040
|
+
},
|
|
4041
|
+
"description": {
|
|
4042
|
+
"description": "",
|
|
4043
|
+
"type": "string"
|
|
4044
|
+
},
|
|
4045
|
+
"id": {
|
|
4046
|
+
"$ref": "#/components/schemas/GroupId",
|
|
4047
|
+
"description": ""
|
|
4048
|
+
},
|
|
4049
|
+
"modifiedBy": {
|
|
4050
|
+
"description": "",
|
|
4051
|
+
"type": "string"
|
|
4052
|
+
},
|
|
4053
|
+
"modifiedOn": {
|
|
4054
|
+
"description": "",
|
|
4055
|
+
"format": "date-time",
|
|
4056
|
+
"type": "string"
|
|
4057
|
+
}
|
|
4058
|
+
},
|
|
4059
|
+
"required": [
|
|
4060
|
+
"description",
|
|
4061
|
+
"createdBy",
|
|
4062
|
+
"createdOn",
|
|
4063
|
+
"id",
|
|
4064
|
+
"modifiedBy",
|
|
4065
|
+
"modifiedOn"
|
|
4066
|
+
],
|
|
4067
|
+
"type": "object"
|
|
4068
|
+
},
|
|
4069
|
+
"SearchedVersion": {
|
|
4070
|
+
"description": "Models a single artifact from the result set returned when searching for artifacts.",
|
|
4071
|
+
"example": {
|
|
4072
|
+
"contentId": 62,
|
|
4073
|
+
"createdBy": "some text",
|
|
4074
|
+
"createdOn": "2018-02-10T09:30Z",
|
|
4075
|
+
"description": "Description of the artifact version",
|
|
4076
|
+
"globalId": 37,
|
|
4077
|
+
"labels": [
|
|
4078
|
+
"current",
|
|
4079
|
+
"internal"
|
|
4080
|
+
],
|
|
4081
|
+
"name": "Artifact Version Name",
|
|
4082
|
+
"properties": {},
|
|
4083
|
+
"references": {},
|
|
4084
|
+
"state": "ENABLED",
|
|
4085
|
+
"type": "AVRO",
|
|
4086
|
+
"version": 85
|
|
4087
|
+
},
|
|
4088
|
+
"properties": {
|
|
4089
|
+
"contentId": {
|
|
4090
|
+
"description": "",
|
|
4091
|
+
"format": "int64",
|
|
4092
|
+
"type": "integer"
|
|
4093
|
+
},
|
|
4094
|
+
"createdBy": {
|
|
4095
|
+
"description": "",
|
|
4096
|
+
"type": "string"
|
|
4097
|
+
},
|
|
4098
|
+
"createdOn": {
|
|
4099
|
+
"description": "",
|
|
4100
|
+
"format": "date-time",
|
|
4101
|
+
"type": "string"
|
|
4102
|
+
},
|
|
4103
|
+
"description": {
|
|
4104
|
+
"description": "",
|
|
4105
|
+
"type": "string"
|
|
4106
|
+
},
|
|
4107
|
+
"globalId": {
|
|
4108
|
+
"description": "",
|
|
4109
|
+
"format": "int64",
|
|
4110
|
+
"type": "integer"
|
|
4111
|
+
},
|
|
4112
|
+
"labels": {
|
|
4113
|
+
"description": "",
|
|
4114
|
+
"items": {
|
|
4115
|
+
"type": "string"
|
|
4116
|
+
},
|
|
4117
|
+
"type": "array"
|
|
4118
|
+
},
|
|
4119
|
+
"name": {
|
|
4120
|
+
"description": "",
|
|
4121
|
+
"type": "string"
|
|
4122
|
+
},
|
|
4123
|
+
"properties": {
|
|
4124
|
+
"$ref": "#/components/schemas/Properties",
|
|
4125
|
+
"description": ""
|
|
4126
|
+
},
|
|
4127
|
+
"references": {
|
|
4128
|
+
"description": "",
|
|
4129
|
+
"items": {
|
|
4130
|
+
"$ref": "#/components/schemas/ArtifactReference"
|
|
4131
|
+
},
|
|
4132
|
+
"type": "array"
|
|
4133
|
+
},
|
|
4134
|
+
"state": {
|
|
4135
|
+
"$ref": "#/components/schemas/ArtifactState",
|
|
4136
|
+
"description": ""
|
|
4137
|
+
},
|
|
4138
|
+
"type": {
|
|
4139
|
+
"$ref": "#/components/schemas/ArtifactType",
|
|
4140
|
+
"description": ""
|
|
4141
|
+
},
|
|
4142
|
+
"version": {
|
|
4143
|
+
"description": "",
|
|
4144
|
+
"type": "string"
|
|
4145
|
+
}
|
|
4146
|
+
},
|
|
4147
|
+
"required": [
|
|
4148
|
+
"createdBy",
|
|
4149
|
+
"createdOn",
|
|
4150
|
+
"type",
|
|
4151
|
+
"state",
|
|
4152
|
+
"globalId",
|
|
4153
|
+
"version",
|
|
4154
|
+
"contentId",
|
|
4155
|
+
"references"
|
|
4156
|
+
],
|
|
4157
|
+
"type": "object"
|
|
4158
|
+
},
|
|
4159
|
+
"SortBy": {
|
|
4160
|
+
"description": "",
|
|
4161
|
+
"enum": [
|
|
4162
|
+
"name",
|
|
4163
|
+
"createdOn"
|
|
4164
|
+
],
|
|
4165
|
+
"type": "string"
|
|
4166
|
+
},
|
|
4167
|
+
"SortOrder": {
|
|
4168
|
+
"description": "",
|
|
4169
|
+
"enum": [
|
|
4170
|
+
"asc",
|
|
4171
|
+
"desc"
|
|
4172
|
+
],
|
|
4173
|
+
"type": "string"
|
|
4174
|
+
},
|
|
4175
|
+
"SystemInfo": {
|
|
4176
|
+
"description": "",
|
|
4177
|
+
"example": {
|
|
4178
|
+
"builtOn": "2021-03-19T12:55:00Z",
|
|
4179
|
+
"description": "The Apicurio Registry application.",
|
|
4180
|
+
"name": "Apicurio Registry (SQL)",
|
|
4181
|
+
"version": "2.0.0.Final"
|
|
4182
|
+
},
|
|
4183
|
+
"properties": {
|
|
4184
|
+
"builtOn": {
|
|
4185
|
+
"format": "date-time",
|
|
4186
|
+
"type": "string"
|
|
4187
|
+
},
|
|
4188
|
+
"description": {
|
|
4189
|
+
"type": "string"
|
|
4190
|
+
},
|
|
4191
|
+
"name": {
|
|
4192
|
+
"type": "string"
|
|
4193
|
+
},
|
|
4194
|
+
"version": {
|
|
4195
|
+
"type": "string"
|
|
4196
|
+
}
|
|
4197
|
+
},
|
|
4198
|
+
"title": "Root Type for SystemInfo",
|
|
4199
|
+
"type": "object"
|
|
4200
|
+
},
|
|
4201
|
+
"UpdateConfigurationProperty": {
|
|
4202
|
+
"description": "",
|
|
4203
|
+
"example": {
|
|
4204
|
+
"value": "true"
|
|
4205
|
+
},
|
|
4206
|
+
"properties": {
|
|
4207
|
+
"value": {
|
|
4208
|
+
"type": "string"
|
|
4209
|
+
}
|
|
4210
|
+
},
|
|
4211
|
+
"required": [
|
|
4212
|
+
"value"
|
|
4213
|
+
],
|
|
4214
|
+
"title": "Root Type for UpdateConfigurationProperty",
|
|
4215
|
+
"type": "object"
|
|
4216
|
+
},
|
|
4217
|
+
"UpdateRole": {
|
|
4218
|
+
"description": "",
|
|
4219
|
+
"example": {
|
|
4220
|
+
"role": "READ_ONLY"
|
|
4221
|
+
},
|
|
4222
|
+
"properties": {
|
|
4223
|
+
"role": {
|
|
4224
|
+
"$ref": "#/components/schemas/RoleType"
|
|
4225
|
+
}
|
|
4226
|
+
},
|
|
4227
|
+
"required": [
|
|
4228
|
+
"role"
|
|
4229
|
+
],
|
|
4230
|
+
"title": "Root Type for UpdateRole",
|
|
4231
|
+
"type": "object"
|
|
4232
|
+
},
|
|
4233
|
+
"UpdateState": {
|
|
4234
|
+
"description": "",
|
|
4235
|
+
"example": {
|
|
4236
|
+
"state": "DISABLED"
|
|
4237
|
+
},
|
|
4238
|
+
"properties": {
|
|
4239
|
+
"state": {
|
|
4240
|
+
"$ref": "#/components/schemas/ArtifactState"
|
|
4241
|
+
}
|
|
4242
|
+
},
|
|
4243
|
+
"required": [
|
|
4244
|
+
"state"
|
|
4245
|
+
],
|
|
4246
|
+
"title": "Root Type for UpdateState",
|
|
4247
|
+
"type": "object"
|
|
4248
|
+
},
|
|
4249
|
+
"UserInfo": {
|
|
4250
|
+
"description": "Information about a single user.",
|
|
4251
|
+
"example": {
|
|
4252
|
+
"admin": true,
|
|
4253
|
+
"developer": false,
|
|
4254
|
+
"displayName": "Diana Prince",
|
|
4255
|
+
"username": "dprince",
|
|
4256
|
+
"viewer": false
|
|
4257
|
+
},
|
|
4258
|
+
"properties": {
|
|
4259
|
+
"admin": {
|
|
4260
|
+
"type": "boolean"
|
|
4261
|
+
},
|
|
4262
|
+
"developer": {
|
|
4263
|
+
"type": "boolean"
|
|
4264
|
+
},
|
|
4265
|
+
"displayName": {
|
|
4266
|
+
"type": "string"
|
|
4267
|
+
},
|
|
4268
|
+
"username": {
|
|
4269
|
+
"type": "string"
|
|
4270
|
+
},
|
|
4271
|
+
"viewer": {
|
|
4272
|
+
"type": "boolean"
|
|
4273
|
+
}
|
|
4274
|
+
},
|
|
4275
|
+
"title": "Root Type for UserInfo",
|
|
4276
|
+
"type": "object"
|
|
4277
|
+
},
|
|
4278
|
+
"Version": {
|
|
4279
|
+
"description": "A single version of an artifact. Can be provided by the client when creating a new version,\nor it can be server-generated. The value can be any string unique to the artifact, but it is\nrecommended to use a simple integer or a semver value.",
|
|
4280
|
+
"example": "\"3.1.6\"",
|
|
4281
|
+
"type": "string"
|
|
4282
|
+
},
|
|
4283
|
+
"VersionMetaData": {
|
|
4284
|
+
"description": "",
|
|
4285
|
+
"example": {
|
|
4286
|
+
"contentId": 12347,
|
|
4287
|
+
"createdBy": "user1",
|
|
4288
|
+
"createdOn": "2019-05-17T12:00:00Z",
|
|
4289
|
+
"description": "The description of the artifact",
|
|
4290
|
+
"globalId": 183282932983,
|
|
4291
|
+
"groupId": "My-Group",
|
|
4292
|
+
"id": "my-artifact-id",
|
|
4293
|
+
"labels": [
|
|
4294
|
+
"label-1",
|
|
4295
|
+
"label-2"
|
|
4296
|
+
],
|
|
4297
|
+
"name": "Artifact Name",
|
|
4298
|
+
"properties": {
|
|
4299
|
+
"custom-1": "foo",
|
|
4300
|
+
"custom-2": "bar"
|
|
4301
|
+
},
|
|
4302
|
+
"references": [
|
|
4303
|
+
{
|
|
4304
|
+
"artifactId": "13842090-2ce3-11ec-8d3d-0242ac130003",
|
|
4305
|
+
"groupId": "mygroup",
|
|
4306
|
+
"name": "foo.bar.Open",
|
|
4307
|
+
"version": 2
|
|
4308
|
+
}
|
|
4309
|
+
],
|
|
4310
|
+
"type": "PROTOBUF",
|
|
4311
|
+
"version": 1221432
|
|
4312
|
+
},
|
|
4313
|
+
"properties": {
|
|
4314
|
+
"contentId": {
|
|
4315
|
+
"description": "",
|
|
4316
|
+
"format": "int64",
|
|
4317
|
+
"type": "integer"
|
|
4318
|
+
},
|
|
4319
|
+
"createdBy": {
|
|
4320
|
+
"type": "string"
|
|
4321
|
+
},
|
|
4322
|
+
"createdOn": {
|
|
4323
|
+
"format": "date-time",
|
|
4324
|
+
"type": "string"
|
|
4325
|
+
},
|
|
4326
|
+
"description": {
|
|
4327
|
+
"type": "string"
|
|
4328
|
+
},
|
|
4329
|
+
"globalId": {
|
|
4330
|
+
"description": "",
|
|
4331
|
+
"format": "int64",
|
|
4332
|
+
"type": "integer"
|
|
4333
|
+
},
|
|
4334
|
+
"groupId": {
|
|
4335
|
+
"$ref": "#/components/schemas/GroupId",
|
|
4336
|
+
"description": ""
|
|
4337
|
+
},
|
|
4338
|
+
"id": {
|
|
4339
|
+
"$ref": "#/components/schemas/ArtifactId",
|
|
4340
|
+
"description": ""
|
|
4341
|
+
},
|
|
4342
|
+
"labels": {
|
|
4343
|
+
"description": "",
|
|
4344
|
+
"items": {
|
|
4345
|
+
"type": "string"
|
|
4346
|
+
},
|
|
4347
|
+
"type": "array"
|
|
4348
|
+
},
|
|
4349
|
+
"name": {
|
|
4350
|
+
"type": "string"
|
|
4351
|
+
},
|
|
4352
|
+
"properties": {
|
|
4353
|
+
"$ref": "#/components/schemas/Properties",
|
|
4354
|
+
"description": ""
|
|
4355
|
+
},
|
|
4356
|
+
"state": {
|
|
4357
|
+
"$ref": "#/components/schemas/ArtifactState",
|
|
4358
|
+
"description": ""
|
|
4359
|
+
},
|
|
4360
|
+
"type": {
|
|
4361
|
+
"$ref": "#/components/schemas/ArtifactType",
|
|
4362
|
+
"description": ""
|
|
4363
|
+
},
|
|
4364
|
+
"version": {
|
|
4365
|
+
"type": "string"
|
|
4366
|
+
}
|
|
4367
|
+
},
|
|
4368
|
+
"required": [
|
|
4369
|
+
"createdOn",
|
|
4370
|
+
"createdBy",
|
|
4371
|
+
"version",
|
|
4372
|
+
"type",
|
|
4373
|
+
"globalId",
|
|
4374
|
+
"id",
|
|
4375
|
+
"contentId"
|
|
4376
|
+
],
|
|
4377
|
+
"title": "Root Type for ArtifactVersionMetaData",
|
|
4378
|
+
"type": "object"
|
|
4379
|
+
},
|
|
4380
|
+
"VersionSearchResults": {
|
|
4381
|
+
"description": "Describes the response received when searching for artifacts.",
|
|
4382
|
+
"properties": {
|
|
4383
|
+
"count": {
|
|
4384
|
+
"description": "The total number of versions that matched the query (may be more than the number of versions\nreturned in the result set).",
|
|
4385
|
+
"type": "integer"
|
|
4386
|
+
},
|
|
4387
|
+
"versions": {
|
|
4388
|
+
"description": "The collection of artifact versions returned in the result set.",
|
|
4389
|
+
"items": {
|
|
4390
|
+
"$ref": "#/components/schemas/SearchedVersion"
|
|
4391
|
+
},
|
|
4392
|
+
"type": "array"
|
|
4393
|
+
}
|
|
4394
|
+
},
|
|
4395
|
+
"required": [
|
|
4396
|
+
"count",
|
|
4397
|
+
"versions"
|
|
4398
|
+
],
|
|
4399
|
+
"type": "object"
|
|
4400
|
+
}
|
|
4401
|
+
}
|
|
4402
|
+
},
|
|
4403
|
+
"x-codegen": {
|
|
4404
|
+
"bean-annotations": [
|
|
4405
|
+
"io.quarkus.runtime.annotations.RegisterForReflection",
|
|
4406
|
+
{
|
|
4407
|
+
"annotation": "lombok.experimental.SuperBuilder",
|
|
4408
|
+
"excludeEnums": true
|
|
4409
|
+
},
|
|
4410
|
+
{
|
|
4411
|
+
"annotation": "lombok.AllArgsConstructor",
|
|
4412
|
+
"excludeEnums": true
|
|
4413
|
+
},
|
|
4414
|
+
{
|
|
4415
|
+
"annotation": "lombok.NoArgsConstructor",
|
|
4416
|
+
"excludeEnums": true
|
|
4417
|
+
},
|
|
4418
|
+
{
|
|
4419
|
+
"annotation": "lombok.EqualsAndHashCode",
|
|
4420
|
+
"excludeEnums": true
|
|
4421
|
+
},
|
|
4422
|
+
{
|
|
4423
|
+
"annotation": "lombok.ToString(callSuper = true)",
|
|
4424
|
+
"excludeEnums": true
|
|
4425
|
+
}
|
|
4426
|
+
]
|
|
4427
|
+
}
|
|
4428
|
+
};
|
|
4429
|
+
function generateTools() {
|
|
4430
|
+
const tools = [];
|
|
4431
|
+
const paths = API_SPEC.paths || {};
|
|
4432
|
+
for (const [path, pathItem] of Object.entries(paths)) {
|
|
4433
|
+
for (const [method, operation] of Object.entries(pathItem)) {
|
|
4434
|
+
if (!["get", "post", "put", "patch", "delete"].includes(method))
|
|
4435
|
+
continue;
|
|
4436
|
+
const op = operation;
|
|
4437
|
+
const operationId = op.operationId || `${method}_${path.replace(/\W/g, "_")}`;
|
|
4438
|
+
const summary = op.summary || op.description || `${method.toUpperCase()} ${path}`;
|
|
4439
|
+
const properties = {};
|
|
4440
|
+
const required = [];
|
|
4441
|
+
// Path parameters
|
|
4442
|
+
if (op.parameters) {
|
|
4443
|
+
for (const param of op.parameters) {
|
|
4444
|
+
if (param.in === "path" || param.in === "query") {
|
|
4445
|
+
properties[param.name] = {
|
|
4446
|
+
type: param.schema?.type || "string",
|
|
4447
|
+
description: param.description,
|
|
4448
|
+
...(param.schema?.enum && { enum: param.schema.enum }),
|
|
4449
|
+
};
|
|
4450
|
+
if (param.required)
|
|
4451
|
+
required.push(param.name);
|
|
4452
|
+
}
|
|
4453
|
+
}
|
|
4454
|
+
}
|
|
4455
|
+
// Request body
|
|
4456
|
+
if (op.requestBody?.content?.["application/json"]?.schema) {
|
|
4457
|
+
properties.body = {
|
|
4458
|
+
type: "object",
|
|
4459
|
+
description: "Request body",
|
|
4460
|
+
};
|
|
4461
|
+
}
|
|
4462
|
+
tools.push({
|
|
4463
|
+
name: operationId,
|
|
4464
|
+
description: summary.substring(0, 200),
|
|
4465
|
+
inputSchema: {
|
|
4466
|
+
type: "object",
|
|
4467
|
+
properties,
|
|
4468
|
+
...(required.length > 0 && { required }),
|
|
4469
|
+
},
|
|
4470
|
+
method: method.toUpperCase(),
|
|
4471
|
+
path,
|
|
4472
|
+
});
|
|
4473
|
+
}
|
|
4474
|
+
}
|
|
4475
|
+
return tools;
|
|
4476
|
+
}
|
|
4477
|
+
async function makeRequest(tool, args) {
|
|
4478
|
+
// Support both OpenAPI 3.0 (servers) and Swagger 2.0 (host + basePath)
|
|
4479
|
+
const apiSpec = API_SPEC;
|
|
4480
|
+
let baseUrl = "https://api.example.com";
|
|
4481
|
+
if (apiSpec.servers && apiSpec.servers.length > 0) {
|
|
4482
|
+
// OpenAPI 3.0
|
|
4483
|
+
baseUrl = apiSpec.servers[0].url;
|
|
4484
|
+
}
|
|
4485
|
+
else if (apiSpec.host) {
|
|
4486
|
+
// Swagger 2.0
|
|
4487
|
+
const scheme = apiSpec.schemes?.[0] || "https";
|
|
4488
|
+
const basePath = apiSpec.basePath || "";
|
|
4489
|
+
baseUrl = `${scheme}://${apiSpec.host}${basePath}`;
|
|
4490
|
+
}
|
|
4491
|
+
let url = baseUrl + tool.path;
|
|
4492
|
+
// Replace path parameters
|
|
4493
|
+
for (const [key, value] of Object.entries(args)) {
|
|
4494
|
+
if (url.includes(`{${key}}`)) {
|
|
4495
|
+
url = url.replace(`{${key}}`, encodeURIComponent(String(value)));
|
|
4496
|
+
}
|
|
4497
|
+
}
|
|
4498
|
+
// Add query parameters
|
|
4499
|
+
const queryParams = new URLSearchParams();
|
|
4500
|
+
for (const [key, value] of Object.entries(args)) {
|
|
4501
|
+
if (!tool.path.includes(`{${key}}`) && key !== "body") {
|
|
4502
|
+
queryParams.append(key, String(value));
|
|
4503
|
+
}
|
|
4504
|
+
}
|
|
4505
|
+
if (queryParams.toString()) {
|
|
4506
|
+
url += "?" + queryParams.toString();
|
|
4507
|
+
}
|
|
4508
|
+
const options = {
|
|
4509
|
+
method: tool.method,
|
|
4510
|
+
headers: {
|
|
4511
|
+
"Content-Type": "application/json",
|
|
4512
|
+
},
|
|
4513
|
+
};
|
|
4514
|
+
if (args.body && ["POST", "PUT", "PATCH"].includes(tool.method)) {
|
|
4515
|
+
options.body = JSON.stringify(args.body);
|
|
4516
|
+
}
|
|
4517
|
+
const response = await fetch(url, options);
|
|
4518
|
+
const data = await response.json();
|
|
4519
|
+
return {
|
|
4520
|
+
status: response.status,
|
|
4521
|
+
data,
|
|
4522
|
+
};
|
|
4523
|
+
}
|
|
4524
|
+
const server = new Server({
|
|
4525
|
+
name: "apicurio",
|
|
4526
|
+
version: "1.0.0",
|
|
4527
|
+
}, {
|
|
4528
|
+
capabilities: {
|
|
4529
|
+
tools: {},
|
|
4530
|
+
},
|
|
4531
|
+
});
|
|
4532
|
+
const tools = generateTools();
|
|
4533
|
+
server.setRequestHandler(ListToolsRequestSchema, async () => ({
|
|
4534
|
+
tools: tools.map(({ method, path, ...tool }) => tool),
|
|
4535
|
+
}));
|
|
4536
|
+
server.setRequestHandler(CallToolRequestSchema, async (request) => {
|
|
4537
|
+
const tool = tools.find((t) => t.name === request.params.name);
|
|
4538
|
+
if (!tool) {
|
|
4539
|
+
throw new Error(`Unknown tool: ${request.params.name}`);
|
|
4540
|
+
}
|
|
4541
|
+
try {
|
|
4542
|
+
const result = await makeRequest(tool, request.params.arguments || {});
|
|
4543
|
+
return {
|
|
4544
|
+
content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
|
|
4545
|
+
};
|
|
4546
|
+
}
|
|
4547
|
+
catch (error) {
|
|
4548
|
+
return {
|
|
4549
|
+
content: [{ type: "text", text: `Error: ${error.message}` }],
|
|
4550
|
+
isError: true,
|
|
4551
|
+
};
|
|
4552
|
+
}
|
|
4553
|
+
});
|
|
4554
|
+
async function main() {
|
|
4555
|
+
const transport = new StdioServerTransport();
|
|
4556
|
+
await server.connect(transport);
|
|
4557
|
+
}
|
|
4558
|
+
main();
|