import { createValidatedOpenApiRouter } from '@backstage/backend-openapi-utils';
export declare const spec: {
    readonly openapi: "3.0.3";
    readonly info: {
        readonly title: "catalog";
        readonly version: "1";
        readonly description: "The Backstage backend plugin that provides the Backstage catalog";
        readonly license: {
            readonly name: "Apache-2.0";
            readonly url: "http://www.apache.org/licenses/LICENSE-2.0.html";
        };
        readonly contact: {};
    };
    readonly servers: readonly [{
        readonly url: "/";
    }];
    readonly components: {
        readonly examples: {};
        readonly headers: {};
        readonly parameters: {
            readonly kind: {
                readonly name: "kind";
                readonly in: "path";
                readonly required: true;
                readonly allowReserved: true;
                readonly schema: {
                    readonly type: "string";
                };
            };
            readonly namespace: {
                readonly name: "namespace";
                readonly in: "path";
                readonly required: true;
                readonly allowReserved: true;
                readonly schema: {
                    readonly type: "string";
                };
            };
            readonly name: {
                readonly name: "name";
                readonly in: "path";
                readonly required: true;
                readonly allowReserved: true;
                readonly schema: {
                    readonly type: "string";
                };
            };
            readonly uid: {
                readonly name: "uid";
                readonly in: "path";
                readonly required: true;
                readonly allowReserved: true;
                readonly schema: {
                    readonly type: "string";
                };
            };
            readonly cursor: {
                readonly name: "cursor";
                readonly in: "query";
                readonly description: "Cursor to a set page of results.";
                readonly required: false;
                readonly allowReserved: true;
                readonly schema: {
                    readonly type: "string";
                    readonly minLength: 1;
                };
            };
            readonly after: {
                readonly name: "after";
                readonly in: "query";
                readonly description: "Pointer to the previous page of results.";
                readonly required: false;
                readonly allowReserved: true;
                readonly schema: {
                    readonly type: "string";
                    readonly minLength: 1;
                };
            };
            readonly fields: {
                readonly name: "fields";
                readonly in: "query";
                readonly description: "Restrict to just these fields in the response.";
                readonly required: false;
                readonly allowReserved: true;
                readonly explode: false;
                readonly schema: {
                    readonly type: "array";
                    readonly items: {
                        readonly type: "string";
                    };
                };
                readonly examples: {
                    readonly 'Get name and the entire relations collection': {
                        readonly value: readonly ["metadata.name", "relations"];
                    };
                    readonly 'Get kind, name and namespace': {
                        readonly value: readonly ["kind", "metadata.name", "metadata.namespace"];
                    };
                };
            };
            readonly filter: {
                readonly name: "filter";
                readonly in: "query";
                readonly description: "Filter for just the entities defined by this filter.";
                readonly required: false;
                readonly allowReserved: true;
                readonly schema: {
                    readonly type: "array";
                    readonly items: {
                        readonly type: "string";
                    };
                };
                readonly examples: {
                    readonly 'Get groups': {
                        readonly value: readonly ["kind=group"];
                    };
                    readonly 'Get orphaned components': {
                        readonly value: readonly ["kind=component,metadata.annotations.backstage.io/orphan=true"];
                    };
                };
            };
            readonly offset: {
                readonly name: "offset";
                readonly in: "query";
                readonly description: "Number of records to skip in the query page.";
                readonly required: false;
                readonly allowReserved: true;
                readonly schema: {
                    readonly type: "integer";
                    readonly minimum: 0;
                };
            };
            readonly limit: {
                readonly name: "limit";
                readonly in: "query";
                readonly description: "Number of records to return in the response.";
                readonly required: false;
                readonly allowReserved: true;
                readonly schema: {
                    readonly type: "integer";
                    readonly minimum: 0;
                };
            };
            readonly orderField: {
                readonly name: "orderField";
                readonly in: "query";
                readonly description: "The fields to sort returned results by.";
                readonly required: false;
                readonly allowReserved: true;
                readonly schema: {
                    readonly type: "array";
                    readonly items: {
                        readonly type: "string";
                        readonly description: "A two-item tuple of [field, order].";
                    };
                };
                readonly explode: true;
                readonly style: "form";
                readonly examples: {
                    readonly 'Order ascending by name': {
                        readonly value: readonly ["metadata.name,asc"];
                    };
                    readonly 'Order descending by owner': {
                        readonly value: readonly ["spec.owner,desc"];
                    };
                };
            };
        };
        readonly requestBodies: {};
        readonly responses: {
            readonly ErrorResponse: {
                readonly description: "An error response from the backend.";
                readonly content: {
                    readonly 'application/json': {
                        readonly schema: {
                            readonly $ref: "#/components/schemas/Error";
                        };
                    };
                };
            };
        };
        readonly schemas: {
            readonly Error: {
                readonly type: "object";
                readonly properties: {
                    readonly error: {
                        readonly type: "object";
                        readonly properties: {
                            readonly name: {
                                readonly type: "string";
                            };
                            readonly message: {
                                readonly type: "string";
                            };
                            readonly stack: {
                                readonly type: "string";
                            };
                            readonly code: {
                                readonly type: "string";
                            };
                        };
                        readonly required: readonly ["name", "message"];
                    };
                    readonly request: {
                        readonly type: "object";
                        readonly properties: {
                            readonly method: {
                                readonly type: "string";
                            };
                            readonly url: {
                                readonly type: "string";
                            };
                        };
                        readonly required: readonly ["method", "url"];
                    };
                    readonly response: {
                        readonly type: "object";
                        readonly properties: {
                            readonly statusCode: {
                                readonly type: "number";
                            };
                        };
                        readonly required: readonly ["statusCode"];
                    };
                };
                readonly required: readonly ["error", "response"];
                readonly additionalProperties: {};
            };
            readonly JsonObject: {
                readonly type: "object";
                readonly properties: {};
                readonly description: "A type representing all allowed JSON object values.";
                readonly additionalProperties: {};
            };
            readonly MapStringString: {
                readonly type: "object";
                readonly properties: {};
                readonly additionalProperties: {
                    readonly type: "string";
                };
                readonly description: "Construct a type with a set of properties K of type T";
            };
            readonly EntityLink: {
                readonly type: "object";
                readonly properties: {
                    readonly type: {
                        readonly type: "string";
                        readonly description: "An optional value to categorize links into specific groups";
                    };
                    readonly icon: {
                        readonly type: "string";
                        readonly description: "An optional semantic key that represents a visual icon.";
                    };
                    readonly title: {
                        readonly type: "string";
                        readonly description: "An optional descriptive title for the link.";
                    };
                    readonly url: {
                        readonly type: "string";
                        readonly description: "The url to the external site, document, etc.";
                    };
                };
                readonly required: readonly ["url"];
                readonly description: "A link to external information that is related to the entity.";
                readonly additionalProperties: false;
            };
            readonly EntityMeta: {
                readonly type: "object";
                readonly properties: {
                    readonly links: {
                        readonly type: "array";
                        readonly items: {
                            readonly $ref: "#/components/schemas/EntityLink";
                        };
                        readonly description: "A list of external hyperlinks related to the entity.";
                    };
                    readonly tags: {
                        readonly type: "array";
                        readonly items: {
                            readonly type: "string";
                        };
                        readonly description: "A list of single-valued strings, to for example classify catalog entities in\nvarious ways.";
                    };
                    readonly annotations: {
                        readonly $ref: "#/components/schemas/MapStringString";
                    };
                    readonly labels: {
                        readonly $ref: "#/components/schemas/MapStringString";
                    };
                    readonly description: {
                        readonly type: "string";
                        readonly description: "A short (typically relatively few words, on one line) description of the\nentity.";
                    };
                    readonly title: {
                        readonly type: "string";
                        readonly description: "A display name of the entity, to be presented in user interfaces instead\nof the `name` property above, when available.\nThis field is sometimes useful when the `name` is cumbersome or ends up\nbeing perceived as overly technical. The title generally does not have\nas stringent format requirements on it, so it may contain special\ncharacters and be more explanatory. Do keep it very short though, and\navoid situations where a title can be confused with the name of another\nentity, or where two entities share a title.\nNote that this is only for display purposes, and may be ignored by some\nparts of the code. Entity references still always make use of the `name`\nproperty, not the title.";
                    };
                    readonly namespace: {
                        readonly type: "string";
                        readonly description: "The namespace that the entity belongs to.";
                    };
                    readonly name: {
                        readonly type: "string";
                        readonly description: "The name of the entity.\nMust be unique within the catalog at any given point in time, for any\ngiven namespace + kind pair. This value is part of the technical\nidentifier of the entity, and as such it will appear in URLs, database\ntables, entity references, and similar. It is subject to restrictions\nregarding what characters are allowed.\nIf you want to use a different, more human readable string with fewer\nrestrictions on it in user interfaces, see the `title` field below.";
                    };
                    readonly etag: {
                        readonly type: "string";
                        readonly description: "An opaque string that changes for each update operation to any part of\nthe entity, including metadata.\nThis field can not be set by the user at creation time, and the server\nwill reject an attempt to do so. The field will be populated in read\noperations. The field can (optionally) be specified when performing\nupdate or delete operations, and the server will then reject the\noperation if it does not match the current stored value.";
                    };
                    readonly uid: {
                        readonly type: "string";
                        readonly description: "A globally unique ID for the entity.\nThis field can not be set by the user at creation time, and the server\nwill reject an attempt to do so. The field will be populated in read\noperations. The field can (optionally) be specified when performing\nupdate or delete operations, but the server is free to reject requests\nthat do so in such a way that it breaks semantics.";
                    };
                };
                readonly required: readonly ["name"];
                readonly description: "Metadata fields common to all versions/kinds of entity.";
                readonly additionalProperties: {};
            };
            readonly EntityRelation: {
                readonly type: "object";
                readonly properties: {
                    readonly targetRef: {
                        readonly type: "string";
                        readonly description: "The entity ref of the target of this relation.";
                    };
                    readonly type: {
                        readonly type: "string";
                        readonly description: "The type of the relation.";
                    };
                };
                readonly required: readonly ["targetRef", "type"];
                readonly description: "A relation of a specific type to another entity in the catalog.";
                readonly additionalProperties: false;
            };
            readonly Entity: {
                readonly type: "object";
                readonly properties: {
                    readonly relations: {
                        readonly type: "array";
                        readonly items: {
                            readonly $ref: "#/components/schemas/EntityRelation";
                        };
                        readonly description: "The relations that this entity has with other entities.";
                    };
                    readonly spec: {
                        readonly $ref: "#/components/schemas/JsonObject";
                    };
                    readonly metadata: {
                        readonly $ref: "#/components/schemas/EntityMeta";
                    };
                    readonly kind: {
                        readonly type: "string";
                        readonly description: "The high level entity type being described.";
                    };
                    readonly apiVersion: {
                        readonly type: "string";
                        readonly description: "The version of specification format for this particular entity that\nthis is written against.";
                    };
                };
                readonly required: readonly ["metadata", "kind", "apiVersion"];
                readonly description: "The parts of the format that's common to all versions/kinds of entity.";
            };
            readonly NullableEntity: {
                readonly type: "object";
                readonly properties: {
                    readonly relations: {
                        readonly type: "array";
                        readonly items: {
                            readonly $ref: "#/components/schemas/EntityRelation";
                        };
                        readonly description: "The relations that this entity has with other entities.";
                    };
                    readonly spec: {
                        readonly $ref: "#/components/schemas/JsonObject";
                    };
                    readonly metadata: {
                        readonly $ref: "#/components/schemas/EntityMeta";
                    };
                    readonly kind: {
                        readonly type: "string";
                        readonly description: "The high level entity type being described.";
                    };
                    readonly apiVersion: {
                        readonly type: "string";
                        readonly description: "The version of specification format for this particular entity that\nthis is written against.";
                    };
                };
                readonly required: readonly ["metadata", "kind", "apiVersion"];
                readonly description: "The parts of the format that's common to all versions/kinds of entity.";
                readonly nullable: true;
            };
            readonly EntityAncestryResponse: {
                readonly type: "object";
                readonly properties: {
                    readonly items: {
                        readonly type: "array";
                        readonly items: {
                            readonly type: "object";
                            readonly properties: {
                                readonly parentEntityRefs: {
                                    readonly items: {
                                        readonly type: "string";
                                    };
                                    readonly type: "array";
                                };
                                readonly entity: {
                                    readonly $ref: "#/components/schemas/Entity";
                                };
                            };
                            readonly required: readonly ["parentEntityRefs", "entity"];
                        };
                    };
                    readonly rootEntityRef: {
                        readonly type: "string";
                    };
                };
                readonly required: readonly ["items", "rootEntityRef"];
                readonly additionalProperties: false;
            };
            readonly EntitiesBatchResponse: {
                readonly type: "object";
                readonly properties: {
                    readonly items: {
                        readonly type: "array";
                        readonly items: {
                            readonly $ref: "#/components/schemas/NullableEntity";
                        };
                        readonly description: "The list of entities, in the same order as the refs in the request. Entries\nthat are null signify that no entity existed with that ref.";
                    };
                };
                readonly required: readonly ["items"];
                readonly additionalProperties: false;
            };
            readonly EntityFacet: {
                readonly type: "object";
                readonly properties: {
                    readonly value: {
                        readonly type: "string";
                    };
                    readonly count: {
                        readonly type: "number";
                    };
                };
                readonly required: readonly ["value", "count"];
                readonly additionalProperties: false;
            };
            readonly EntityFacetsResponse: {
                readonly type: "object";
                readonly properties: {
                    readonly facets: {
                        readonly type: "object";
                        readonly additionalProperties: {
                            readonly type: "array";
                            readonly items: {
                                readonly $ref: "#/components/schemas/EntityFacet";
                            };
                        };
                    };
                };
                readonly required: readonly ["facets"];
                readonly additionalProperties: false;
            };
            readonly Location: {
                readonly type: "object";
                readonly properties: {
                    readonly target: {
                        readonly type: "string";
                    };
                    readonly type: {
                        readonly type: "string";
                    };
                    readonly id: {
                        readonly type: "string";
                    };
                };
                readonly required: readonly ["target", "type", "id"];
                readonly description: "Entity location for a specific entity.";
                readonly additionalProperties: false;
            };
            readonly LocationSpec: {
                readonly type: "object";
                readonly properties: {
                    readonly target: {
                        readonly type: "string";
                    };
                    readonly type: {
                        readonly type: "string";
                    };
                };
                readonly required: readonly ["target", "type"];
                readonly description: "Holds the entity location information.";
                readonly additionalProperties: false;
            };
            readonly AnalyzeLocationExistingEntity: {
                readonly type: "object";
                readonly properties: {
                    readonly entity: {
                        readonly $ref: "#/components/schemas/Entity";
                    };
                    readonly isRegistered: {
                        readonly type: "boolean";
                    };
                    readonly location: {
                        readonly $ref: "#/components/schemas/LocationSpec";
                    };
                };
                readonly required: readonly ["entity", "isRegistered", "location"];
                readonly description: "If the folder pointed to already contained catalog info yaml files, they are\nread and emitted like this so that the frontend can inform the user that it\nlocated them and can make sure to register them as well if they weren't\nalready";
                readonly additionalProperties: false;
            };
            readonly RecursivePartialEntityRelation: {
                readonly type: "object";
                readonly properties: {
                    readonly targetRef: {
                        readonly type: "string";
                        readonly description: "The entity ref of the target of this relation.";
                    };
                    readonly type: {
                        readonly type: "string";
                        readonly description: "The type of the relation.";
                    };
                };
                readonly description: "A relation of a specific type to another entity in the catalog.";
                readonly additionalProperties: false;
            };
            readonly RecursivePartialEntityMeta: {
                readonly allOf: readonly [{
                    readonly $ref: "#/components/schemas/JsonObject";
                }, {
                    readonly type: "object";
                    readonly properties: {
                        readonly links: {
                            readonly type: "array";
                            readonly items: {
                                readonly $ref: "#/components/schemas/EntityLink";
                            };
                            readonly description: "A list of external hyperlinks related to the entity.";
                        };
                        readonly tags: {
                            readonly type: "array";
                            readonly items: {
                                readonly type: "string";
                            };
                            readonly description: "A list of single-valued strings, to for example classify catalog entities in\nvarious ways.";
                        };
                        readonly annotations: {
                            readonly $ref: "#/components/schemas/MapStringString";
                        };
                        readonly labels: {
                            readonly $ref: "#/components/schemas/MapStringString";
                        };
                        readonly description: {
                            readonly type: "string";
                            readonly description: "A short (typically relatively few words, on one line) description of the\nentity.";
                        };
                        readonly title: {
                            readonly type: "string";
                            readonly description: "A display name of the entity, to be presented in user interfaces instead\nof the `name` property above, when available.\nThis field is sometimes useful when the `name` is cumbersome or ends up\nbeing perceived as overly technical. The title generally does not have\nas stringent format requirements on it, so it may contain special\ncharacters and be more explanatory. Do keep it very short though, and\navoid situations where a title can be confused with the name of another\nentity, or where two entities share a title.\nNote that this is only for display purposes, and may be ignored by some\nparts of the code. Entity references still always make use of the `name`\nproperty, not the title.";
                        };
                        readonly namespace: {
                            readonly type: "string";
                            readonly description: "The namespace that the entity belongs to.";
                        };
                        readonly name: {
                            readonly type: "string";
                            readonly description: "The name of the entity.\nMust be unique within the catalog at any given point in time, for any\ngiven namespace + kind pair. This value is part of the technical\nidentifier of the entity, and as such it will appear in URLs, database\ntables, entity references, and similar. It is subject to restrictions\nregarding what characters are allowed.\nIf you want to use a different, more human readable string with fewer\nrestrictions on it in user interfaces, see the `title` field below.";
                        };
                        readonly etag: {
                            readonly type: "string";
                            readonly description: "An opaque string that changes for each update operation to any part of\nthe entity, including metadata.\nThis field can not be set by the user at creation time, and the server\nwill reject an attempt to do so. The field will be populated in read\noperations. The field can (optionally) be specified when performing\nupdate or delete operations, and the server will then reject the\noperation if it does not match the current stored value.";
                        };
                        readonly uid: {
                            readonly type: "string";
                            readonly description: "A globally unique ID for the entity.\nThis field can not be set by the user at creation time, and the server\nwill reject an attempt to do so. The field will be populated in read\noperations. The field can (optionally) be specified when performing\nupdate or delete operations, but the server is free to reject requests\nthat do so in such a way that it breaks semantics.";
                        };
                    };
                    readonly description: "Metadata fields common to all versions/kinds of entity.";
                }];
                readonly additionalProperties: false;
            };
            readonly RecursivePartialEntity: {
                readonly type: "object";
                readonly properties: {
                    readonly apiVersion: {
                        readonly type: "string";
                        readonly description: "The version of specification format for this particular entity that\nthis is written against.";
                    };
                    readonly kind: {
                        readonly type: "string";
                        readonly description: "The high level entity type being described.";
                    };
                    readonly metadata: {
                        readonly $ref: "#/components/schemas/RecursivePartialEntityMeta";
                    };
                    readonly spec: {
                        readonly $ref: "#/components/schemas/JsonObject";
                    };
                    readonly relations: {
                        readonly type: "array";
                        readonly items: {
                            readonly $ref: "#/components/schemas/RecursivePartialEntityRelation";
                        };
                        readonly description: "The relations that this entity has with other entities.";
                    };
                };
                readonly description: "Makes all keys of an entire hierarchy optional.";
                readonly additionalProperties: false;
            };
            readonly AnalyzeLocationEntityField: {
                readonly type: "object";
                readonly properties: {
                    readonly description: {
                        readonly type: "string";
                        readonly description: "A text to show to the user to inform about the choices made. Like, it could say\n\"Found a CODEOWNERS file that covers this target, so we suggest leaving this\nfield empty; which would currently make it owned by X\" where X is taken from the\ncodeowners file.";
                    };
                    readonly value: {
                        readonly type: "string";
                        readonly nullable: true;
                    };
                    readonly state: {
                        readonly type: "string";
                        readonly enum: readonly ["analysisSuggestedValue", "analysisSuggestedNoValue", "needsUserInput"];
                        readonly description: "The outcome of the analysis for this particular field";
                    };
                    readonly field: {
                        readonly type: "string";
                        readonly description: "e.g. \"spec.owner\"? The frontend needs to know how to \"inject\" the field into the\nentity again if the user wants to change it";
                    };
                };
                readonly required: readonly ["description", "value", "state", "field"];
                readonly additionalProperties: false;
            };
            readonly AnalyzeLocationGenerateEntity: {
                readonly type: "object";
                readonly properties: {
                    readonly fields: {
                        readonly type: "array";
                        readonly items: {
                            readonly $ref: "#/components/schemas/AnalyzeLocationEntityField";
                        };
                    };
                    readonly entity: {
                        readonly $ref: "#/components/schemas/RecursivePartialEntity";
                    };
                };
                readonly required: readonly ["fields", "entity"];
                readonly description: "This is some form of representation of what the analyzer could deduce.\nWe should probably have a chat about how this can best be conveyed to\nthe frontend. It'll probably contain a (possibly incomplete) entity, plus\nenough info for the frontend to know what form data to show to the user\nfor overriding/completing the info.";
                readonly additionalProperties: false;
            };
            readonly AnalyzeLocationResponse: {
                readonly type: "object";
                readonly properties: {
                    readonly generateEntities: {
                        readonly items: {
                            readonly $ref: "#/components/schemas/AnalyzeLocationGenerateEntity";
                        };
                        readonly type: "array";
                    };
                    readonly existingEntityFiles: {
                        readonly items: {
                            readonly $ref: "#/components/schemas/AnalyzeLocationExistingEntity";
                        };
                        readonly type: "array";
                    };
                };
                readonly required: readonly ["generateEntities", "existingEntityFiles"];
                readonly additionalProperties: false;
            };
            readonly LocationInput: {
                readonly type: "object";
                readonly properties: {
                    readonly type: {
                        readonly type: "string";
                    };
                    readonly target: {
                        readonly type: "string";
                    };
                };
                readonly required: readonly ["type", "target"];
                readonly additionalProperties: false;
            };
            readonly EntitiesQueryResponse: {
                readonly type: "object";
                readonly properties: {
                    readonly items: {
                        readonly type: "array";
                        readonly items: {
                            readonly $ref: "#/components/schemas/Entity";
                        };
                        readonly description: "The list of entities paginated by a specific filter.";
                    };
                    readonly totalItems: {
                        readonly type: "number";
                    };
                    readonly pageInfo: {
                        readonly type: "object";
                        readonly properties: {
                            readonly nextCursor: {
                                readonly type: "string";
                                readonly description: "The cursor for the next batch of entities.";
                            };
                            readonly prevCursor: {
                                readonly type: "string";
                                readonly description: "The cursor for the previous batch of entities.";
                            };
                        };
                    };
                };
                readonly required: readonly ["items", "totalItems", "pageInfo"];
                readonly additionalProperties: false;
            };
        };
        readonly securitySchemes: {
            readonly JWT: {
                readonly type: "http";
                readonly scheme: "bearer";
                readonly bearerFormat: "JWT";
            };
        };
    };
    readonly paths: {
        readonly '/refresh': {
            readonly post: {
                readonly operationId: "RefreshEntity";
                readonly description: "Refresh the entity related to entityRef.";
                readonly responses: {
                    readonly '200': {
                        readonly description: "Refreshed";
                    };
                    readonly '400': {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                    readonly default: {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                };
                readonly security: readonly [{}, {
                    readonly JWT: readonly [];
                }];
                readonly parameters: readonly [];
                readonly requestBody: {
                    readonly required: true;
                    readonly content: {
                        readonly 'application/json': {
                            readonly schema: {
                                readonly type: "object";
                                readonly properties: {
                                    readonly authorizationToken: {
                                        readonly type: "string";
                                    };
                                    readonly entityRef: {
                                        readonly type: "string";
                                        readonly description: "The reference to a single entity that should be refreshed";
                                    };
                                };
                                readonly required: readonly ["entityRef"];
                                readonly description: "Options for requesting a refresh of entities in the catalog.";
                                readonly additionalProperties: false;
                            };
                        };
                    };
                };
            };
        };
        readonly '/entities': {
            readonly get: {
                readonly operationId: "GetEntities";
                readonly description: "Get all entities matching a given filter.";
                readonly responses: {
                    readonly '200': {
                        readonly description: "";
                        readonly content: {
                            readonly 'application/json': {
                                readonly schema: {
                                    readonly type: "array";
                                    readonly items: {
                                        readonly $ref: "#/components/schemas/Entity";
                                    };
                                };
                            };
                        };
                    };
                    readonly '400': {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                    readonly default: {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                };
                readonly security: readonly [{}, {
                    readonly JWT: readonly [];
                }];
                readonly parameters: readonly [{
                    readonly $ref: "#/components/parameters/fields";
                }, {
                    readonly $ref: "#/components/parameters/limit";
                }, {
                    readonly $ref: "#/components/parameters/filter";
                }, {
                    readonly $ref: "#/components/parameters/offset";
                }, {
                    readonly $ref: "#/components/parameters/after";
                }, {
                    readonly name: "order";
                    readonly in: "query";
                    readonly allowReserved: true;
                    readonly required: false;
                    readonly schema: {
                        readonly type: "array";
                        readonly items: {
                            readonly type: "string";
                        };
                    };
                }];
            };
        };
        readonly '/entities/by-uid/{uid}': {
            readonly get: {
                readonly operationId: "GetEntityByUid";
                readonly description: "Get a single entity by the UID.";
                readonly responses: {
                    readonly '200': {
                        readonly description: "Ok";
                        readonly content: {
                            readonly 'application/json': {
                                readonly schema: {
                                    readonly $ref: "#/components/schemas/Entity";
                                };
                            };
                        };
                    };
                    readonly '400': {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                    readonly default: {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                };
                readonly security: readonly [{}, {
                    readonly JWT: readonly [];
                }];
                readonly parameters: readonly [{
                    readonly $ref: "#/components/parameters/uid";
                }];
            };
            readonly delete: {
                readonly operationId: "DeleteEntityByUid";
                readonly description: "Delete a single entity by UID.";
                readonly responses: {
                    readonly '204': {
                        readonly description: "Deleted successfully.";
                    };
                    readonly '400': {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                    readonly default: {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                };
                readonly security: readonly [{}, {
                    readonly JWT: readonly [];
                }];
                readonly parameters: readonly [{
                    readonly $ref: "#/components/parameters/uid";
                }];
            };
        };
        readonly '/entities/by-name/{kind}/{namespace}/{name}': {
            readonly get: {
                readonly operationId: "GetEntityByName";
                readonly description: "Get an entity by an entity ref.";
                readonly responses: {
                    readonly '200': {
                        readonly description: "Ok";
                        readonly content: {
                            readonly 'application/json': {
                                readonly schema: {
                                    readonly $ref: "#/components/schemas/Entity";
                                };
                            };
                        };
                    };
                    readonly '400': {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                    readonly default: {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                };
                readonly security: readonly [{}, {
                    readonly JWT: readonly [];
                }];
                readonly parameters: readonly [{
                    readonly $ref: "#/components/parameters/kind";
                }, {
                    readonly $ref: "#/components/parameters/namespace";
                }, {
                    readonly $ref: "#/components/parameters/name";
                }];
            };
        };
        readonly '/entities/by-name/{kind}/{namespace}/{name}/ancestry': {
            readonly get: {
                readonly operationId: "GetEntityAncestryByName";
                readonly description: "Get an entity's ancestry by entity ref.";
                readonly responses: {
                    readonly '200': {
                        readonly description: "Ok";
                        readonly content: {
                            readonly 'application/json': {
                                readonly schema: {
                                    readonly $ref: "#/components/schemas/EntityAncestryResponse";
                                };
                            };
                        };
                    };
                    readonly '400': {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                    readonly default: {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                };
                readonly security: readonly [{}, {
                    readonly JWT: readonly [];
                }];
                readonly parameters: readonly [{
                    readonly $ref: "#/components/parameters/kind";
                }, {
                    readonly $ref: "#/components/parameters/namespace";
                }, {
                    readonly $ref: "#/components/parameters/name";
                }];
            };
        };
        readonly '/entities/by-refs': {
            readonly post: {
                readonly operationId: "GetEntitiesByRefs";
                readonly description: "Get a batch set of entities given an array of entityRefs.";
                readonly responses: {
                    readonly '200': {
                        readonly description: "Ok";
                        readonly content: {
                            readonly 'application/json': {
                                readonly schema: {
                                    readonly $ref: "#/components/schemas/EntitiesBatchResponse";
                                };
                            };
                        };
                    };
                    readonly '400': {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                    readonly default: {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                };
                readonly security: readonly [{}, {
                    readonly JWT: readonly [];
                }];
                readonly requestBody: {
                    readonly required: false;
                    readonly content: {
                        readonly 'application/json': {
                            readonly schema: {
                                readonly type: "object";
                                readonly required: readonly ["entityRefs"];
                                readonly properties: {
                                    readonly entityRefs: {
                                        readonly type: "array";
                                        readonly items: {
                                            readonly type: "string";
                                        };
                                    };
                                    readonly fields: {
                                        readonly type: "array";
                                        readonly items: {
                                            readonly type: "string";
                                        };
                                    };
                                };
                            };
                            readonly examples: {
                                readonly 'Fetch Backstage entities': {
                                    readonly value: {
                                        readonly entityRefs: readonly ["component:default/backstage", "api:default/backstage"];
                                    };
                                };
                                readonly 'Fetch annotations for backstage entity': {
                                    readonly value: {
                                        readonly entityRefs: readonly ["component:default/backstage"];
                                        readonly fields: readonly ["metadata.annotations"];
                                    };
                                };
                            };
                        };
                    };
                };
                readonly parameters: readonly [{
                    readonly $ref: "#/components/parameters/filter";
                }];
            };
        };
        readonly '/entities/by-query': {
            readonly get: {
                readonly operationId: "GetEntitiesByQuery";
                readonly description: "Search for entities by a given query.";
                readonly responses: {
                    readonly '200': {
                        readonly description: "Ok";
                        readonly content: {
                            readonly 'application/json': {
                                readonly schema: {
                                    readonly $ref: "#/components/schemas/EntitiesQueryResponse";
                                };
                            };
                        };
                    };
                    readonly '400': {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                    readonly default: {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                };
                readonly security: readonly [{}, {
                    readonly JWT: readonly [];
                }];
                readonly parameters: readonly [{
                    readonly $ref: "#/components/parameters/fields";
                }, {
                    readonly $ref: "#/components/parameters/limit";
                }, {
                    readonly $ref: "#/components/parameters/orderField";
                }, {
                    readonly $ref: "#/components/parameters/cursor";
                }, {
                    readonly $ref: "#/components/parameters/filter";
                }, {
                    readonly name: "fullTextFilterTerm";
                    readonly in: "query";
                    readonly description: "Text search term.";
                    readonly required: false;
                    readonly allowReserved: true;
                    readonly schema: {
                        readonly type: "string";
                    };
                }, {
                    readonly name: "fullTextFilterFields";
                    readonly in: "query";
                    readonly description: "A comma separated list of fields to sort returned results by.";
                    readonly required: false;
                    readonly allowReserved: true;
                    readonly schema: {
                        readonly type: "array";
                        readonly items: {
                            readonly type: "string";
                        };
                    };
                    readonly explode: false;
                    readonly style: "form";
                }];
            };
        };
        readonly '/entity-facets': {
            readonly get: {
                readonly operationId: "GetEntityFacets";
                readonly description: "Get all entity facets that match the given filters.";
                readonly responses: {
                    readonly '200': {
                        readonly description: "Ok";
                        readonly content: {
                            readonly 'application/json': {
                                readonly schema: {
                                    readonly $ref: "#/components/schemas/EntityFacetsResponse";
                                };
                            };
                        };
                    };
                    readonly '400': {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                    readonly default: {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                };
                readonly security: readonly [{}, {
                    readonly JWT: readonly [];
                }];
                readonly parameters: readonly [{
                    readonly in: "query";
                    readonly name: "facet";
                    readonly required: true;
                    readonly allowReserved: true;
                    readonly schema: {
                        readonly type: "array";
                        readonly items: {
                            readonly type: "string";
                        };
                    };
                    readonly examples: {
                        readonly 'Entities by kind': {
                            readonly value: readonly ["kind"];
                        };
                        readonly 'Entities by spec type': {
                            readonly value: readonly ["spec.type"];
                        };
                    };
                }, {
                    readonly $ref: "#/components/parameters/filter";
                }];
            };
        };
        readonly '/locations': {
            readonly post: {
                readonly operationId: "CreateLocation";
                readonly description: "Create a location for a given target.";
                readonly responses: {
                    readonly '201': {
                        readonly description: "Created";
                        readonly content: {
                            readonly 'application/json': {
                                readonly schema: {
                                    readonly type: "object";
                                    readonly properties: {
                                        readonly exists: {
                                            readonly type: "boolean";
                                        };
                                        readonly entities: {
                                            readonly items: {
                                                readonly $ref: "#/components/schemas/Entity";
                                            };
                                            readonly type: "array";
                                        };
                                        readonly location: {
                                            readonly $ref: "#/components/schemas/Location";
                                        };
                                    };
                                    readonly required: readonly ["entities", "location"];
                                };
                            };
                        };
                    };
                    readonly '400': {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                    readonly default: {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                };
                readonly security: readonly [{}, {
                    readonly JWT: readonly [];
                }];
                readonly parameters: readonly [{
                    readonly in: "query";
                    readonly name: "dryRun";
                    readonly required: false;
                    readonly allowReserved: true;
                    readonly schema: {
                        readonly type: "string";
                    };
                }];
                readonly requestBody: {
                    readonly required: true;
                    readonly content: {
                        readonly 'application/json': {
                            readonly schema: {
                                readonly type: "object";
                                readonly properties: {
                                    readonly target: {
                                        readonly type: "string";
                                    };
                                    readonly type: {
                                        readonly type: "string";
                                    };
                                };
                                readonly required: readonly ["target", "type"];
                            };
                        };
                    };
                };
            };
            readonly get: {
                readonly operationId: "GetLocations";
                readonly description: "Get all locations";
                readonly responses: {
                    readonly '200': {
                        readonly description: "Ok";
                        readonly content: {
                            readonly 'application/json': {
                                readonly schema: {
                                    readonly type: "array";
                                    readonly items: {
                                        readonly type: "object";
                                        readonly properties: {
                                            readonly data: {
                                                readonly $ref: "#/components/schemas/Location";
                                            };
                                        };
                                        readonly required: readonly ["data"];
                                    };
                                };
                            };
                        };
                    };
                    readonly default: {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                };
                readonly security: readonly [{}, {
                    readonly JWT: readonly [];
                }];
                readonly parameters: readonly [];
            };
        };
        readonly '/locations/{id}': {
            readonly get: {
                readonly operationId: "GetLocation";
                readonly description: "Get a location by id.";
                readonly responses: {
                    readonly '200': {
                        readonly description: "Ok";
                        readonly content: {
                            readonly 'application/json': {
                                readonly schema: {
                                    readonly $ref: "#/components/schemas/Location";
                                };
                            };
                        };
                    };
                    readonly default: {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                };
                readonly security: readonly [{}, {
                    readonly JWT: readonly [];
                }];
                readonly parameters: readonly [{
                    readonly in: "path";
                    readonly name: "id";
                    readonly required: true;
                    readonly allowReserved: true;
                    readonly schema: {
                        readonly type: "string";
                    };
                }];
            };
            readonly delete: {
                readonly operationId: "DeleteLocation";
                readonly description: "Delete a location by id.";
                readonly responses: {
                    readonly '204': {
                        readonly description: "No content";
                    };
                    readonly '400': {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                    readonly default: {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                };
                readonly security: readonly [{}, {
                    readonly JWT: readonly [];
                }];
                readonly parameters: readonly [{
                    readonly in: "path";
                    readonly name: "id";
                    readonly required: true;
                    readonly allowReserved: true;
                    readonly schema: {
                        readonly type: "string";
                    };
                }];
            };
        };
        readonly '/locations/by-entity/{kind}/{namespace}/{name}': {
            readonly get: {
                readonly operationId: "getLocationByEntity";
                readonly description: "Get a location for entity.";
                readonly responses: {
                    readonly '200': {
                        readonly description: "Ok";
                        readonly content: {
                            readonly 'application/json': {
                                readonly schema: {
                                    readonly $ref: "#/components/schemas/Location";
                                };
                            };
                        };
                    };
                    readonly default: {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                };
                readonly security: readonly [{}, {
                    readonly JWT: readonly [];
                }];
                readonly parameters: readonly [{
                    readonly in: "path";
                    readonly name: "kind";
                    readonly required: true;
                    readonly allowReserved: true;
                    readonly schema: {
                        readonly type: "string";
                    };
                }, {
                    readonly in: "path";
                    readonly name: "namespace";
                    readonly required: true;
                    readonly allowReserved: true;
                    readonly schema: {
                        readonly type: "string";
                    };
                }, {
                    readonly in: "path";
                    readonly name: "name";
                    readonly required: true;
                    readonly allowReserved: true;
                    readonly schema: {
                        readonly type: "string";
                    };
                }];
            };
        };
        readonly '/analyze-location': {
            readonly post: {
                readonly operationId: "AnalyzeLocation";
                readonly description: "Validate a given location.";
                readonly responses: {
                    readonly '200': {
                        readonly description: "Ok";
                        readonly content: {
                            readonly 'application/json': {
                                readonly schema: {
                                    readonly $ref: "#/components/schemas/AnalyzeLocationResponse";
                                };
                            };
                        };
                    };
                    readonly '400': {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                    readonly default: {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                };
                readonly security: readonly [{}, {
                    readonly JWT: readonly [];
                }];
                readonly parameters: readonly [];
                readonly requestBody: {
                    readonly required: true;
                    readonly content: {
                        readonly 'application/json': {
                            readonly schema: {
                                readonly type: "object";
                                readonly properties: {
                                    readonly catalogFileName: {
                                        readonly type: "string";
                                    };
                                    readonly location: {
                                        readonly $ref: "#/components/schemas/LocationInput";
                                    };
                                };
                                readonly required: readonly ["location"];
                            };
                        };
                    };
                };
            };
        };
        readonly '/validate-entity': {
            readonly post: {
                readonly operationId: "ValidateEntity";
                readonly description: "Validate that a passed in entity has no errors in schema.";
                readonly responses: {
                    readonly '200': {
                        readonly description: "Ok";
                    };
                    readonly '400': {
                        readonly description: "Validation errors.";
                        readonly content: {
                            readonly 'application/json; charset=utf-8': {
                                readonly schema: {
                                    readonly type: "object";
                                    readonly properties: {
                                        readonly errors: {
                                            readonly type: "array";
                                            readonly items: {
                                                readonly type: "object";
                                                readonly properties: {
                                                    readonly name: {
                                                        readonly type: "string";
                                                    };
                                                    readonly message: {
                                                        readonly type: "string";
                                                    };
                                                };
                                                readonly required: readonly ["name", "message"];
                                                readonly additionalProperties: {};
                                            };
                                        };
                                    };
                                    readonly required: readonly ["errors"];
                                };
                            };
                        };
                    };
                };
                readonly security: readonly [{}, {
                    readonly JWT: readonly [];
                }];
                readonly parameters: readonly [];
                readonly requestBody: {
                    readonly required: true;
                    readonly content: {
                        readonly 'application/json': {
                            readonly schema: {
                                readonly type: "object";
                                readonly properties: {
                                    readonly location: {
                                        readonly type: "string";
                                    };
                                    readonly entity: {
                                        readonly type: "object";
                                        readonly additionalProperties: {};
                                    };
                                };
                                readonly required: readonly ["location", "entity"];
                            };
                        };
                    };
                };
            };
        };
    };
};
export declare const createOpenApiRouter: (options?: Parameters<typeof createValidatedOpenApiRouter>['1']) => Promise<import("@backstage/backend-openapi-utils").ApiRouter<{
    readonly openapi: "3.0.3";
    readonly info: {
        readonly title: "catalog";
        readonly version: "1";
        readonly description: "The Backstage backend plugin that provides the Backstage catalog";
        readonly license: {
            readonly name: "Apache-2.0";
            readonly url: "http://www.apache.org/licenses/LICENSE-2.0.html";
        };
        readonly contact: {};
    };
    readonly servers: readonly [{
        readonly url: "/";
    }];
    readonly components: {
        readonly examples: {};
        readonly headers: {};
        readonly parameters: {
            readonly kind: {
                readonly name: "kind";
                readonly in: "path";
                readonly required: true;
                readonly allowReserved: true;
                readonly schema: {
                    readonly type: "string";
                };
            };
            readonly namespace: {
                readonly name: "namespace";
                readonly in: "path";
                readonly required: true;
                readonly allowReserved: true;
                readonly schema: {
                    readonly type: "string";
                };
            };
            readonly name: {
                readonly name: "name";
                readonly in: "path";
                readonly required: true;
                readonly allowReserved: true;
                readonly schema: {
                    readonly type: "string";
                };
            };
            readonly uid: {
                readonly name: "uid";
                readonly in: "path";
                readonly required: true;
                readonly allowReserved: true;
                readonly schema: {
                    readonly type: "string";
                };
            };
            readonly cursor: {
                readonly name: "cursor";
                readonly in: "query";
                readonly description: "Cursor to a set page of results.";
                readonly required: false;
                readonly allowReserved: true;
                readonly schema: {
                    readonly type: "string";
                    readonly minLength: 1;
                };
            };
            readonly after: {
                readonly name: "after";
                readonly in: "query";
                readonly description: "Pointer to the previous page of results.";
                readonly required: false;
                readonly allowReserved: true;
                readonly schema: {
                    readonly type: "string";
                    readonly minLength: 1;
                };
            };
            readonly fields: {
                readonly name: "fields";
                readonly in: "query";
                readonly description: "Restrict to just these fields in the response.";
                readonly required: false;
                readonly allowReserved: true;
                readonly explode: false;
                readonly schema: {
                    readonly type: "array";
                    readonly items: {
                        readonly type: "string";
                    };
                };
                readonly examples: {
                    readonly 'Get name and the entire relations collection': {
                        readonly value: readonly ["metadata.name", "relations"];
                    };
                    readonly 'Get kind, name and namespace': {
                        readonly value: readonly ["kind", "metadata.name", "metadata.namespace"];
                    };
                };
            };
            readonly filter: {
                readonly name: "filter";
                readonly in: "query";
                readonly description: "Filter for just the entities defined by this filter.";
                readonly required: false;
                readonly allowReserved: true;
                readonly schema: {
                    readonly type: "array";
                    readonly items: {
                        readonly type: "string";
                    };
                };
                readonly examples: {
                    readonly 'Get groups': {
                        readonly value: readonly ["kind=group"];
                    };
                    readonly 'Get orphaned components': {
                        readonly value: readonly ["kind=component,metadata.annotations.backstage.io/orphan=true"];
                    };
                };
            };
            readonly offset: {
                readonly name: "offset";
                readonly in: "query";
                readonly description: "Number of records to skip in the query page.";
                readonly required: false;
                readonly allowReserved: true;
                readonly schema: {
                    readonly type: "integer";
                    readonly minimum: 0;
                };
            };
            readonly limit: {
                readonly name: "limit";
                readonly in: "query";
                readonly description: "Number of records to return in the response.";
                readonly required: false;
                readonly allowReserved: true;
                readonly schema: {
                    readonly type: "integer";
                    readonly minimum: 0;
                };
            };
            readonly orderField: {
                readonly name: "orderField";
                readonly in: "query";
                readonly description: "The fields to sort returned results by.";
                readonly required: false;
                readonly allowReserved: true;
                readonly schema: {
                    readonly type: "array";
                    readonly items: {
                        readonly type: "string";
                        readonly description: "A two-item tuple of [field, order].";
                    };
                };
                readonly explode: true;
                readonly style: "form";
                readonly examples: {
                    readonly 'Order ascending by name': {
                        readonly value: readonly ["metadata.name,asc"];
                    };
                    readonly 'Order descending by owner': {
                        readonly value: readonly ["spec.owner,desc"];
                    };
                };
            };
        };
        readonly requestBodies: {};
        readonly responses: {
            readonly ErrorResponse: {
                readonly description: "An error response from the backend.";
                readonly content: {
                    readonly 'application/json': {
                        readonly schema: {
                            readonly $ref: "#/components/schemas/Error";
                        };
                    };
                };
            };
        };
        readonly schemas: {
            readonly Error: {
                readonly type: "object";
                readonly properties: {
                    readonly error: {
                        readonly type: "object";
                        readonly properties: {
                            readonly name: {
                                readonly type: "string";
                            };
                            readonly message: {
                                readonly type: "string";
                            };
                            readonly stack: {
                                readonly type: "string";
                            };
                            readonly code: {
                                readonly type: "string";
                            };
                        };
                        readonly required: readonly ["name", "message"];
                    };
                    readonly request: {
                        readonly type: "object";
                        readonly properties: {
                            readonly method: {
                                readonly type: "string";
                            };
                            readonly url: {
                                readonly type: "string";
                            };
                        };
                        readonly required: readonly ["method", "url"];
                    };
                    readonly response: {
                        readonly type: "object";
                        readonly properties: {
                            readonly statusCode: {
                                readonly type: "number";
                            };
                        };
                        readonly required: readonly ["statusCode"];
                    };
                };
                readonly required: readonly ["error", "response"];
                readonly additionalProperties: {};
            };
            readonly JsonObject: {
                readonly type: "object";
                readonly properties: {};
                readonly description: "A type representing all allowed JSON object values.";
                readonly additionalProperties: {};
            };
            readonly MapStringString: {
                readonly type: "object";
                readonly properties: {};
                readonly additionalProperties: {
                    readonly type: "string";
                };
                readonly description: "Construct a type with a set of properties K of type T";
            };
            readonly EntityLink: {
                readonly type: "object";
                readonly properties: {
                    readonly type: {
                        readonly type: "string";
                        readonly description: "An optional value to categorize links into specific groups";
                    };
                    readonly icon: {
                        readonly type: "string";
                        readonly description: "An optional semantic key that represents a visual icon.";
                    };
                    readonly title: {
                        readonly type: "string";
                        readonly description: "An optional descriptive title for the link.";
                    };
                    readonly url: {
                        readonly type: "string";
                        readonly description: "The url to the external site, document, etc.";
                    };
                };
                readonly required: readonly ["url"];
                readonly description: "A link to external information that is related to the entity.";
                readonly additionalProperties: false;
            };
            readonly EntityMeta: {
                readonly type: "object";
                readonly properties: {
                    readonly links: {
                        readonly type: "array";
                        readonly items: {
                            readonly $ref: "#/components/schemas/EntityLink";
                        };
                        readonly description: "A list of external hyperlinks related to the entity.";
                    };
                    readonly tags: {
                        readonly type: "array";
                        readonly items: {
                            readonly type: "string";
                        };
                        readonly description: "A list of single-valued strings, to for example classify catalog entities in\nvarious ways.";
                    };
                    readonly annotations: {
                        readonly $ref: "#/components/schemas/MapStringString";
                    };
                    readonly labels: {
                        readonly $ref: "#/components/schemas/MapStringString";
                    };
                    readonly description: {
                        readonly type: "string";
                        readonly description: "A short (typically relatively few words, on one line) description of the\nentity.";
                    };
                    readonly title: {
                        readonly type: "string";
                        readonly description: "A display name of the entity, to be presented in user interfaces instead\nof the `name` property above, when available.\nThis field is sometimes useful when the `name` is cumbersome or ends up\nbeing perceived as overly technical. The title generally does not have\nas stringent format requirements on it, so it may contain special\ncharacters and be more explanatory. Do keep it very short though, and\navoid situations where a title can be confused with the name of another\nentity, or where two entities share a title.\nNote that this is only for display purposes, and may be ignored by some\nparts of the code. Entity references still always make use of the `name`\nproperty, not the title.";
                    };
                    readonly namespace: {
                        readonly type: "string";
                        readonly description: "The namespace that the entity belongs to.";
                    };
                    readonly name: {
                        readonly type: "string";
                        readonly description: "The name of the entity.\nMust be unique within the catalog at any given point in time, for any\ngiven namespace + kind pair. This value is part of the technical\nidentifier of the entity, and as such it will appear in URLs, database\ntables, entity references, and similar. It is subject to restrictions\nregarding what characters are allowed.\nIf you want to use a different, more human readable string with fewer\nrestrictions on it in user interfaces, see the `title` field below.";
                    };
                    readonly etag: {
                        readonly type: "string";
                        readonly description: "An opaque string that changes for each update operation to any part of\nthe entity, including metadata.\nThis field can not be set by the user at creation time, and the server\nwill reject an attempt to do so. The field will be populated in read\noperations. The field can (optionally) be specified when performing\nupdate or delete operations, and the server will then reject the\noperation if it does not match the current stored value.";
                    };
                    readonly uid: {
                        readonly type: "string";
                        readonly description: "A globally unique ID for the entity.\nThis field can not be set by the user at creation time, and the server\nwill reject an attempt to do so. The field will be populated in read\noperations. The field can (optionally) be specified when performing\nupdate or delete operations, but the server is free to reject requests\nthat do so in such a way that it breaks semantics.";
                    };
                };
                readonly required: readonly ["name"];
                readonly description: "Metadata fields common to all versions/kinds of entity.";
                readonly additionalProperties: {};
            };
            readonly EntityRelation: {
                readonly type: "object";
                readonly properties: {
                    readonly targetRef: {
                        readonly type: "string";
                        readonly description: "The entity ref of the target of this relation.";
                    };
                    readonly type: {
                        readonly type: "string";
                        readonly description: "The type of the relation.";
                    };
                };
                readonly required: readonly ["targetRef", "type"];
                readonly description: "A relation of a specific type to another entity in the catalog.";
                readonly additionalProperties: false;
            };
            readonly Entity: {
                readonly type: "object";
                readonly properties: {
                    readonly relations: {
                        readonly type: "array";
                        readonly items: {
                            readonly $ref: "#/components/schemas/EntityRelation";
                        };
                        readonly description: "The relations that this entity has with other entities.";
                    };
                    readonly spec: {
                        readonly $ref: "#/components/schemas/JsonObject";
                    };
                    readonly metadata: {
                        readonly $ref: "#/components/schemas/EntityMeta";
                    };
                    readonly kind: {
                        readonly type: "string";
                        readonly description: "The high level entity type being described.";
                    };
                    readonly apiVersion: {
                        readonly type: "string";
                        readonly description: "The version of specification format for this particular entity that\nthis is written against.";
                    };
                };
                readonly required: readonly ["metadata", "kind", "apiVersion"];
                readonly description: "The parts of the format that's common to all versions/kinds of entity.";
            };
            readonly NullableEntity: {
                readonly type: "object";
                readonly properties: {
                    readonly relations: {
                        readonly type: "array";
                        readonly items: {
                            readonly $ref: "#/components/schemas/EntityRelation";
                        };
                        readonly description: "The relations that this entity has with other entities.";
                    };
                    readonly spec: {
                        readonly $ref: "#/components/schemas/JsonObject";
                    };
                    readonly metadata: {
                        readonly $ref: "#/components/schemas/EntityMeta";
                    };
                    readonly kind: {
                        readonly type: "string";
                        readonly description: "The high level entity type being described.";
                    };
                    readonly apiVersion: {
                        readonly type: "string";
                        readonly description: "The version of specification format for this particular entity that\nthis is written against.";
                    };
                };
                readonly required: readonly ["metadata", "kind", "apiVersion"];
                readonly description: "The parts of the format that's common to all versions/kinds of entity.";
                readonly nullable: true;
            };
            readonly EntityAncestryResponse: {
                readonly type: "object";
                readonly properties: {
                    readonly items: {
                        readonly type: "array";
                        readonly items: {
                            readonly type: "object";
                            readonly properties: {
                                readonly parentEntityRefs: {
                                    readonly items: {
                                        readonly type: "string";
                                    };
                                    readonly type: "array";
                                };
                                readonly entity: {
                                    readonly $ref: "#/components/schemas/Entity";
                                };
                            };
                            readonly required: readonly ["parentEntityRefs", "entity"];
                        };
                    };
                    readonly rootEntityRef: {
                        readonly type: "string";
                    };
                };
                readonly required: readonly ["items", "rootEntityRef"];
                readonly additionalProperties: false;
            };
            readonly EntitiesBatchResponse: {
                readonly type: "object";
                readonly properties: {
                    readonly items: {
                        readonly type: "array";
                        readonly items: {
                            readonly $ref: "#/components/schemas/NullableEntity";
                        };
                        readonly description: "The list of entities, in the same order as the refs in the request. Entries\nthat are null signify that no entity existed with that ref.";
                    };
                };
                readonly required: readonly ["items"];
                readonly additionalProperties: false;
            };
            readonly EntityFacet: {
                readonly type: "object";
                readonly properties: {
                    readonly value: {
                        readonly type: "string";
                    };
                    readonly count: {
                        readonly type: "number";
                    };
                };
                readonly required: readonly ["value", "count"];
                readonly additionalProperties: false;
            };
            readonly EntityFacetsResponse: {
                readonly type: "object";
                readonly properties: {
                    readonly facets: {
                        readonly type: "object";
                        readonly additionalProperties: {
                            readonly type: "array";
                            readonly items: {
                                readonly $ref: "#/components/schemas/EntityFacet";
                            };
                        };
                    };
                };
                readonly required: readonly ["facets"];
                readonly additionalProperties: false;
            };
            readonly Location: {
                readonly type: "object";
                readonly properties: {
                    readonly target: {
                        readonly type: "string";
                    };
                    readonly type: {
                        readonly type: "string";
                    };
                    readonly id: {
                        readonly type: "string";
                    };
                };
                readonly required: readonly ["target", "type", "id"];
                readonly description: "Entity location for a specific entity.";
                readonly additionalProperties: false;
            };
            readonly LocationSpec: {
                readonly type: "object";
                readonly properties: {
                    readonly target: {
                        readonly type: "string";
                    };
                    readonly type: {
                        readonly type: "string";
                    };
                };
                readonly required: readonly ["target", "type"];
                readonly description: "Holds the entity location information.";
                readonly additionalProperties: false;
            };
            readonly AnalyzeLocationExistingEntity: {
                readonly type: "object";
                readonly properties: {
                    readonly entity: {
                        readonly $ref: "#/components/schemas/Entity";
                    };
                    readonly isRegistered: {
                        readonly type: "boolean";
                    };
                    readonly location: {
                        readonly $ref: "#/components/schemas/LocationSpec";
                    };
                };
                readonly required: readonly ["entity", "isRegistered", "location"];
                readonly description: "If the folder pointed to already contained catalog info yaml files, they are\nread and emitted like this so that the frontend can inform the user that it\nlocated them and can make sure to register them as well if they weren't\nalready";
                readonly additionalProperties: false;
            };
            readonly RecursivePartialEntityRelation: {
                readonly type: "object";
                readonly properties: {
                    readonly targetRef: {
                        readonly type: "string";
                        readonly description: "The entity ref of the target of this relation.";
                    };
                    readonly type: {
                        readonly type: "string";
                        readonly description: "The type of the relation.";
                    };
                };
                readonly description: "A relation of a specific type to another entity in the catalog.";
                readonly additionalProperties: false;
            };
            readonly RecursivePartialEntityMeta: {
                readonly allOf: readonly [{
                    readonly $ref: "#/components/schemas/JsonObject";
                }, {
                    readonly type: "object";
                    readonly properties: {
                        readonly links: {
                            readonly type: "array";
                            readonly items: {
                                readonly $ref: "#/components/schemas/EntityLink";
                            };
                            readonly description: "A list of external hyperlinks related to the entity.";
                        };
                        readonly tags: {
                            readonly type: "array";
                            readonly items: {
                                readonly type: "string";
                            };
                            readonly description: "A list of single-valued strings, to for example classify catalog entities in\nvarious ways.";
                        };
                        readonly annotations: {
                            readonly $ref: "#/components/schemas/MapStringString";
                        };
                        readonly labels: {
                            readonly $ref: "#/components/schemas/MapStringString";
                        };
                        readonly description: {
                            readonly type: "string";
                            readonly description: "A short (typically relatively few words, on one line) description of the\nentity.";
                        };
                        readonly title: {
                            readonly type: "string";
                            readonly description: "A display name of the entity, to be presented in user interfaces instead\nof the `name` property above, when available.\nThis field is sometimes useful when the `name` is cumbersome or ends up\nbeing perceived as overly technical. The title generally does not have\nas stringent format requirements on it, so it may contain special\ncharacters and be more explanatory. Do keep it very short though, and\navoid situations where a title can be confused with the name of another\nentity, or where two entities share a title.\nNote that this is only for display purposes, and may be ignored by some\nparts of the code. Entity references still always make use of the `name`\nproperty, not the title.";
                        };
                        readonly namespace: {
                            readonly type: "string";
                            readonly description: "The namespace that the entity belongs to.";
                        };
                        readonly name: {
                            readonly type: "string";
                            readonly description: "The name of the entity.\nMust be unique within the catalog at any given point in time, for any\ngiven namespace + kind pair. This value is part of the technical\nidentifier of the entity, and as such it will appear in URLs, database\ntables, entity references, and similar. It is subject to restrictions\nregarding what characters are allowed.\nIf you want to use a different, more human readable string with fewer\nrestrictions on it in user interfaces, see the `title` field below.";
                        };
                        readonly etag: {
                            readonly type: "string";
                            readonly description: "An opaque string that changes for each update operation to any part of\nthe entity, including metadata.\nThis field can not be set by the user at creation time, and the server\nwill reject an attempt to do so. The field will be populated in read\noperations. The field can (optionally) be specified when performing\nupdate or delete operations, and the server will then reject the\noperation if it does not match the current stored value.";
                        };
                        readonly uid: {
                            readonly type: "string";
                            readonly description: "A globally unique ID for the entity.\nThis field can not be set by the user at creation time, and the server\nwill reject an attempt to do so. The field will be populated in read\noperations. The field can (optionally) be specified when performing\nupdate or delete operations, but the server is free to reject requests\nthat do so in such a way that it breaks semantics.";
                        };
                    };
                    readonly description: "Metadata fields common to all versions/kinds of entity.";
                }];
                readonly additionalProperties: false;
            };
            readonly RecursivePartialEntity: {
                readonly type: "object";
                readonly properties: {
                    readonly apiVersion: {
                        readonly type: "string";
                        readonly description: "The version of specification format for this particular entity that\nthis is written against.";
                    };
                    readonly kind: {
                        readonly type: "string";
                        readonly description: "The high level entity type being described.";
                    };
                    readonly metadata: {
                        readonly $ref: "#/components/schemas/RecursivePartialEntityMeta";
                    };
                    readonly spec: {
                        readonly $ref: "#/components/schemas/JsonObject";
                    };
                    readonly relations: {
                        readonly type: "array";
                        readonly items: {
                            readonly $ref: "#/components/schemas/RecursivePartialEntityRelation";
                        };
                        readonly description: "The relations that this entity has with other entities.";
                    };
                };
                readonly description: "Makes all keys of an entire hierarchy optional.";
                readonly additionalProperties: false;
            };
            readonly AnalyzeLocationEntityField: {
                readonly type: "object";
                readonly properties: {
                    readonly description: {
                        readonly type: "string";
                        readonly description: "A text to show to the user to inform about the choices made. Like, it could say\n\"Found a CODEOWNERS file that covers this target, so we suggest leaving this\nfield empty; which would currently make it owned by X\" where X is taken from the\ncodeowners file.";
                    };
                    readonly value: {
                        readonly type: "string";
                        readonly nullable: true;
                    };
                    readonly state: {
                        readonly type: "string";
                        readonly enum: readonly ["analysisSuggestedValue", "analysisSuggestedNoValue", "needsUserInput"];
                        readonly description: "The outcome of the analysis for this particular field";
                    };
                    readonly field: {
                        readonly type: "string";
                        readonly description: "e.g. \"spec.owner\"? The frontend needs to know how to \"inject\" the field into the\nentity again if the user wants to change it";
                    };
                };
                readonly required: readonly ["description", "value", "state", "field"];
                readonly additionalProperties: false;
            };
            readonly AnalyzeLocationGenerateEntity: {
                readonly type: "object";
                readonly properties: {
                    readonly fields: {
                        readonly type: "array";
                        readonly items: {
                            readonly $ref: "#/components/schemas/AnalyzeLocationEntityField";
                        };
                    };
                    readonly entity: {
                        readonly $ref: "#/components/schemas/RecursivePartialEntity";
                    };
                };
                readonly required: readonly ["fields", "entity"];
                readonly description: "This is some form of representation of what the analyzer could deduce.\nWe should probably have a chat about how this can best be conveyed to\nthe frontend. It'll probably contain a (possibly incomplete) entity, plus\nenough info for the frontend to know what form data to show to the user\nfor overriding/completing the info.";
                readonly additionalProperties: false;
            };
            readonly AnalyzeLocationResponse: {
                readonly type: "object";
                readonly properties: {
                    readonly generateEntities: {
                        readonly items: {
                            readonly $ref: "#/components/schemas/AnalyzeLocationGenerateEntity";
                        };
                        readonly type: "array";
                    };
                    readonly existingEntityFiles: {
                        readonly items: {
                            readonly $ref: "#/components/schemas/AnalyzeLocationExistingEntity";
                        };
                        readonly type: "array";
                    };
                };
                readonly required: readonly ["generateEntities", "existingEntityFiles"];
                readonly additionalProperties: false;
            };
            readonly LocationInput: {
                readonly type: "object";
                readonly properties: {
                    readonly type: {
                        readonly type: "string";
                    };
                    readonly target: {
                        readonly type: "string";
                    };
                };
                readonly required: readonly ["type", "target"];
                readonly additionalProperties: false;
            };
            readonly EntitiesQueryResponse: {
                readonly type: "object";
                readonly properties: {
                    readonly items: {
                        readonly type: "array";
                        readonly items: {
                            readonly $ref: "#/components/schemas/Entity";
                        };
                        readonly description: "The list of entities paginated by a specific filter.";
                    };
                    readonly totalItems: {
                        readonly type: "number";
                    };
                    readonly pageInfo: {
                        readonly type: "object";
                        readonly properties: {
                            readonly nextCursor: {
                                readonly type: "string";
                                readonly description: "The cursor for the next batch of entities.";
                            };
                            readonly prevCursor: {
                                readonly type: "string";
                                readonly description: "The cursor for the previous batch of entities.";
                            };
                        };
                    };
                };
                readonly required: readonly ["items", "totalItems", "pageInfo"];
                readonly additionalProperties: false;
            };
        };
        readonly securitySchemes: {
            readonly JWT: {
                readonly type: "http";
                readonly scheme: "bearer";
                readonly bearerFormat: "JWT";
            };
        };
    };
    readonly paths: {
        readonly '/refresh': {
            readonly post: {
                readonly operationId: "RefreshEntity";
                readonly description: "Refresh the entity related to entityRef.";
                readonly responses: {
                    readonly '200': {
                        readonly description: "Refreshed";
                    };
                    readonly '400': {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                    readonly default: {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                };
                readonly security: readonly [{}, {
                    readonly JWT: readonly [];
                }];
                readonly parameters: readonly [];
                readonly requestBody: {
                    readonly required: true;
                    readonly content: {
                        readonly 'application/json': {
                            readonly schema: {
                                readonly type: "object";
                                readonly properties: {
                                    readonly authorizationToken: {
                                        readonly type: "string";
                                    };
                                    readonly entityRef: {
                                        readonly type: "string";
                                        readonly description: "The reference to a single entity that should be refreshed";
                                    };
                                };
                                readonly required: readonly ["entityRef"];
                                readonly description: "Options for requesting a refresh of entities in the catalog.";
                                readonly additionalProperties: false;
                            };
                        };
                    };
                };
            };
        };
        readonly '/entities': {
            readonly get: {
                readonly operationId: "GetEntities";
                readonly description: "Get all entities matching a given filter.";
                readonly responses: {
                    readonly '200': {
                        readonly description: "";
                        readonly content: {
                            readonly 'application/json': {
                                readonly schema: {
                                    readonly type: "array";
                                    readonly items: {
                                        readonly $ref: "#/components/schemas/Entity";
                                    };
                                };
                            };
                        };
                    };
                    readonly '400': {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                    readonly default: {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                };
                readonly security: readonly [{}, {
                    readonly JWT: readonly [];
                }];
                readonly parameters: readonly [{
                    readonly $ref: "#/components/parameters/fields";
                }, {
                    readonly $ref: "#/components/parameters/limit";
                }, {
                    readonly $ref: "#/components/parameters/filter";
                }, {
                    readonly $ref: "#/components/parameters/offset";
                }, {
                    readonly $ref: "#/components/parameters/after";
                }, {
                    readonly name: "order";
                    readonly in: "query";
                    readonly allowReserved: true;
                    readonly required: false;
                    readonly schema: {
                        readonly type: "array";
                        readonly items: {
                            readonly type: "string";
                        };
                    };
                }];
            };
        };
        readonly '/entities/by-uid/{uid}': {
            readonly get: {
                readonly operationId: "GetEntityByUid";
                readonly description: "Get a single entity by the UID.";
                readonly responses: {
                    readonly '200': {
                        readonly description: "Ok";
                        readonly content: {
                            readonly 'application/json': {
                                readonly schema: {
                                    readonly $ref: "#/components/schemas/Entity";
                                };
                            };
                        };
                    };
                    readonly '400': {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                    readonly default: {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                };
                readonly security: readonly [{}, {
                    readonly JWT: readonly [];
                }];
                readonly parameters: readonly [{
                    readonly $ref: "#/components/parameters/uid";
                }];
            };
            readonly delete: {
                readonly operationId: "DeleteEntityByUid";
                readonly description: "Delete a single entity by UID.";
                readonly responses: {
                    readonly '204': {
                        readonly description: "Deleted successfully.";
                    };
                    readonly '400': {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                    readonly default: {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                };
                readonly security: readonly [{}, {
                    readonly JWT: readonly [];
                }];
                readonly parameters: readonly [{
                    readonly $ref: "#/components/parameters/uid";
                }];
            };
        };
        readonly '/entities/by-name/{kind}/{namespace}/{name}': {
            readonly get: {
                readonly operationId: "GetEntityByName";
                readonly description: "Get an entity by an entity ref.";
                readonly responses: {
                    readonly '200': {
                        readonly description: "Ok";
                        readonly content: {
                            readonly 'application/json': {
                                readonly schema: {
                                    readonly $ref: "#/components/schemas/Entity";
                                };
                            };
                        };
                    };
                    readonly '400': {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                    readonly default: {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                };
                readonly security: readonly [{}, {
                    readonly JWT: readonly [];
                }];
                readonly parameters: readonly [{
                    readonly $ref: "#/components/parameters/kind";
                }, {
                    readonly $ref: "#/components/parameters/namespace";
                }, {
                    readonly $ref: "#/components/parameters/name";
                }];
            };
        };
        readonly '/entities/by-name/{kind}/{namespace}/{name}/ancestry': {
            readonly get: {
                readonly operationId: "GetEntityAncestryByName";
                readonly description: "Get an entity's ancestry by entity ref.";
                readonly responses: {
                    readonly '200': {
                        readonly description: "Ok";
                        readonly content: {
                            readonly 'application/json': {
                                readonly schema: {
                                    readonly $ref: "#/components/schemas/EntityAncestryResponse";
                                };
                            };
                        };
                    };
                    readonly '400': {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                    readonly default: {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                };
                readonly security: readonly [{}, {
                    readonly JWT: readonly [];
                }];
                readonly parameters: readonly [{
                    readonly $ref: "#/components/parameters/kind";
                }, {
                    readonly $ref: "#/components/parameters/namespace";
                }, {
                    readonly $ref: "#/components/parameters/name";
                }];
            };
        };
        readonly '/entities/by-refs': {
            readonly post: {
                readonly operationId: "GetEntitiesByRefs";
                readonly description: "Get a batch set of entities given an array of entityRefs.";
                readonly responses: {
                    readonly '200': {
                        readonly description: "Ok";
                        readonly content: {
                            readonly 'application/json': {
                                readonly schema: {
                                    readonly $ref: "#/components/schemas/EntitiesBatchResponse";
                                };
                            };
                        };
                    };
                    readonly '400': {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                    readonly default: {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                };
                readonly security: readonly [{}, {
                    readonly JWT: readonly [];
                }];
                readonly requestBody: {
                    readonly required: false;
                    readonly content: {
                        readonly 'application/json': {
                            readonly schema: {
                                readonly type: "object";
                                readonly required: readonly ["entityRefs"];
                                readonly properties: {
                                    readonly entityRefs: {
                                        readonly type: "array";
                                        readonly items: {
                                            readonly type: "string";
                                        };
                                    };
                                    readonly fields: {
                                        readonly type: "array";
                                        readonly items: {
                                            readonly type: "string";
                                        };
                                    };
                                };
                            };
                            readonly examples: {
                                readonly 'Fetch Backstage entities': {
                                    readonly value: {
                                        readonly entityRefs: readonly ["component:default/backstage", "api:default/backstage"];
                                    };
                                };
                                readonly 'Fetch annotations for backstage entity': {
                                    readonly value: {
                                        readonly entityRefs: readonly ["component:default/backstage"];
                                        readonly fields: readonly ["metadata.annotations"];
                                    };
                                };
                            };
                        };
                    };
                };
                readonly parameters: readonly [{
                    readonly $ref: "#/components/parameters/filter";
                }];
            };
        };
        readonly '/entities/by-query': {
            readonly get: {
                readonly operationId: "GetEntitiesByQuery";
                readonly description: "Search for entities by a given query.";
                readonly responses: {
                    readonly '200': {
                        readonly description: "Ok";
                        readonly content: {
                            readonly 'application/json': {
                                readonly schema: {
                                    readonly $ref: "#/components/schemas/EntitiesQueryResponse";
                                };
                            };
                        };
                    };
                    readonly '400': {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                    readonly default: {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                };
                readonly security: readonly [{}, {
                    readonly JWT: readonly [];
                }];
                readonly parameters: readonly [{
                    readonly $ref: "#/components/parameters/fields";
                }, {
                    readonly $ref: "#/components/parameters/limit";
                }, {
                    readonly $ref: "#/components/parameters/orderField";
                }, {
                    readonly $ref: "#/components/parameters/cursor";
                }, {
                    readonly $ref: "#/components/parameters/filter";
                }, {
                    readonly name: "fullTextFilterTerm";
                    readonly in: "query";
                    readonly description: "Text search term.";
                    readonly required: false;
                    readonly allowReserved: true;
                    readonly schema: {
                        readonly type: "string";
                    };
                }, {
                    readonly name: "fullTextFilterFields";
                    readonly in: "query";
                    readonly description: "A comma separated list of fields to sort returned results by.";
                    readonly required: false;
                    readonly allowReserved: true;
                    readonly schema: {
                        readonly type: "array";
                        readonly items: {
                            readonly type: "string";
                        };
                    };
                    readonly explode: false;
                    readonly style: "form";
                }];
            };
        };
        readonly '/entity-facets': {
            readonly get: {
                readonly operationId: "GetEntityFacets";
                readonly description: "Get all entity facets that match the given filters.";
                readonly responses: {
                    readonly '200': {
                        readonly description: "Ok";
                        readonly content: {
                            readonly 'application/json': {
                                readonly schema: {
                                    readonly $ref: "#/components/schemas/EntityFacetsResponse";
                                };
                            };
                        };
                    };
                    readonly '400': {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                    readonly default: {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                };
                readonly security: readonly [{}, {
                    readonly JWT: readonly [];
                }];
                readonly parameters: readonly [{
                    readonly in: "query";
                    readonly name: "facet";
                    readonly required: true;
                    readonly allowReserved: true;
                    readonly schema: {
                        readonly type: "array";
                        readonly items: {
                            readonly type: "string";
                        };
                    };
                    readonly examples: {
                        readonly 'Entities by kind': {
                            readonly value: readonly ["kind"];
                        };
                        readonly 'Entities by spec type': {
                            readonly value: readonly ["spec.type"];
                        };
                    };
                }, {
                    readonly $ref: "#/components/parameters/filter";
                }];
            };
        };
        readonly '/locations': {
            readonly post: {
                readonly operationId: "CreateLocation";
                readonly description: "Create a location for a given target.";
                readonly responses: {
                    readonly '201': {
                        readonly description: "Created";
                        readonly content: {
                            readonly 'application/json': {
                                readonly schema: {
                                    readonly type: "object";
                                    readonly properties: {
                                        readonly exists: {
                                            readonly type: "boolean";
                                        };
                                        readonly entities: {
                                            readonly items: {
                                                readonly $ref: "#/components/schemas/Entity";
                                            };
                                            readonly type: "array";
                                        };
                                        readonly location: {
                                            readonly $ref: "#/components/schemas/Location";
                                        };
                                    };
                                    readonly required: readonly ["entities", "location"];
                                };
                            };
                        };
                    };
                    readonly '400': {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                    readonly default: {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                };
                readonly security: readonly [{}, {
                    readonly JWT: readonly [];
                }];
                readonly parameters: readonly [{
                    readonly in: "query";
                    readonly name: "dryRun";
                    readonly required: false;
                    readonly allowReserved: true;
                    readonly schema: {
                        readonly type: "string";
                    };
                }];
                readonly requestBody: {
                    readonly required: true;
                    readonly content: {
                        readonly 'application/json': {
                            readonly schema: {
                                readonly type: "object";
                                readonly properties: {
                                    readonly target: {
                                        readonly type: "string";
                                    };
                                    readonly type: {
                                        readonly type: "string";
                                    };
                                };
                                readonly required: readonly ["target", "type"];
                            };
                        };
                    };
                };
            };
            readonly get: {
                readonly operationId: "GetLocations";
                readonly description: "Get all locations";
                readonly responses: {
                    readonly '200': {
                        readonly description: "Ok";
                        readonly content: {
                            readonly 'application/json': {
                                readonly schema: {
                                    readonly type: "array";
                                    readonly items: {
                                        readonly type: "object";
                                        readonly properties: {
                                            readonly data: {
                                                readonly $ref: "#/components/schemas/Location";
                                            };
                                        };
                                        readonly required: readonly ["data"];
                                    };
                                };
                            };
                        };
                    };
                    readonly default: {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                };
                readonly security: readonly [{}, {
                    readonly JWT: readonly [];
                }];
                readonly parameters: readonly [];
            };
        };
        readonly '/locations/{id}': {
            readonly get: {
                readonly operationId: "GetLocation";
                readonly description: "Get a location by id.";
                readonly responses: {
                    readonly '200': {
                        readonly description: "Ok";
                        readonly content: {
                            readonly 'application/json': {
                                readonly schema: {
                                    readonly $ref: "#/components/schemas/Location";
                                };
                            };
                        };
                    };
                    readonly default: {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                };
                readonly security: readonly [{}, {
                    readonly JWT: readonly [];
                }];
                readonly parameters: readonly [{
                    readonly in: "path";
                    readonly name: "id";
                    readonly required: true;
                    readonly allowReserved: true;
                    readonly schema: {
                        readonly type: "string";
                    };
                }];
            };
            readonly delete: {
                readonly operationId: "DeleteLocation";
                readonly description: "Delete a location by id.";
                readonly responses: {
                    readonly '204': {
                        readonly description: "No content";
                    };
                    readonly '400': {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                    readonly default: {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                };
                readonly security: readonly [{}, {
                    readonly JWT: readonly [];
                }];
                readonly parameters: readonly [{
                    readonly in: "path";
                    readonly name: "id";
                    readonly required: true;
                    readonly allowReserved: true;
                    readonly schema: {
                        readonly type: "string";
                    };
                }];
            };
        };
        readonly '/locations/by-entity/{kind}/{namespace}/{name}': {
            readonly get: {
                readonly operationId: "getLocationByEntity";
                readonly description: "Get a location for entity.";
                readonly responses: {
                    readonly '200': {
                        readonly description: "Ok";
                        readonly content: {
                            readonly 'application/json': {
                                readonly schema: {
                                    readonly $ref: "#/components/schemas/Location";
                                };
                            };
                        };
                    };
                    readonly default: {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                };
                readonly security: readonly [{}, {
                    readonly JWT: readonly [];
                }];
                readonly parameters: readonly [{
                    readonly in: "path";
                    readonly name: "kind";
                    readonly required: true;
                    readonly allowReserved: true;
                    readonly schema: {
                        readonly type: "string";
                    };
                }, {
                    readonly in: "path";
                    readonly name: "namespace";
                    readonly required: true;
                    readonly allowReserved: true;
                    readonly schema: {
                        readonly type: "string";
                    };
                }, {
                    readonly in: "path";
                    readonly name: "name";
                    readonly required: true;
                    readonly allowReserved: true;
                    readonly schema: {
                        readonly type: "string";
                    };
                }];
            };
        };
        readonly '/analyze-location': {
            readonly post: {
                readonly operationId: "AnalyzeLocation";
                readonly description: "Validate a given location.";
                readonly responses: {
                    readonly '200': {
                        readonly description: "Ok";
                        readonly content: {
                            readonly 'application/json': {
                                readonly schema: {
                                    readonly $ref: "#/components/schemas/AnalyzeLocationResponse";
                                };
                            };
                        };
                    };
                    readonly '400': {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                    readonly default: {
                        readonly $ref: "#/components/responses/ErrorResponse";
                    };
                };
                readonly security: readonly [{}, {
                    readonly JWT: readonly [];
                }];
                readonly parameters: readonly [];
                readonly requestBody: {
                    readonly required: true;
                    readonly content: {
                        readonly 'application/json': {
                            readonly schema: {
                                readonly type: "object";
                                readonly properties: {
                                    readonly catalogFileName: {
                                        readonly type: "string";
                                    };
                                    readonly location: {
                                        readonly $ref: "#/components/schemas/LocationInput";
                                    };
                                };
                                readonly required: readonly ["location"];
                            };
                        };
                    };
                };
            };
        };
        readonly '/validate-entity': {
            readonly post: {
                readonly operationId: "ValidateEntity";
                readonly description: "Validate that a passed in entity has no errors in schema.";
                readonly responses: {
                    readonly '200': {
                        readonly description: "Ok";
                    };
                    readonly '400': {
                        readonly description: "Validation errors.";
                        readonly content: {
                            readonly 'application/json; charset=utf-8': {
                                readonly schema: {
                                    readonly type: "object";
                                    readonly properties: {
                                        readonly errors: {
                                            readonly type: "array";
                                            readonly items: {
                                                readonly type: "object";
                                                readonly properties: {
                                                    readonly name: {
                                                        readonly type: "string";
                                                    };
                                                    readonly message: {
                                                        readonly type: "string";
                                                    };
                                                };
                                                readonly required: readonly ["name", "message"];
                                                readonly additionalProperties: {};
                                            };
                                        };
                                    };
                                    readonly required: readonly ["errors"];
                                };
                            };
                        };
                    };
                };
                readonly security: readonly [{}, {
                    readonly JWT: readonly [];
                }];
                readonly parameters: readonly [];
                readonly requestBody: {
                    readonly required: true;
                    readonly content: {
                        readonly 'application/json': {
                            readonly schema: {
                                readonly type: "object";
                                readonly properties: {
                                    readonly location: {
                                        readonly type: "string";
                                    };
                                    readonly entity: {
                                        readonly type: "object";
                                        readonly additionalProperties: {};
                                    };
                                };
                                readonly required: readonly ["location", "entity"];
                            };
                        };
                    };
                };
            };
        };
    };
}>>;
