@kubb/agent 4.33.1 → 4.33.3

package/.output/server/node_modules/@redocly/openapi-core/lib/types/oas3_1.js

@@ -0,0 +1,292 @@
+import { listOf, mapOf } from './index.js';
+import { Oas3Types } from './oas3.js';
+const Root = {
+    properties: {
+        openapi: null,
+        info: 'Info',
+        servers: 'ServerList',
+        security: 'SecurityRequirementList',
+        tags: 'TagList',
+        externalDocs: 'ExternalDocs',
+        paths: 'Paths',
+        webhooks: 'WebhooksMap',
+        components: 'Components',
+        jsonSchemaDialect: {
+            type: 'string',
+            description: 'The default value for the $schema keyword within Schema Objects contained within this OAS document. This MUST be in the form of a URI.',
+        },
+    },
+    required: ['openapi', 'info'],
+    requiredOneOf: ['paths', 'components', 'webhooks'],
+    extensionsPrefix: 'x-',
+    documentationLink: 'https://redocly.com/learn/openapi/openapi-visual-reference/openapi#openapi',
+    description: 'REQUIRED. This string MUST be the semantic version number of the OpenAPI Specification version that the OpenAPI document uses. The openapi field SHOULD be used by tooling specifications and clients to interpret the OpenAPI document. This is not related to the API info.version string.',
+};
+const License = {
+    ...Oas3Types.License,
+    properties: {
+        ...Oas3Types.License.properties,
+        identifier: {
+            type: 'string',
+            description: 'An [SPDX-Licenses] expression for the API. The identifier field is mutually exclusive of the url field.',
+        },
+    },
+};
+const Info = {
+    ...Oas3Types.Info,
+    properties: {
+        ...Oas3Types.Info.properties,
+        summary: {
+            type: 'string',
+            description: 'A short summary of the API. This field MAY be used by tooling as required.',
+        },
+    },
+};
+const Components = {
+    ...Oas3Types.Components,
+    properties: {
+        ...Oas3Types.Components.properties,
+        pathItems: 'NamedPathItems',
+    },
+};
+const Operation = {
+    properties: {
+        tags: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'A list of tags for API documentation control. Tags can be used for logical grouping of operations by resources or any other qualifier.',
+        },
+        summary: {
+            type: 'string',
+            description: 'A short summary of what the operation does.',
+            documentationLink: 'https://redocly.com/learn/openapi/openapi-visual-reference/operation#summary',
+        },
+        description: {
+            type: 'string',
+            description: 'A verbose explanation of the operation behavior.',
+            documentationLink: 'https://redocly.com/learn/openapi/openapi-visual-reference/operation#description',
+        },
+        externalDocs: 'ExternalDocs',
+        operationId: {
+            type: 'string',
+            description: 'The operationId is path segment or path fragment in deep links to a specific operation.',
+            documentationLink: 'https://redocly.com/learn/openapi/openapi-visual-reference/operation#operationid',
+        },
+        parameters: 'ParameterList',
+        security: 'SecurityRequirementList',
+        servers: 'ServerList',
+        requestBody: 'RequestBody',
+        responses: 'Responses',
+        deprecated: { type: 'boolean' },
+        callbacks: 'CallbacksMap',
+        'x-codeSamples': 'XCodeSampleList',
+        'x-code-samples': 'XCodeSampleList', // deprecated
+        'x-hideTryItPanel': { type: 'boolean' },
+    },
+    extensionsPrefix: 'x-',
+    description: `The Operation Object describes a single API operation on a path, including its parameters, responses, and request body (if applicable). Each path can support more than one operation, but those operations must be unique. A unique operation is a combination of a path and an HTTP method, so two GET or two POST methods for the same path are not allowed.`,
+};
+// draft-2020-12
+const Schema = {
+    properties: {
+        $id: { type: 'string' },
+        $anchor: { type: 'string' },
+        id: { type: 'string' },
+        $schema: { type: 'string' },
+        definitions: 'NamedSchemas',
+        $defs: 'NamedSchemas',
+        $vocabulary: { type: 'string' },
+        externalDocs: 'ExternalDocs',
+        discriminator: 'Discriminator',
+        title: { type: 'string' },
+        multipleOf: { type: 'number', minimum: 0 },
+        maximum: { type: 'number' },
+        minimum: { type: 'number' },
+        exclusiveMaximum: { type: 'number' },
+        exclusiveMinimum: { type: 'number' },
+        maxLength: { type: 'integer', minimum: 0 },
+        minLength: { type: 'integer', minimum: 0 },
+        pattern: { type: 'string' },
+        maxItems: { type: 'integer', minimum: 0 },
+        minItems: { type: 'integer', minimum: 0 },
+        uniqueItems: { type: 'boolean' },
+        maxProperties: { type: 'integer', minimum: 0 },
+        minProperties: { type: 'integer', minimum: 0 },
+        required: { type: 'array', items: { type: 'string' } },
+        enum: { type: 'array' },
+        type: (value) => {
+            if (Array.isArray(value)) {
+                return {
+                    type: 'array',
+                    items: { enum: ['object', 'array', 'string', 'number', 'integer', 'boolean', 'null'] },
+                };
+            }
+            else {
+                return {
+                    enum: ['object', 'array', 'string', 'number', 'integer', 'boolean', 'null'],
+                };
+            }
+        },
+        allOf: listOf('Schema'),
+        anyOf: listOf('Schema'),
+        oneOf: listOf('Schema'),
+        not: 'Schema',
+        if: 'Schema',
+        then: 'Schema',
+        else: 'Schema',
+        dependentSchemas: mapOf('Schema'),
+        dependentRequired: 'DependentRequired',
+        prefixItems: listOf('Schema'),
+        contains: 'Schema',
+        minContains: { type: 'integer', minimum: 0 },
+        maxContains: { type: 'integer', minimum: 0 },
+        patternProperties: 'PatternProperties',
+        propertyNames: 'Schema',
+        unevaluatedItems: (value) => {
+            if (typeof value === 'boolean') {
+                return { type: 'boolean' };
+            }
+            else {
+                return 'Schema';
+            }
+        },
+        unevaluatedProperties: (value) => {
+            if (typeof value === 'boolean') {
+                return { type: 'boolean' };
+            }
+            else {
+                return 'Schema';
+            }
+        },
+        summary: { type: 'string' },
+        properties: 'SchemaProperties',
+        items: (value) => {
+            if (typeof value === 'boolean') {
+                return { type: 'boolean' };
+            }
+            else {
+                return 'Schema';
+            }
+        },
+        additionalProperties: (value) => {
+            return typeof value === 'boolean' ? { type: 'boolean' } : 'Schema';
+        },
+        description: { type: 'string' },
+        format: { type: 'string' },
+        contentEncoding: { type: 'string' },
+        contentMediaType: { type: 'string' },
+        contentSchema: 'Schema',
+        default: null,
+        readOnly: { type: 'boolean' },
+        writeOnly: { type: 'boolean' },
+        xml: 'Xml',
+        examples: { type: 'array' },
+        example: { isExample: true },
+        deprecated: { type: 'boolean' },
+        const: null,
+        $comment: { type: 'string' },
+        'x-tags': { type: 'array', items: { type: 'string' } },
+        $dynamicAnchor: { type: 'string' },
+        $dynamicRef: { type: 'string' },
+    },
+    extensionsPrefix: 'x-',
+};
+const SchemaProperties = {
+    properties: {},
+    additionalProperties: (value) => {
+        if (typeof value === 'boolean') {
+            return { type: 'boolean' };
+        }
+        else {
+            return 'Schema';
+        }
+    },
+};
+const SecurityScheme = {
+    properties: {
+        type: { enum: ['apiKey', 'http', 'oauth2', 'openIdConnect', 'mutualTLS'] },
+        description: { type: 'string' },
+        name: { type: 'string' },
+        in: { type: 'string', enum: ['query', 'header', 'cookie'] },
+        scheme: { type: 'string' },
+        bearerFormat: { type: 'string' },
+        flows: 'OAuth2Flows',
+        openIdConnectUrl: { type: 'string' },
+    },
+    required(value) {
+        switch (value?.type) {
+            case 'apiKey':
+                return ['type', 'name', 'in'];
+            case 'http':
+                return ['type', 'scheme'];
+            case 'oauth2':
+                return ['type', 'flows'];
+            case 'openIdConnect':
+                return ['type', 'openIdConnectUrl'];
+            default:
+                return ['type'];
+        }
+    },
+    allowed(value) {
+        switch (value?.type) {
+            case 'apiKey':
+                return ['type', 'name', 'in', 'description'];
+            case 'http':
+                return ['type', 'scheme', 'bearerFormat', 'description'];
+            case 'oauth2':
+                switch (value?.flows) {
+                    case 'implicit':
+                        return ['type', 'flows', 'authorizationUrl', 'refreshUrl', 'description', 'scopes'];
+                    case 'password':
+                    case 'clientCredentials':
+                        return ['type', 'flows', 'tokenUrl', 'refreshUrl', 'description', 'scopes'];
+                    case 'authorizationCode':
+                        return [
+                            'type',
+                            'flows',
+                            'authorizationUrl',
+                            'refreshUrl',
+                            'tokenUrl',
+                            'description',
+                            'scopes',
+                        ];
+                    default:
+                        return [
+                            'type',
+                            'flows',
+                            'authorizationUrl',
+                            'refreshUrl',
+                            'tokenUrl',
+                            'description',
+                            'scopes',
+                        ];
+                }
+            case 'openIdConnect':
+                return ['type', 'openIdConnectUrl', 'description'];
+            case 'mutualTLS':
+                return ['type', 'description'];
+            default:
+                return ['type', 'description'];
+        }
+    },
+    extensionsPrefix: 'x-',
+};
+const DependentRequired = {
+    properties: {},
+    additionalProperties: { type: 'array', items: { type: 'string' } },
+};
+export const Oas3_1Types = {
+    ...Oas3Types,
+    Info,
+    Root,
+    Schema,
+    SchemaProperties,
+    PatternProperties: SchemaProperties,
+    License,
+    Components,
+    NamedPathItems: mapOf('PathItem'),
+    SecurityScheme,
+    Operation,
+    DependentRequired,
+};
+//# sourceMappingURL=oas3_1.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/types/oas3_2.js

@@ -0,0 +1,306 @@
+import { listOf, mapOf } from './index.js';
+import { Oas3Types } from './oas3.js';
+import { Oas3_1Types } from './oas3_1.js';
+const Root = {
+    ...Oas3_1Types.Root,
+    properties: {
+        ...Oas3_1Types.Root.properties,
+        $self: {
+            type: 'string',
+            description: 'This string MUST be in the form of a URI reference as defined by [RFC3986] Section 4.1. The $self field provides the self-assigned URI of this document, which also serves as its base URI in accordance with [RFC3986] Section 5.1.1. Implementations MUST support identifying the targets of API description URIs using the URI defined by this field when it is present. See Establishing the Base URI for the base URI behavior when $self is absent or relative, and see Appendix F for examples of using $self to resolve references.',
+        },
+    },
+};
+const Tag = {
+    ...Oas3_1Types.Tag,
+    properties: {
+        ...Oas3_1Types.Tag.properties,
+        kind: {
+            type: 'string',
+            description: 'A machine-readable string to categorize what sort of tag it is. Any string value can be used; common uses are nav for Navigation, badge for visible badges, audience for APIs used by different groups. A registry of the most commonly used values is available.',
+        },
+        parent: {
+            type: 'string',
+            description: 'The name of a tag that this tag is nested under. The named tag MUST exist in the API description, and circular references between parent and child tags MUST NOT be used.',
+        },
+        summary: {
+            type: 'string',
+            description: 'A short summary of the tag, used for display purposes.',
+        },
+    },
+    description: 'Adds metadata to a single tag that is used by the Operation Object. It is not mandatory to have a Tag Object per tag defined in the Operation Object instances.',
+};
+const Server = {
+    ...Oas3_1Types.Server,
+    properties: {
+        ...Oas3_1Types.Server.properties,
+        name: {
+            type: 'string',
+            description: 'An optional unique string to refer to the host designated by the URL.',
+        },
+    },
+    description: 'An object representing a Server.',
+};
+const SecurityScheme = {
+    ...Oas3_1Types.SecurityScheme,
+    properties: {
+        ...Oas3_1Types.SecurityScheme.properties,
+        deprecated: {
+            type: 'boolean',
+            description: 'Declares this security scheme to be deprecated. Consumers SHOULD refrain from usage of the declared scheme. Default value is false.',
+        }, // added in OAS 3.2
+        oauth2MetadataUrl: {
+            type: 'string',
+            description: 'URL to the OAuth2 authorization server metadata [RFC8414]. TLS is required.',
+        }, // added in OAS 3.2
+    },
+    allowed(value) {
+        switch (value?.type) {
+            case 'apiKey':
+                return [
+                    'type',
+                    'name',
+                    'in',
+                    'description',
+                    'deprecated', // added in OAS 3.2
+                ];
+            case 'http':
+                return [
+                    'type',
+                    'scheme',
+                    'bearerFormat',
+                    'description',
+                    'deprecated', // added in OAS 3.2
+                ];
+            case 'oauth2':
+                switch (value?.flows) {
+                    case 'implicit':
+                        return [
+                            'type',
+                            'flows',
+                            'authorizationUrl',
+                            'refreshUrl',
+                            'description',
+                            'scopes',
+                            'oauth2MetadataUrl', // added in OAS 3.2
+                            'deprecated', // added in OAS 3.2
+                        ];
+                    case 'password':
+                    case 'clientCredentials':
+                        return [
+                            'type',
+                            'flows',
+                            'tokenUrl',
+                            'refreshUrl',
+                            'description',
+                            'scopes',
+                            'oauth2MetadataUrl', // added in OAS 3.2
+                            'deprecated', // added in OAS 3.2
+                        ];
+                    case 'authorizationCode':
+                        return [
+                            'type',
+                            'flows',
+                            'authorizationUrl',
+                            'refreshUrl',
+                            'tokenUrl',
+                            'description',
+                            'scopes',
+                            'oauth2MetadataUrl', // added in OAS 3.2
+                            'deprecated', // added in OAS 3.2
+                        ];
+                    case 'deviceAuthorization': // added in OAS 3.2
+                        return ['type', 'flows', 'deviceAuthorizationUrl', 'tokenUrl'];
+                    default:
+                        return [
+                            'type',
+                            'flows',
+                            'authorizationUrl',
+                            'refreshUrl',
+                            'tokenUrl',
+                            'description',
+                            'scopes',
+                            'oauth2MetadataUrl', // added in OAS 3.2
+                            'deprecated', // added in OAS 3.2
+                        ];
+                }
+            case 'openIdConnect':
+                return [
+                    'type',
+                    'openIdConnectUrl',
+                    'description',
+                    'deprecated', // added in OAS 3.2
+                ];
+            case 'mutualTLS':
+                return [
+                    'type',
+                    'description',
+                    'deprecated', // added in OAS 3.2
+                ];
+            default:
+                return [
+                    'type',
+                    'description',
+                    'deprecated', // added in OAS 3.2
+                ];
+        }
+    },
+    description: 'Defines a security scheme that can be used by the operations.',
+};
+const OAuth2Flows = {
+    ...Oas3_1Types.OAuth2Flows,
+    properties: {
+        ...Oas3_1Types.OAuth2Flows.properties,
+        deviceAuthorization: 'DeviceAuthorization',
+    },
+};
+const DeviceAuthorization = {
+    properties: {
+        deviceAuthorizationUrl: {
+            type: 'string',
+            description: 'REQUIRED. The device authorization URL to be used for this flow. This MUST be in the form of a URL. The OAuth2 standard requires the use of TLS.',
+        },
+        tokenUrl: {
+            type: 'string',
+            description: 'REQUIRED. The token URL to be used for this flow. This MUST be in the form of a URL. The OAuth2 standard requires the use of TLS.',
+        },
+        refreshUrl: {
+            type: 'string',
+            description: 'The URL to be used for obtaining refresh tokens. This MUST be in the form of a URL. The OAuth2 standard requires the use of TLS.',
+        },
+        scopes: mapOf('string', {
+            description: 'REQUIRED. The available scopes for the OAuth2 security scheme. A map between the scope name and a short description for it. The map MAY be empty.',
+        }),
+    },
+    required: ['deviceAuthorizationUrl', 'tokenUrl', 'scopes'],
+    extensionsPrefix: 'x-',
+    description: 'Configuration for the OAuth Device Authorization flow.',
+};
+const PathItem = {
+    ...Oas3Types.PathItem,
+    properties: {
+        ...Oas3Types.PathItem.properties,
+        query: 'Operation',
+        additionalOperations: mapOf('Operation'),
+    },
+};
+const Parameter = {
+    ...Oas3_1Types.Parameter,
+    properties: {
+        ...Oas3_1Types.Parameter.properties,
+        in: {
+            description: 'REQUIRED. The location of the parameter. Possible values are "query", "querystring", "header", "path" or "cookie".',
+            enum: ['query', 'header', 'path', 'cookie', 'querystring'],
+        },
+    },
+};
+const Response = {
+    ...Oas3_1Types.Response,
+    properties: {
+        ...Oas3_1Types.Response.properties,
+        summary: {
+            type: 'string',
+            description: 'A short summary of the meaning of the response.',
+        },
+    },
+};
+const MediaType = {
+    ...Oas3_1Types.MediaType,
+    properties: {
+        ...Oas3_1Types.MediaType.properties,
+        itemSchema: 'Schema',
+        prefixEncoding: listOf('Encoding', {
+            description: 'A map between a property name and its encoding information, as defined under Encoding By Name. The encoding field SHALL only apply when the media type is multipart or application/x-www-form-urlencoded. If no Encoding Object is provided for a property, the behavior is determined by the default values documented for the Encoding Object. This field MUST NOT be present if prefixEncoding or itemEncoding are present.',
+        }),
+        itemEncoding: 'Encoding',
+    },
+};
+const Discriminator = {
+    ...Oas3_1Types.Discriminator,
+    properties: {
+        ...Oas3_1Types.Discriminator.properties,
+        defaultMapping: {
+            type: 'string',
+            description: 'The schema name or URI reference to a schema that is expected to validate the structure of the model when the discriminating property is not present in the payload or contains a value for which there is no explicit or implicit mapping.',
+        },
+    },
+};
+const Components = {
+    properties: {
+        ...Oas3_1Types.Components.properties,
+        mediaTypes: 'NamedMediaTypes',
+    },
+};
+const Example = {
+    ...Oas3_1Types.Example,
+    properties: {
+        ...Oas3_1Types.Example.properties,
+        dataValue: {
+            resolvable: false,
+            description: 'An example of the data structure that MUST be valid according to the relevant Schema Object. If this field is present, value MUST be absent.',
+        },
+        serializedValue: {
+            type: 'string',
+            description: 'An example of the serialized form of the value, including encoding and escaping as described under Validating Examples. If dataValue is present, then this field SHOULD contain the serialization of the given data. Otherwise, it SHOULD be the valid serialization of a data value that itself MUST be valid as described for dataValue. This field SHOULD NOT be used if the serialization format is JSON, as the data form is easier to work with. If this field is present, value, and externalValue MUST be absent.',
+        },
+    },
+};
+const Xml = {
+    properties: {
+        nodeType: {
+            type: 'string',
+            enum: ['element', 'attribute', 'text', 'cdata', 'none'],
+            description: 'One of element, attribute, text, cdata, or none, as explained under XML Node Types. The default value is none if $ref, $dynamicRef, or type: "array" is present in the Schema Object containing the XML Object, and element otherwise.',
+        },
+        name: {
+            type: 'string',
+            description: 'Sets the name of the element/attribute corresponding to the schema, replacing the name that was inferred as described under XML Node Names. This field SHALL be ignored if the nodeType is text, cdata, or none.',
+        },
+        namespace: {
+            type: 'string',
+            description: 'The IRI ([RFC3987]) of the namespace definition. Value MUST be in the form of a non-relative IRI.',
+        },
+        prefix: {
+            type: 'string',
+            description: 'The prefix to be used for the name.',
+        },
+        attribute: {
+            type: 'boolean',
+            description: 'Declares whether the property definition translates to an attribute instead of an element. Default value is false. If nodeType is present, this field MUST NOT be present.Deprecated: Use nodeType: "attribute" instead of attribute: true.',
+        },
+        wrapped: {
+            type: 'boolean',
+            description: 'MAY be used only for an array definition. Signifies whether the array is wrapped (for example, <books><book/><book/></books>) or unwrapped (<book/><book/>). Default value is false. The definition takes effect only when defined alongside type being "array" (outside the items). If nodeType is present, this field MUST NOT be present. Deprecated: Use nodeType: "element" instead of wrapped: true.',
+        }, // Deprecated in OAS 3.2: Use nodeType: "element" instead
+    },
+    extensionsPrefix: 'x-',
+    description: 'A metadata object that allows for more fine-tuned XML model definitions. When using a Schema Object with XML, if no XML Object is present, the behavior is determined by the XML Object’s default field values.',
+};
+// based on draft-2020-12
+const Schema = {
+    ...Oas3_1Types.Schema,
+    properties: {
+        ...Oas3_1Types.Schema.properties,
+        xml: 'Xml',
+    },
+};
+export const Oas3_2Types = {
+    ...Oas3_1Types,
+    Root,
+    Tag,
+    Server,
+    SecurityScheme,
+    OAuth2Flows,
+    DeviceAuthorization,
+    PathItem,
+    Parameter,
+    Response,
+    MediaType,
+    Discriminator,
+    Example,
+    Xml,
+    Schema,
+    Components,
+    NamedMediaTypes: mapOf('MediaTypesMap'),
+};
+//# sourceMappingURL=oas3_2.js.map