{
    "openapi": "3.0.2",
    "info": {
        "title": "Apicurio Registry API",
        "version": "1.3.2.Final",
        "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 (schema and file descriptor)\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**Note**: The Apicurio Registry REST API is available from `http://MY-REGISTRY-URL/api`. You must prefix all API operation paths with `/api`, for example, `api/ids/{globalId}`.\n",
        "contact": {
            "name": "Apicurio",
            "url": "https://github.com/apicurio/apicurio-registry",
            "email": "apicurio@lists.jboss.org"
        },
        "license": {
            "name": "Apache 2.0",
            "url": "https://www.apache.org/licenses/LICENSE-2.0"
        }
    },
    "paths": {
        "/rules/{rule}": {
            "summary": "Manage the configuration of a single global artifact rule.",
            "get": {
                "tags": [
                    "Global rules"
                ],
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/Rule"
                                }
                            }
                        },
                        "description": "The global rule's configuration."
                    },
                    "404": {
                        "$ref": "#/components/responses/NotFound"
                    },
                    "500": {
                        "$ref": "#/components/responses/ServerError"
                    }
                },
                "operationId": "getGlobalRuleConfig",
                "summary": "Get global rule configuration",
                "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"
            },
            "put": {
                "requestBody": {
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/Rule"
                            }
                        }
                    },
                    "required": true
                },
                "tags": [
                    "Global rules"
                ],
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/Rule"
                                }
                            }
                        },
                        "description": "The global rule's configuration was successfully updated."
                    },
                    "404": {
                        "$ref": "#/components/responses/NotFound"
                    },
                    "500": {
                        "$ref": "#/components/responses/ServerError"
                    }
                },
                "operationId": "updateGlobalRuleConfig",
                "summary": "Update global rule configuration",
                "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"
            },
            "delete": {
                "tags": [
                    "Global rules"
                ],
                "responses": {
                    "204": {
                        "description": "The global rule was successfully deleted."
                    },
                    "404": {
                        "$ref": "#/components/responses/NotFound"
                    },
                    "500": {
                        "$ref": "#/components/responses/ServerError"
                    }
                },
                "operationId": "deleteGlobalRule",
                "summary": "Delete global rule",
                "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"
            },
            "parameters": [
                {
                    "name": "rule",
                    "description": "The unique name/type of a rule.",
                    "schema": {
                        "enum": [
                            "VALIDITY",
                            "COMPATIBILITY"
                        ],
                        "type": "string"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/rules": {
            "summary": "Manage the global rules that apply to all artifacts if not otherwise configured.",
            "get": {
                "tags": [
                    "Global rules"
                ],
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "type": "array",
                                    "items": {
                                        "$ref": "#/components/schemas/RuleType"
                                    }
                                }
                            }
                        },
                        "description": "The list of names of the globally configured rules."
                    },
                    "500": {
                        "$ref": "#/components/responses/ServerError"
                    }
                },
                "operationId": "listGlobalRules",
                "summary": "List global rules",
                "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"
            },
            "post": {
                "requestBody": {
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/Rule"
                            }
                        }
                    },
                    "required": true
                },
                "tags": [
                    "Global rules"
                ],
                "responses": {
                    "204": {
                        "description": "The global rule was added."
                    },
                    "400": {
                        "$ref": "#/components/responses/BadRequest"
                    },
                    "409": {
                        "$ref": "#/components/responses/Conflict"
                    },
                    "500": {
                        "$ref": "#/components/responses/ServerError"
                    }
                },
                "operationId": "createGlobalRule",
                "summary": "Create global rule",
                "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"
            },
            "delete": {
                "tags": [
                    "Global rules"
                ],
                "responses": {
                    "204": {
                        "description": "All global rules have been removed successfully."
                    },
                    "500": {
                        "$ref": "#/components/responses/ServerError"
                    }
                },
                "operationId": "deleteAllGlobalRules",
                "summary": "Delete all global rules",
                "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"
            }
        },
        "/ids/{globalId}": {
            "summary": "Access artifact content utilizing an artifact version's globally unique identifier.",
            "get": {
                "tags": [
                    "Artifacts"
                ],
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "examples": {
                                    "OpenAPI Example": {
                                        "value": {
                                            "openapi": "3.0.2",
                                            "info": {
                                                "title": "Empty API",
                                                "version": "1.0.0",
                                                "description": "An example API design using OpenAPI."
                                            }
                                        }
                                    }
                                }
                            },
                            "application/x-protobuf": {
                                "examples": {
                                    "Protobuf Example": {
                                        "value": "message SearchResponse {\n  repeated Result result = 1;\n}\n\nmessage Result {\n  required string url = 1;\n  optional string title = 2;\n  repeated string snippets = 3;\n}"
                                    }
                                }
                            },
                            "application/x-protobuffer": {
                                "examples": {
                                    "Protobuffer Example": {
                                        "value": "message SearchResponse {\n  repeated Result result = 1;\n}\n\nmessage Result {\n  required string url = 1;\n  optional string title = 2;\n  repeated string snippets = 3;\n}"
                                    }
                                }
                            }
                        },
                        "description": "The content of the artifact version."
                    }
                },
                "operationId": "getArtifactByGlobalId",
                "summary": "Get artifact by global ID",
                "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"
            },
            "parameters": [
                {
                    "name": "globalId",
                    "description": "Global identifier for an artifact version.",
                    "schema": {
                        "format": "int64",
                        "type": "integer"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/ids/{globalId}/meta": {
            "summary": "Access an artifact verison's metadata using its globally unique identifier.",
            "get": {
                "tags": [
                    "Metadata"
                ],
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/ArtifactMetaData"
                                }
                            }
                        },
                        "description": "The artifact's metadata."
                    },
                    "404": {
                        "$ref": "#/components/responses/NotFound"
                    },
                    "500": {
                        "$ref": "#/components/responses/ServerError"
                    }
                },
                "operationId": "getArtifactMetaDataByGlobalId",
                "summary": "Get global artifact metadata",
                "description": "Gets the metadata for an artifact version in the registry using its globally unique\nidentifier.  The returned metadata includes both generated (read-only) and editable\nmetadata (such as name and description).\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"
            },
            "parameters": [
                {
                    "name": "globalId",
                    "description": "Global identifier for an artifact version.",
                    "schema": {
                        "format": "int64",
                        "type": "integer"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/artifacts/{artifactId}/state": {
            "summary": "Manage the state of an artifact.",
            "put": {
                "requestBody": {
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/UpdateState"
                            }
                        }
                    },
                    "required": true
                },
                "tags": [
                    "Artifacts"
                ],
                "responses": {
                    "204": {
                        "description": "Returned when the operation was successful."
                    },
                    "400": {
                        "$ref": "#/components/responses/BadRequest"
                    },
                    "404": {
                        "$ref": "#/components/responses/NotFound"
                    },
                    "500": {
                        "$ref": "#/components/responses/ServerError"
                    }
                },
                "operationId": "updateArtifactState",
                "summary": "Update artifact state",
                "description": "Updates the state of the artifact. For example, you can use this to mark the latest version of an artifact as `DEPRECATED`. The operation changes the state of the latest version of the artifact, even if this version is `DISABLED`. If multiple versions exist, only the most recent is changed.\n\nThe following state changes are supported:\n\n* Enabled -> Disabled\n* Enabled -> Deprecated\n* Enabled -> Deleted\n* Disabled -> Enabled\n* Disabled -> Deleted\n* Disabled -> Deprecated\n* Deprecated -> Deleted\n\nThis operation can fail for the following reasons:\n\n* No artifact with this `artifactId` exists (HTTP error `404`)\n* Artifact cannot transition to the given state (HTTP error `400`)\n* A server error occurred (HTTP error `500`)\n"
            },
            "parameters": [
                {
                    "name": "artifactId",
                    "description": "The artifact ID.  Can be a string (client-provided) or integer (server-generated) representing the unique artifact identifier.",
                    "schema": {
                        "type": "string"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/artifacts/{artifactId}/versions/{version}": {
            "summary": "Manage a single version of a single artifact in the registry.",
            "get": {
                "tags": [
                    "Versions"
                ],
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "examples": {
                                    "OpenAPI": {
                                        "value": {
                                            "openapi": "3.0.2",
                                            "info": {
                                                "title": "Empty API",
                                                "version": "1.0.0",
                                                "description": "An example API design using OpenAPI."
                                            }
                                        }
                                    }
                                }
                            },
                            "application/x-protobuf": {
                                "examples": {
                                    "Protobuf Example": {
                                        "value": "message SearchResponse {\n  repeated Result result = 1;\n}\n\nmessage Result {\n  required string url = 1;\n  optional string title = 2;\n  repeated string snippets = 3;\n}"
                                    }
                                }
                            },
                            "application/x-protobuffer": {
                                "examples": {
                                    "Protobuffer Example": {
                                        "value": "message SearchResponse {\n  repeated Result result = 1;\n}\n\nmessage Result {\n  required string url = 1;\n  optional string title = 2;\n  repeated string snippets = 3;\n}"
                                    }
                                }
                            },
                            "application/graphql": {}
                        },
                        "description": "The content of the artifact version."
                    },
                    "404": {
                        "$ref": "#/components/responses/NotFound"
                    },
                    "500": {
                        "$ref": "#/components/responses/ServerError"
                    }
                },
                "operationId": "getArtifactVersion",
                "summary": "Get artifact version",
                "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"
            },
            "parameters": [
                {
                    "name": "version",
                    "description": "The unique identifier of a specific version of the artifact content.",
                    "schema": {
                        "type": "integer"
                    },
                    "in": "path",
                    "required": true
                },
                {
                    "name": "artifactId",
                    "description": "The artifact ID.  Can be a string (client-provided) or integer (server-generated) representing the unique artifact identifier.",
                    "schema": {
                        "type": "string"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/artifacts/{artifactId}/versions/{version}/state": {
            "summary": "Manage the state of a specific artifact version.",
            "put": {
                "requestBody": {
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/UpdateState"
                            }
                        }
                    },
                    "required": true
                },
                "tags": [
                    "Versions"
                ],
                "responses": {
                    "204": {
                        "description": "Returned when the update was successful."
                    },
                    "400": {
                        "$ref": "#/components/responses/BadRequest"
                    },
                    "404": {
                        "$ref": "#/components/responses/NotFound"
                    },
                    "500": {
                        "$ref": "#/components/responses/ServerError"
                    }
                },
                "operationId": "updateArtifactVersionState",
                "summary": "Update artifact version state",
                "description": "Updates the state of a specific version of an artifact.  For example, you can use \nthis operation to disable a specific version.\n\nThe following state changes are supported:\n\n* Enabled -> Disabled\n* Enabled -> Deprecated\n* Enabled -> Deleted\n* Disabled -> Enabled\n* Disabled -> Deleted\n* Disabled -> Deprecated\n* Deprecated -> Deleted\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* Artifact version cannot transition to the given state (HTTP error `400`)\n* A server error occurred (HTTP error `500`)\n"
            },
            "parameters": [
                {
                    "name": "version",
                    "description": "The unique identifier of a specific version of the artifact content.",
                    "schema": {
                        "type": "integer"
                    },
                    "in": "path",
                    "required": true
                },
                {
                    "name": "artifactId",
                    "description": "The artifact ID.  Can be a string (client-provided) or integer (server-generated) representing the unique artifact identifier.",
                    "schema": {
                        "type": "string"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/artifacts/{artifactId}/versions/{version}/meta": {
            "summary": "Manage the metadata for a single version of an artifact in the registry.",
            "get": {
                "tags": [
                    "Metadata"
                ],
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/VersionMetaData"
                                }
                            }
                        },
                        "description": "The artifact version's metadata."
                    },
                    "404": {
                        "$ref": "#/components/responses/NotFound"
                    },
                    "500": {
                        "$ref": "#/components/responses/ServerError"
                    }
                },
                "operationId": "getArtifactVersionMetaData",
                "summary": "Get artifact version metadata",
                "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"
            },
            "put": {
                "requestBody": {
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/EditableMetaData"
                            }
                        }
                    },
                    "required": true
                },
                "tags": [
                    "Metadata"
                ],
                "responses": {
                    "204": {
                        "description": "The artifact version's metadata was successfully updated."
                    },
                    "404": {
                        "$ref": "#/components/responses/NotFound"
                    },
                    "500": {
                        "$ref": "#/components/responses/ServerError"
                    }
                },
                "operationId": "updateArtifactVersionMetaData",
                "summary": "Update artifact version metadata",
                "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"
            },
            "delete": {
                "tags": [
                    "Metadata"
                ],
                "responses": {
                    "204": {
                        "description": "The artifact version's user-editable metadata was successfully deleted."
                    },
                    "404": {
                        "$ref": "#/components/responses/NotFound"
                    },
                    "500": {
                        "$ref": "#/components/responses/ServerError"
                    }
                },
                "operationId": "deleteArtifactVersionMetaData",
                "summary": "Delete artifact version metadata",
                "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"
            },
            "parameters": [
                {
                    "name": "version",
                    "description": "The unique identifier of a specific version of the artifact content.",
                    "schema": {
                        "type": "integer"
                    },
                    "in": "path",
                    "required": true
                },
                {
                    "name": "artifactId",
                    "description": "The artifact ID.  Can be a string (client-provided) or integer (server-generated) representing the unique artifact identifier.",
                    "schema": {
                        "type": "string"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/artifacts/{artifactId}/rules": {
            "summary": "Manage the rules for a single artifact.",
            "get": {
                "tags": [
                    "Artifact rules"
                ],
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "type": "array",
                                    "items": {
                                        "$ref": "#/components/schemas/RuleType"
                                    }
                                }
                            }
                        },
                        "description": "Returns the names of the rules configured for the artifact."
                    },
                    "404": {
                        "$ref": "#/components/responses/NotFound"
                    },
                    "500": {
                        "$ref": "#/components/responses/ServerError"
                    }
                },
                "operationId": "listArtifactRules",
                "summary": "List artifact rules",
                "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`)"
            },
            "post": {
                "requestBody": {
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/Rule"
                            }
                        }
                    },
                    "required": true
                },
                "tags": [
                    "Artifact rules"
                ],
                "responses": {
                    "204": {
                        "description": "The rule was added."
                    },
                    "400": {
                        "$ref": "#/components/responses/BadRequest"
                    },
                    "404": {
                        "$ref": "#/components/responses/NotFound"
                    },
                    "500": {
                        "$ref": "#/components/responses/ServerError"
                    }
                },
                "operationId": "createArtifactRule",
                "summary": "Create artifact rule",
                "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`)"
            },
            "delete": {
                "tags": [
                    "Artifact rules"
                ],
                "responses": {
                    "204": {
                        "description": "The rules were successfully deleted."
                    },
                    "404": {
                        "$ref": "#/components/responses/NotFound"
                    },
                    "500": {
                        "$ref": "#/components/responses/ServerError"
                    }
                },
                "operationId": "deleteArtifactRules",
                "summary": "Delete artifact rules",
                "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`)"
            },
            "parameters": [
                {
                    "name": "artifactId",
                    "description": "The artifact ID.  Can be a string (client-provided) or integer (server-generated) representing the unique artifact identifier.",
                    "schema": {
                        "type": "string"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/artifacts/{artifactId}/rules/{rule}": {
            "summary": "Manage the configuration of a single artifact rule.",
            "get": {
                "tags": [
                    "Artifact rules"
                ],
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/Rule"
                                }
                            }
                        },
                        "description": "Information about a rule."
                    },
                    "404": {
                        "$ref": "#/components/responses/NotFound"
                    },
                    "500": {
                        "$ref": "#/components/responses/ServerError"
                    }
                },
                "operationId": "getArtifactRuleConfig",
                "summary": "Get artifact rule configuration",
                "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`)"
            },
            "put": {
                "requestBody": {
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/Rule"
                            }
                        }
                    },
                    "required": true
                },
                "tags": [
                    "Artifact rules"
                ],
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/Rule"
                                }
                            }
                        },
                        "description": "Rule configuration was updated."
                    },
                    "404": {
                        "$ref": "#/components/responses/NotFound"
                    },
                    "500": {
                        "$ref": "#/components/responses/ServerError"
                    }
                },
                "operationId": "updateArtifactRuleConfig",
                "summary": "Update artifact rule configuration",
                "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"
            },
            "delete": {
                "tags": [
                    "Artifact rules"
                ],
                "responses": {
                    "204": {
                        "description": "The rule was successfully deleted."
                    },
                    "404": {
                        "$ref": "#/components/responses/NotFound"
                    },
                    "500": {
                        "$ref": "#/components/responses/ServerError"
                    }
                },
                "operationId": "deleteArtifactRule",
                "summary": "Delete artifact rule",
                "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`)"
            },
            "parameters": [
                {
                    "name": "rule",
                    "description": "The unique name/type of a rule.",
                    "schema": {
                        "enum": [
                            "VALIDITY",
                            "COMPATIBILITY"
                        ],
                        "type": "string"
                    },
                    "in": "path",
                    "required": true
                },
                {
                    "name": "artifactId",
                    "description": "The artifact ID.  Can be a string (client-provided) or integer (server-generated) representing the unique artifact identifier.",
                    "schema": {
                        "type": "string"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/search/artifacts/{artifactId}/versions": {
            "summary": "Search for all versions of an artifact.",
            "get": {
                "tags": [
                    "Search",
                    "Versions"
                ],
                "parameters": [
                    {
                        "name": "offset",
                        "description": "The number of versions to skip before starting to collect the result set.",
                        "schema": {
                            "type": "integer"
                        },
                        "in": "query",
                        "required": true
                    },
                    {
                        "name": "limit",
                        "description": "The number of versions to return.",
                        "schema": {
                            "type": "integer"
                        },
                        "in": "query",
                        "required": true
                    }
                ],
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/VersionSearchResults"
                                }
                            }
                        },
                        "description": "On a successful response, returns a result set of versions - one for each version\nof the artifact."
                    },
                    "404": {
                        "$ref": "#/components/responses/NotFound"
                    },
                    "500": {
                        "$ref": "#/components/responses/ServerError"
                    }
                },
                "operationId": "searchVersions",
                "summary": "Search artifact versions",
                "description": "Searches for versions of a specific artifact.  This is typically used to get a listing\nof all versions of an artifact (for example, in a user interface)."
            },
            "parameters": [
                {
                    "name": "artifactId",
                    "description": "The artifact ID.  Can be a string (client-provided) or integer (server-generated) representing the unique artifact identifier.",
                    "schema": {
                        "type": "string"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/artifacts": {
            "summary": "Manage the collection of artifacts in the registry.",
            "get": {
                "tags": [
                    "Artifacts"
                ],
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "type": "array",
                                    "items": {
                                        "type": "string"
                                    }
                                }
                            }
                        },
                        "description": "On a successful response, returns an array of artifact IDs - one for each artifact\nin the registry."
                    },
                    "500": {
                        "$ref": "#/components/responses/ServerError"
                    }
                },
                "operationId": "listArtifacts",
                "summary": "List all artifact IDs",
                "description": "Returns a list of IDs of all artifacts in the registry as a flat list.  Typically the\nserver is configured to limit the number of artifact IDs returned when a large number \nof artifacts exist. In this case, the result of this call may be non-deterministic. The \ndefault limit is typically 1000 artifacts."
            },
            "post": {
                "requestBody": {
                    "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* Protobuf File Descriptor (`PROTOBUF_FD`)\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",
                    "content": {
                        "*/*": {
                            "examples": {
                                "OpenAPI Example": {
                                    "value": {
                                        "openapi": "3.0.2",
                                        "info": {
                                            "title": "Empty API",
                                            "version": "1.0.7",
                                            "description": "An example API design using OpenAPI."
                                        },
                                        "paths": {
                                            "/widgets": {
                                                "get": {
                                                    "responses": {
                                                        "200": {
                                                            "content": {
                                                                "application/json": {
                                                                    "schema": {
                                                                        "type": "array",
                                                                        "items": {
                                                                            "type": "string"
                                                                        }
                                                                    }
                                                                }
                                                            },
                                                            "description": "All widgets"
                                                        }
                                                    },
                                                    "summary": "Get widgets"
                                                }
                                            }
                                        },
                                        "components": {
                                            "schemas": {
                                                "Widget": {
                                                    "title": "Root Type for Widget",
                                                    "description": "A sample data type.",
                                                    "type": "object",
                                                    "properties": {
                                                        "property-1": {
                                                            "type": "string"
                                                        },
                                                        "property-2": {
                                                            "type": "boolean"
                                                        }
                                                    },
                                                    "example": {
                                                        "property-1": "value1",
                                                        "property-2": true
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    },
                    "required": true
                },
                "tags": [
                    "Artifacts"
                ],
                "parameters": [
                    {
                        "name": "X-Registry-ArtifactType",
                        "description": "Specifies the type of the artifact being added. Possible values include:\n\n* Avro (`AVRO`)\n* Protobuf (`PROTOBUF`)\n* Protobuf File Descriptor (`PROTOBUF_FD`)\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`)",
                        "schema": {
                            "enum": [
                                "AVRO",
                                "PROTOBUF",
                                "PROTOBUF_FD",
                                "JSON",
                                "OPENAPI",
                                "ASYNCAPI",
                                "GRAPHQL",
                                "KCONNECT",
                                "WSDL",
                                "XSD",
                                "XML"
                            ],
                            "type": "string"
                        },
                        "in": "header"
                    },
                    {
                        "name": "X-Registry-ArtifactId",
                        "description": "A client-provided, globally unique identifier for the new artifact.",
                        "schema": {
                            "type": "string"
                        },
                        "in": "header"
                    },
                    {
                        "name": "ifExists",
                        "description": "Set this option to instruct the server on what to do if the artifact already exists.",
                        "schema": {
                            "enum": [
                                "FAIL",
                                "UPDATE",
                                "RETURN",
                                "RETURN_OR_UPDATE"
                            ],
                            "type": "string"
                        },
                        "in": "query"
                    }
                ],
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/ArtifactMetaData"
                                }
                            }
                        },
                        "description": "Artifact was successfully created."
                    },
                    "400": {
                        "$ref": "#/components/responses/BadRequest"
                    },
                    "409": {
                        "$ref": "#/components/responses/Conflict"
                    },
                    "500": {
                        "$ref": "#/components/responses/ServerError"
                    }
                },
                "operationId": "createArtifact",
                "summary": "Create artifact",
                "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* Protobuf File Descriptor (`PROTOBUF_FD`)\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",
                "x-codegen-async": true
            }
        },
        "/artifacts/{artifactId}": {
            "summary": "Manage a single artifact.",
            "get": {
                "tags": [
                    "Artifacts"
                ],
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "examples": {
                                    "OpenAPI": {
                                        "value": {
                                            "openapi": "3.0.2",
                                            "info": {
                                                "title": "Empty API",
                                                "version": "1.0.0",
                                                "description": "An example API design using OpenAPI."
                                            }
                                        }
                                    }
                                }
                            },
                            "application/x-protobuf": {
                                "examples": {
                                    "Protobuf Example": {
                                        "value": "message SearchResponse {\n  repeated Result result = 1;\n}\n\nmessage Result {\n  required string url = 1;\n  optional string title = 2;\n  repeated string snippets = 3;\n}"
                                    }
                                }
                            },
                            "application/x-protobuffer": {
                                "examples": {
                                    "Protobuffer Example": {
                                        "value": "message SearchResponse {\n  repeated Result result = 1;\n}\n\nmessage Result {\n  required string url = 1;\n  optional string title = 2;\n  repeated string snippets = 3;\n}"
                                    }
                                }
                            },
                            "application/graphql": {}
                        },
                        "description": "The most recent version of the artifact."
                    },
                    "404": {
                        "$ref": "#/components/responses/NotFound"
                    },
                    "500": {
                        "$ref": "#/components/responses/ServerError"
                    }
                },
                "operationId": "getLatestArtifact",
                "summary": "Get latest artifact",
                "description": "Returns the latest version of the artifact in its raw form.  The `Content-Type` of the response depends on the artifact type.  In most cases, this is `application/json`, but for some types it may be different (for example, `PROTOBUF`). If the latest version of the artifact is marked as `DISABLED`, the next available non-disabled version will be used.\n\nThis operation may fail for one of the following reasons:\n\n* No artifact with this `artifactId` exists or all versions are `DISABLED` (HTTP error `404`)\n* A server error occurred (HTTP error `500`)\n"
            },
            "put": {
                "requestBody": {
                    "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* Protobuf File Descriptor (`PROTOBUF_FD`)\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",
                    "content": {
                        "*/*": {
                            "examples": {
                                "OpenAPI Example": {
                                    "value": {
                                        "openapi": "3.0.2",
                                        "info": {
                                            "title": "Empty API",
                                            "version": "1.0.7",
                                            "description": "An example API design using OpenAPI."
                                        },
                                        "paths": {
                                            "/widgets": {
                                                "get": {
                                                    "responses": {
                                                        "200": {
                                                            "content": {
                                                                "application/json": {
                                                                    "schema": {
                                                                        "type": "array",
                                                                        "items": {
                                                                            "type": "string"
                                                                        }
                                                                    }
                                                                }
                                                            },
                                                            "description": "All widgets"
                                                        }
                                                    },
                                                    "summary": "Get widgets"
                                                }
                                            }
                                        },
                                        "components": {
                                            "schemas": {
                                                "Widget": {
                                                    "title": "Root Type for Widget",
                                                    "description": "A sample data type.",
                                                    "type": "object",
                                                    "properties": {
                                                        "property-1": {
                                                            "type": "string"
                                                        },
                                                        "property-2": {
                                                            "type": "boolean"
                                                        }
                                                    },
                                                    "example": {
                                                        "property-1": "value1",
                                                        "property-2": true
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    },
                    "required": true
                },
                "tags": [
                    "Artifacts"
                ],
                "parameters": [
                    {
                        "name": "X-Registry-ArtifactType",
                        "description": "Specifies the type of the artifact being added.  Possible values include:\n\n* Avro (`AVRO`)\n* Protobuf (`PROTOBUF`)\n* Protobuf File Descriptor (`PROTOBUF_FD`)\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`)",
                        "schema": {
                            "enum": [
                                "AVRO",
                                "PROTOBUF",
                                "PROTOBUF_FD",
                                "JSON",
                                "OPENAPI",
                                "ASYNCAPI",
                                "GRAPHQL",
                                "KCONNECT",
                                "WSDL",
                                "XSD",
                                "XML"
                            ],
                            "type": "string"
                        },
                        "in": "header",
                        "required": false
                    }
                ],
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/ArtifactMetaData"
                                }
                            }
                        },
                        "description": "When successful, returns the updated artifact metadata."
                    },
                    "404": {
                        "$ref": "#/components/responses/NotFound"
                    },
                    "409": {
                        "$ref": "#/components/responses/Conflict"
                    },
                    "500": {
                        "$ref": "#/components/responses/ServerError"
                    }
                },
                "operationId": "updateArtifact",
                "summary": "Update artifact",
                "description": "Updates an artifact by uploading new content.  The body of the request should\nbe the raw content of the artifact.  This is typically in JSON format for *most*\nof the supported 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* Protobuf File Descriptor (`PROTOBUF_FD`)\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\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 creates a new version of the artifact, making it the most recent\n(and therefore official) version of the artifact.",
                "x-codegen-async": true
            },
            "delete": {
                "tags": [
                    "Artifacts"
                ],
                "responses": {
                    "204": {
                        "description": "Returned when the artifact was successfully deleted."
                    },
                    "404": {
                        "$ref": "#/components/responses/NotFound"
                    },
                    "500": {
                        "$ref": "#/components/responses/ServerError"
                    }
                },
                "operationId": "deleteArtifact",
                "summary": "Delete artifact",
                "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`)"
            },
            "parameters": [
                {
                    "name": "artifactId",
                    "description": "The artifact ID.  Can be a string (client-provided) or integer (server-generated) representing the unique artifact identifier.",
                    "schema": {
                        "type": "string"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/artifacts/{artifactId}/meta": {
            "summary": "Manage the metadata of a single artifact.",
            "get": {
                "tags": [
                    "Metadata"
                ],
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/ArtifactMetaData"
                                }
                            }
                        },
                        "description": "The artifact's metadata."
                    },
                    "404": {
                        "$ref": "#/components/responses/NotFound"
                    },
                    "500": {
                        "$ref": "#/components/responses/ServerError"
                    }
                },
                "operationId": "getArtifactMetaData",
                "summary": "Get artifact metadata",
                "description": "Gets the metadata for an artifact in the registry, based on the latest version. If the latest version of the artifact is marked as `DISABLED`, the next available non-disabled version will be used. The returned metadata includes both 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 or all versions are `DISABLED` (HTTP error `404`)\n* A server error occurred (HTTP error `500`)"
            },
            "put": {
                "requestBody": {
                    "description": "Updated artifact metadata.",
                    "content": {
                        "*/*": {
                            "schema": {
                                "$ref": "#/components/schemas/EditableMetaData"
                            }
                        }
                    },
                    "required": true
                },
                "tags": [
                    "Metadata"
                ],
                "responses": {
                    "204": {
                        "description": "The artifact's metadata was updated."
                    },
                    "404": {
                        "$ref": "#/components/responses/NotFound"
                    },
                    "500": {
                        "$ref": "#/components/responses/ServerError"
                    }
                },
                "operationId": "updateArtifactMetaData",
                "summary": "Update artifact metadata",
                "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`)"
            },
            "post": {
                "requestBody": {
                    "description": "The content of an artifact version.",
                    "content": {
                        "application/json": {
                            "examples": {
                                "OpenAPI Example": {
                                    "value": {
                                        "openapi": "3.0.2",
                                        "info": {
                                            "title": "Empty API",
                                            "version": "1.0.7",
                                            "description": "An example API design using OpenAPI."
                                        },
                                        "paths": {
                                            "/widgets": {
                                                "get": {
                                                    "responses": {
                                                        "200": {
                                                            "content": {
                                                                "application/json": {
                                                                    "schema": {
                                                                        "type": "array",
                                                                        "items": {
                                                                            "type": "string"
                                                                        }
                                                                    }
                                                                }
                                                            },
                                                            "description": "All widgets"
                                                        }
                                                    },
                                                    "summary": "Get widgets"
                                                }
                                            }
                                        },
                                        "components": {
                                            "schemas": {
                                                "Widget": {
                                                    "title": "Root Type for Widget",
                                                    "description": "A sample data type.",
                                                    "type": "object",
                                                    "properties": {
                                                        "property-1": {
                                                            "type": "string"
                                                        },
                                                        "property-2": {
                                                            "type": "boolean"
                                                        }
                                                    },
                                                    "example": {
                                                        "property-1": "value1",
                                                        "property-2": true
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    },
                    "required": true
                },
                "tags": [
                    "Metadata"
                ],
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/ArtifactMetaData"
                                }
                            }
                        },
                        "description": "The metadata of the artifact version matching the provided content."
                    },
                    "404": {
                        "$ref": "#/components/responses/NotFound"
                    },
                    "500": {
                        "$ref": "#/components/responses/ServerError"
                    }
                },
                "operationId": "getArtifactMetaDataByContent",
                "summary": "Get artifact metadata by content",
                "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"
            },
            "parameters": [
                {
                    "name": "artifactId",
                    "description": "The artifact ID.  Can be a string (client-provided) or integer (server-generated) representing the unique artifact identifier.",
                    "schema": {
                        "type": "string"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/artifacts/{artifactId}/versions": {
            "summary": "Manage all the versions of an artifact in the registry.",
            "get": {
                "tags": [
                    "Versions"
                ],
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "type": "array",
                                    "items": {
                                        "format": "int64",
                                        "type": "integer"
                                    }
                                },
                                "examples": {
                                    "All Versions": {
                                        "value": [
                                            5,
                                            6,
                                            10,
                                            103
                                        ]
                                    }
                                }
                            }
                        },
                        "description": "List of all artifact versions (just the version IDs)."
                    },
                    "404": {
                        "$ref": "#/components/responses/NotFound"
                    },
                    "500": {
                        "$ref": "#/components/responses/ServerError"
                    }
                },
                "operationId": "listArtifactVersions",
                "summary": "List artifact versions",
                "description": "Returns a list of all version numbers for the 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`)\n"
            },
            "post": {
                "requestBody": {
                    "description": "The content of the artifact version 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* Protobuf File Descriptor (`PROTOBUF_FD`)\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",
                    "content": {
                        "*/*": {
                            "examples": {
                                "OpenAPI Example": {
                                    "value": {
                                        "openapi": "3.0.2",
                                        "info": {
                                            "title": "Empty API",
                                            "version": "1.0.7",
                                            "description": "An example API design using OpenAPI."
                                        },
                                        "paths": {
                                            "/widgets": {
                                                "get": {
                                                    "responses": {
                                                        "200": {
                                                            "content": {
                                                                "application/json": {
                                                                    "schema": {
                                                                        "type": "array",
                                                                        "items": {
                                                                            "type": "string"
                                                                        }
                                                                    }
                                                                }
                                                            },
                                                            "description": "All widgets"
                                                        }
                                                    },
                                                    "summary": "Get widgets"
                                                }
                                            }
                                        },
                                        "components": {
                                            "schemas": {
                                                "Widget": {
                                                    "title": "Root Type for Widget",
                                                    "description": "A sample data type.",
                                                    "type": "object",
                                                    "properties": {
                                                        "property-1": {
                                                            "type": "string"
                                                        },
                                                        "property-2": {
                                                            "type": "boolean"
                                                        }
                                                    },
                                                    "example": {
                                                        "property-1": "value1",
                                                        "property-2": true
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    },
                    "required": true
                },
                "tags": [
                    "Versions"
                ],
                "parameters": [
                    {
                        "name": "X-Registry-ArtifactType",
                        "description": "This header parameter can be used to indicate the type of the artifact being added. Possible values include: \n* Avro (`AVRO`)   \n* Protobuf (`PROTOBUF`)  \n* Protobuf File Descriptor (`PROTOBUF_FD`)   \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`)",
                        "schema": {
                            "enum": [
                                "AVRO",
                                "PROTOBUF",
                                "PROTOBUF_FD",
                                "JSON",
                                "OPENAPI",
                                "ASYNCAPI",
                                "GRAPHQL",
                                "KCONNECT",
                                "WSDL",
                                "XSD",
                                "XML"
                            ],
                            "type": "string"
                        },
                        "in": "header"
                    }
                ],
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/VersionMetaData"
                                }
                            }
                        },
                        "description": "The artifact version was successfully created."
                    },
                    "404": {
                        "$ref": "#/components/responses/NotFound"
                    },
                    "409": {
                        "$ref": "#/components/responses/Conflict"
                    },
                    "500": {
                        "$ref": "#/components/responses/ServerError"
                    }
                },
                "operationId": "createArtifactVersion",
                "summary": "Create artifact version",
                "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 should be the raw content of the new artifact version.  This \nis typically in JSON format for *most* of the supported types, but may be in another \nformat 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* Protobuf File Descriptor (`PROTOBUF_FD`)\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 explicitly specify the artifact type using the `X-Registry-ArtifactType` \nHTTP request header, or by including a hint in the request's `Content-Type`.\n\nFor example:\n\n```\nContent-Type: application/json; artifactType=AVRO\n```\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",
                "x-codegen-async": true
            },
            "parameters": [
                {
                    "name": "artifactId",
                    "description": "The artifact ID.  Can be a string (client-provided) or integer (server-generated) representing the unique artifact identifier.",
                    "schema": {
                        "type": "string"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/artifacts/{artifactId}/test": {
            "summary": "Test whether content would pass update rules.",
            "put": {
                "requestBody": {
                    "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* Protobuf File Descriptor (`PROTOBUF_FD`)\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",
                    "content": {
                        "*/*": {}
                    },
                    "required": true
                },
                "tags": [
                    "Artifact rules"
                ],
                "parameters": [
                    {
                        "name": "X-Registry-ArtifactType",
                        "description": "This header parameter can be used to indicate the type of the artifact being added.  Possible values include: \n* Avro (`AVRO`)  \n* Protobuf (`PROTOBUF`)  \n* Protobuf File Descriptor (`PROTOBUF_FD`)  \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`)",
                        "schema": {
                            "enum": [
                                "AVRO",
                                "PROTOBUF",
                                "PROTOBUF_FD",
                                "JSON",
                                "OPENAPI",
                                "ASYNCAPI",
                                "GRAPHQL",
                                "KCONNECT",
                                "WSDL",
                                "XSD",
                                "XML"
                            ],
                            "type": "string"
                        },
                        "in": "header"
                    }
                ],
                "responses": {
                    "204": {
                        "description": "When successful, returns \"No Content\" to indicate that the rules passed, and the\ncontent was not updated."
                    },
                    "404": {
                        "$ref": "#/components/responses/NotFound"
                    },
                    "409": {
                        "$ref": "#/components/responses/Conflict"
                    },
                    "500": {
                        "$ref": "#/components/responses/ServerError"
                    }
                },
                "operationId": "testUpdateArtifact",
                "summary": "Test update artifact",
                "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 registry attempts to figure out what kind of artifact is being added from the following  supported list: \n\n* Avro (`AVRO`)  \n* Protobuf (`PROTOBUF`)  \n* Protobuf File Descriptor (`PROTOBUF_FD`)  \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 explicitly specify the artifact type using the `X-Registry-ArtifactType` \nHTTP request header, or by including a hint in the request's `Content-Type`.  For example:\n\n```\nContent-Type: application/json; artifactType=AVRO\n```\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."
            },
            "parameters": [
                {
                    "name": "artifactId",
                    "description": "The artifact ID.  Can be a string (client-provided) or integer (server-generated) representing the unique artifact identifier.",
                    "schema": {
                        "type": "string"
                    },
                    "in": "path",
                    "required": true
                }
            ]
        },
        "/search/artifacts": {
            "summary": "Search for content in the registry; artifacts in particular.",
            "get": {
                "tags": [
                    "Search",
                    "Artifacts"
                ],
                "parameters": [
                    {
                        "name": "search",
                        "description": "The text to search.",
                        "schema": {
                            "type": "string"
                        },
                        "in": "query"
                    },
                    {
                        "name": "offset",
                        "description": "The number of artifacts to skip before starting to collect the result set.",
                        "schema": {
                            "default": 0,
                            "type": "integer"
                        },
                        "in": "query",
                        "required": true
                    },
                    {
                        "name": "limit",
                        "description": "The number of artifacts to return.",
                        "schema": {
                            "default": 20,
                            "type": "integer"
                        },
                        "in": "query",
                        "required": true
                    },
                    {
                        "name": "over",
                        "description": "What fields to search.",
                        "schema": {
                            "enum": [
                                "everything",
                                "name",
                                "description",
                                "labels"
                            ],
                            "type": "string"
                        },
                        "in": "query",
                        "required": false
                    },
                    {
                        "name": "order",
                        "description": "Sort order, ascending or descending.",
                        "schema": {
                            "enum": [
                                "asc",
                                "desc"
                            ],
                            "type": "string"
                        },
                        "in": "query",
                        "required": false
                    }
                ],
                "responses": {
                    "200": {
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/ArtifactSearchResults"
                                }
                            }
                        },
                        "description": "On a successful response, returns a result set of artifacts - one for each artifact\nin the registry that matches the criteria."
                    },
                    "500": {
                        "$ref": "#/components/responses/ServerError"
                    }
                },
                "operationId": "searchArtifacts",
                "summary": "Search for artifacts",
                "description": "Returns a paginated list of all artifacts that match the provided search criteria.\n"
            }
        }
    },
    "components": {
        "schemas": {
            "EditableMetaData": {
                "title": "Root Type for EditableArtifactMetaData",
                "description": "",
                "type": "object",
                "properties": {
                    "name": {
                        "type": "string"
                    },
                    "description": {
                        "type": "string"
                    },
                    "labels": {
                        "description": "",
                        "type": "array",
                        "items": {
                            "type": "string"
                        }
                    },
                    "properties": {
                        "$ref": "#/components/schemas/Properties",
                        "description": ""
                    }
                },
                "example": {
                    "name": "Artifact Name",
                    "description": "The description of the artifact.",
                    "labels": [
                        "regional",
                        "global"
                    ],
                    "properties": {
                        "custom-1": "foo",
                        "custom-2": "bar"
                    }
                }
            },
            "VersionMetaData": {
                "title": "Root Type for ArtifactVersionMetaData",
                "description": "",
                "required": [
                    "createdOn",
                    "createdBy",
                    "version",
                    "type",
                    "globalId",
                    "id"
                ],
                "type": "object",
                "properties": {
                    "version": {
                        "format": "int64",
                        "type": "integer"
                    },
                    "name": {
                        "type": "string"
                    },
                    "description": {
                        "type": "string"
                    },
                    "createdBy": {
                        "type": "string"
                    },
                    "createdOn": {
                        "format": "date-time",
                        "type": "string"
                    },
                    "type": {
                        "$ref": "#/components/schemas/ArtifactType",
                        "description": ""
                    },
                    "globalId": {
                        "format": "int64",
                        "description": "",
                        "type": "integer"
                    },
                    "state": {
                        "$ref": "#/components/schemas/ArtifactState",
                        "description": ""
                    },
                    "id": {
                        "description": "The artifact id.",
                        "type": "string"
                    },
                    "labels": {
                        "description": "",
                        "type": "array",
                        "items": {
                            "type": "string"
                        }
                    },
                    "properties": {
                        "$ref": "#/components/schemas/Properties",
                        "description": ""
                    }
                },
                "example": {
                    "id": "my-artifact-id",
                    "version": 1221432,
                    "type": "PROTOBUF",
                    "name": "Artifact Name",
                    "description": "The description of the artifact",
                    "createdBy": "user1",
                    "createdOn": "2019-05-17T12:00:00Z",
                    "globalId": 183282932983,
                    "labels": [
                        "label-1",
                        "label-2"
                    ],
                    "properties": {
                        "custom-1": "foo",
                        "custom-2": "bar"
                    }
                }
            },
            "ArtifactMetaData": {
                "title": "Root Type for ArtifactMetaData",
                "description": "",
                "required": [
                    "id",
                    "createdBy",
                    "createdOn",
                    "modifiedBy",
                    "modifiedOn",
                    "version",
                    "type",
                    "globalId",
                    "state"
                ],
                "type": "object",
                "properties": {
                    "name": {
                        "type": "string"
                    },
                    "description": {
                        "type": "string"
                    },
                    "createdBy": {
                        "type": "string"
                    },
                    "createdOn": {
                        "format": "date-time",
                        "type": "string"
                    },
                    "modifiedBy": {
                        "type": "string"
                    },
                    "modifiedOn": {
                        "format": "date-time",
                        "type": "string"
                    },
                    "id": {
                        "description": "",
                        "type": "string"
                    },
                    "version": {
                        "format": "int64",
                        "description": "",
                        "type": "integer"
                    },
                    "type": {
                        "$ref": "#/components/schemas/ArtifactType",
                        "description": ""
                    },
                    "globalId": {
                        "format": "int64",
                        "description": "",
                        "type": "integer"
                    },
                    "state": {
                        "$ref": "#/components/schemas/ArtifactState",
                        "description": ""
                    },
                    "labels": {
                        "description": "",
                        "type": "array",
                        "items": {
                            "type": "string"
                        }
                    },
                    "properties": {
                        "$ref": "#/components/schemas/Properties",
                        "description": ""
                    }
                },
                "example": {
                    "id": "Procurement-Invoice",
                    "name": "Artifact Name",
                    "description": "Description of the artifact",
                    "type": "AVRO",
                    "version": 18,
                    "createdBy": "user1",
                    "createdOn": "2019-03-22T12:51:19Z",
                    "modifiedBy": "user2",
                    "modifiedOn": "2019-07-19T15:09:00Z",
                    "globalId": 12984719247,
                    "labels": [
                        "label-1",
                        "label-2"
                    ],
                    "properties": {
                        "custom-1": "foo",
                        "custom-2": "bar"
                    }
                }
            },
            "Rule": {
                "title": "Root Type for Rule",
                "description": "",
                "required": [
                    "config"
                ],
                "type": "object",
                "properties": {
                    "config": {
                        "type": "string"
                    },
                    "type": {
                        "$ref": "#/components/schemas/RuleType"
                    }
                },
                "example": {
                    "type": "VALIDITY",
                    "config": "FULL"
                }
            },
            "Error": {
                "title": "Root Type for Error",
                "description": "All error responses, whether `4xx` or `5xx` will include one of these as the response\nbody.",
                "type": "object",
                "properties": {
                    "message": {
                        "description": "The short error message.",
                        "type": "string"
                    },
                    "error_code": {
                        "format": "int32",
                        "description": "The server-side error code.",
                        "type": "integer"
                    },
                    "detail": {
                        "description": "Full details about the error.  This might contain a server stack trace, for example.",
                        "type": "string"
                    }
                },
                "example": {
                    "error_code": 500,
                    "message": "An error occurred somewhere."
                }
            },
            "RuleType": {
                "description": "",
                "enum": [
                    "VALIDITY",
                    "COMPATIBILITY"
                ],
                "type": "string",
                "example": "VALIDITY",
                "x-codegen-package": "io.apicurio.registry.types"
            },
            "ArtifactType": {
                "description": "",
                "enum": [
                    "AVRO",
                    "PROTOBUF",
                    "PROTOBUF_FD",
                    "JSON",
                    "OPENAPI",
                    "ASYNCAPI",
                    "GRAPHQL",
                    "KCONNECT",
                    "WSDL",
                    "XSD",
                    "XML"
                ],
                "type": "string",
                "example": "AVRO",
                "x-codegen-package": "io.apicurio.registry.types"
            },
            "UpdateState": {
                "title": "Root Type for UpdateState",
                "description": "",
                "required": [
                    "state"
                ],
                "type": "object",
                "properties": {
                    "state": {
                        "$ref": "#/components/schemas/ArtifactState"
                    }
                },
                "example": {
                    "state": "DISABLED"
                }
            },
            "ArtifactState": {
                "description": "Describes the state of an artifact or artifact version.  The following states\nare possible:\n\n* ENABLED\n* DISABLED\n* DEPRECATED\n",
                "enum": [
                    "ENABLED",
                    "DISABLED",
                    "DEPRECATED",
                    "DELETED"
                ],
                "type": "string",
                "x-codegen-package": "io.apicurio.registry.types"
            },
            "ArtifactSearchResults": {
                "description": "Describes the response received when searching for artifacts.",
                "required": [
                    "count",
                    "artifacts"
                ],
                "type": "object",
                "properties": {
                    "artifacts": {
                        "description": "The artifacts that matched the search criteria.",
                        "type": "array",
                        "items": {
                            "$ref": "#/components/schemas/SearchedArtifact"
                        }
                    },
                    "count": {
                        "description": "The total number of artifacts that matched the search criteria.",
                        "type": "integer"
                    }
                }
            },
            "SearchedArtifact": {
                "description": "Models a single artifact from the result set returned when searching for artifacts.",
                "required": [
                    "createdBy",
                    "createdOn",
                    "id",
                    "type",
                    "state"
                ],
                "type": "object",
                "properties": {
                    "id": {
                        "description": "",
                        "type": "string"
                    },
                    "name": {
                        "description": "",
                        "type": "string"
                    },
                    "description": {
                        "description": "",
                        "type": "string"
                    },
                    "createdOn": {
                        "format": "date-time",
                        "description": "",
                        "type": "string"
                    },
                    "createdBy": {
                        "description": "",
                        "type": "string"
                    },
                    "type": {
                        "$ref": "#/components/schemas/ArtifactType",
                        "description": ""
                    },
                    "labels": {
                        "description": "",
                        "type": "array",
                        "items": {
                            "type": "string"
                        }
                    },
                    "state": {
                        "$ref": "#/components/schemas/ArtifactState",
                        "description": ""
                    },
                    "modifiedOn": {
                        "format": "date-time",
                        "description": "",
                        "type": "string"
                    },
                    "modifiedBy": {
                        "description": "",
                        "type": "string"
                    }
                },
                "example": {
                    "id": "Procurement-Invoice",
                    "name": "Artifact Name",
                    "description": "Description of the artifact",
                    "labels": [
                        "current",
                        "internal"
                    ],
                    "type": "AVRO",
                    "state": "ENABLED",
                    "createdBy": "user1",
                    "createdOn": "2019-03-22T12:51:19Z"
                }
            },
            "SortOrder": {
                "description": "",
                "enum": [
                    "asc",
                    "desc"
                ],
                "type": "string"
            },
            "SearchOver": {
                "description": "",
                "enum": [
                    "everything",
                    "name",
                    "description",
                    "labels"
                ],
                "type": "string"
            },
            "VersionSearchResults": {
                "description": "Describes the response received when searching for artifacts.",
                "required": [
                    "count",
                    "versions"
                ],
                "type": "object",
                "properties": {
                    "count": {
                        "description": "The total number of artifacts that matched the search criteria.",
                        "type": "integer"
                    },
                    "versions": {
                        "description": "",
                        "type": "array",
                        "items": {
                            "$ref": "#/components/schemas/SearchedVersion"
                        }
                    }
                }
            },
            "SearchedVersion": {
                "description": "Models a single artifact from the result set returned when searching for artifacts.",
                "required": [
                    "createdBy",
                    "createdOn",
                    "type",
                    "state",
                    "globalId",
                    "version"
                ],
                "type": "object",
                "properties": {
                    "name": {
                        "description": "",
                        "type": "string"
                    },
                    "description": {
                        "description": "",
                        "type": "string"
                    },
                    "createdOn": {
                        "format": "date-time",
                        "description": "",
                        "type": "string"
                    },
                    "createdBy": {
                        "description": "",
                        "type": "string"
                    },
                    "type": {
                        "$ref": "#/components/schemas/ArtifactType",
                        "description": ""
                    },
                    "labels": {
                        "description": "",
                        "type": "array",
                        "items": {
                            "type": "string"
                        }
                    },
                    "state": {
                        "$ref": "#/components/schemas/ArtifactState",
                        "description": ""
                    },
                    "globalId": {
                        "format": "int64",
                        "description": "",
                        "type": "integer"
                    },
                    "version": {
                        "format": "int32",
                        "description": "",
                        "type": "integer"
                    }
                },
                "example": {
                    "globalId": 3849759283547,
                    "version": 17,
                    "name": "Artifact Version Name",
                    "description": "Description of the artifact version",
                    "labels": [
                        "current",
                        "internal"
                    ],
                    "type": "AVRO",
                    "state": "ENABLED",
                    "createdBy": "user1",
                    "createdOn": "2019-03-22T12:51:19Z"
                }
            },
            "Properties": {
                "description": "User-defined name-value pairs. Name and value must be strings.",
                "type": "object",
                "additionalProperties": {
                    "type": "string"
                }
            }
        },
        "responses": {
            "NotFound": {
                "content": {
                    "application/json": {
                        "schema": {
                            "$ref": "#/components/schemas/Error"
                        },
                        "examples": {
                            "NotFoundExample": {
                                "value": {
                                    "error_code": 404,
                                    "message": "No artifact with id 'Topic-1/Inbound' could be found."
                                }
                            }
                        }
                    }
                },
                "description": "Common response for all operations that can return a `404` error."
            },
            "ServerError": {
                "content": {
                    "application/json": {
                        "schema": {
                            "$ref": "#/components/schemas/Error"
                        },
                        "examples": {
                            "ErrorExample": {
                                "value": {
                                    "error_code": 500,
                                    "message": "Lost connection to the database."
                                }
                            }
                        }
                    }
                },
                "description": "Common response for all operations that can fail with an unexpected server error."
            },
            "BadRequest": {
                "content": {
                    "application/json": {
                        "schema": {
                            "$ref": "#/components/schemas/Error"
                        }
                    }
                },
                "description": "Common response for all operations that can return a `400` error."
            },
            "Conflict": {
                "content": {
                    "application/json": {
                        "schema": {
                            "$ref": "#/components/schemas/Error"
                        },
                        "examples": {
                            "ConflictExample": {
                                "value": {
                                    "error_code": 409,
                                    "message": "The artifact content was invalid."
                                }
                            }
                        }
                    }
                },
                "description": "Common response used when an input conflicts with existing data."
            }
        }
    },
    "tags": [
        {
            "name": "Artifacts",
            "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."
        },
        {
            "name": "Metadata",
            "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."
        },
        {
            "name": "Versions",
            "description": "Whenever an artifact's content is updated, the old versions of the artifact's content\nare not lost.  All versions can be listed and accessed if necessary.  This section \ndescribes the operations used to list and access all versions of an artifact's content\nand metadata."
        },
        {
            "name": "Artifact rules",
            "description": "Rules can be configured on a per-artifact basis, allowing for different approaches\nto content evolution for each artifact.  These rules will override any global rules\nthat have been configured.  This section contains the operations used to manage a\nsingle artifact's rules."
        },
        {
            "name": "Global rules",
            "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 will be applied \nwhenever an artifact is added to the registry, and also whenever an artifact's \ncontent is updated (only if that artifact doesn't have its own specific rules \nconfigured). This section describes the operations used to manage the global rules."
        },
        {
            "name": "Search",
            "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. "
        }
    ]
}