@kubb/agent 5.0.0-alpha.36 → 5.0.0-alpha.38

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/oas3/no-undefined-server-variable.js

@@ -1,28 +0,0 @@
-export const NoUndefinedServerVariable = () => {
-    return {
-        Server(server, { report, location }) {
-            if (!server?.url)
-                return;
-            const urlVariables = server.url.match(/{[^}]+}/g)?.map((e) => e.slice(1, e.length - 1)) || [];
-            const definedVariables = (server?.variables && Object.keys(server.variables)) || [];
-            for (const serverVar of urlVariables) {
-                if (!definedVariables.includes(serverVar)) {
-                    report({
-                        message: `The \`${serverVar}\` variable is not defined in the \`variables\` objects.`,
-                        location: location.child(['url']),
-                    });
-                }
-            }
-            for (const definedServerVar of definedVariables) {
-                if (!urlVariables.includes(definedServerVar)) {
-                    report({
-                        message: `The \`${definedServerVar}\` variable is not used in the server's \`url\` field.`,
-                        location: location.child(['variables', definedServerVar]).key(),
-                        from: location.child('url'),
-                    });
-                }
-            }
-        },
-    };
-};
-//# sourceMappingURL=no-undefined-server-variable.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/oas3/no-unused-components.js

@@ -1,83 +0,0 @@
-export const NoUnusedComponents = () => {
-    const components = new Map();
-    function registerComponent(location, name) {
-        components.set(location.absolutePointer, {
-            used: components.get(location.absolutePointer)?.used || false,
-            location,
-            name,
-        });
-    }
-    return {
-        ref(ref, { type, resolve, key, location }) {
-            if ([
-                'Schema',
-                'Header',
-                'Parameter',
-                'Response',
-                'Example',
-                'RequestBody',
-                'MediaTypesMap',
-            ].includes(type.name)) {
-                const resolvedRef = resolve(ref);
-                if (!resolvedRef.location)
-                    return;
-                components.set(resolvedRef.location.absolutePointer, {
-                    used: true,
-                    name: key.toString(),
-                    location,
-                });
-            }
-        },
-        Root: {
-            leave(_, { report }) {
-                components.forEach((usageInfo) => {
-                    if (!usageInfo.used) {
-                        report({
-                            message: `Component: "${usageInfo.name}" is never used.`,
-                            location: usageInfo.location.key(),
-                        });
-                    }
-                });
-            },
-        },
-        NamedSchemas: {
-            Schema(schema, { location, key }) {
-                if (!schema.allOf) {
-                    // FIXME: find a better way to detect possible discriminator
-                    registerComponent(location, key.toString());
-                }
-            },
-        },
-        NamedParameters: {
-            Parameter(_parameter, { location, key }) {
-                registerComponent(location, key.toString());
-            },
-        },
-        NamedResponses: {
-            Response(_response, { location, key }) {
-                registerComponent(location, key.toString());
-            },
-        },
-        NamedExamples: {
-            Example(_example, { location, key }) {
-                registerComponent(location, key.toString());
-            },
-        },
-        NamedRequestBodies: {
-            RequestBody(_requestBody, { location, key }) {
-                registerComponent(location, key.toString());
-            },
-        },
-        NamedHeaders: {
-            Header(_header, { location, key }) {
-                registerComponent(location, key.toString());
-            },
-        },
-        NamedMediaTypes: {
-            MediaTypesMap(_mediaTypesMap, { location, key }) {
-                registerComponent(location, key.toString());
-            },
-        },
-    };
-};
-//# sourceMappingURL=no-unused-components.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/oas3/nullable-type-sibling.js

@@ -1,15 +0,0 @@
-export const NullableTypeSibling = () => {
-    return {
-        Schema: {
-            leave(schema, ctx) {
-                if ('nullable' in schema && !('type' in schema)) {
-                    ctx.report({
-                        message: `The \`type\` field must be defined when the \`nullable\` field is used.`,
-                        location: ctx.location.child(['nullable']),
-                    });
-                }
-            },
-        },
-    };
-};
-//# sourceMappingURL=nullable-type-sibling.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/oas3/operation-4xx-problem-details-rfc7807.js

@@ -1,33 +0,0 @@
-import { validateDefinedAndNonEmpty } from '../utils.js';
-/**
- * Validation according to rfc7807 - https://datatracker.ietf.org/doc/html/rfc7807
- */
-export const Operation4xxProblemDetailsRfc7807 = () => {
-    return {
-        Response: {
-            skip(_, key) {
-                return !/4[Xx0-9]{2}/.test(`${key}`);
-            },
-            enter(response, { report, location }) {
-                if (!response.content || !response.content['application/problem+json'])
-                    report({
-                        message: 'Response `4xx` must have content-type `application/problem+json`.',
-                        location: location.key(),
-                    });
-            },
-            MediaType: {
-                skip(_, key) {
-                    return key !== 'application/problem+json';
-                },
-                enter(media, ctx) {
-                    validateDefinedAndNonEmpty('schema', media, ctx);
-                },
-                SchemaProperties(schema, ctx) {
-                    validateDefinedAndNonEmpty('type', schema, ctx);
-                    validateDefinedAndNonEmpty('title', schema, ctx);
-                },
-            },
-        },
-    };
-};
-//# sourceMappingURL=operation-4xx-problem-details-rfc7807.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/oas3/request-mime-type.js

@@ -1,28 +0,0 @@
-import { validateMimeTypeOAS3 } from '../../utils/validate-mime-type.js';
-export const RequestMimeType = ({ allowedValues }) => {
-    return {
-        Paths: {
-            RequestBody: {
-                leave(requestBody, ctx) {
-                    validateMimeTypeOAS3({ type: 'consumes', value: requestBody }, ctx, allowedValues);
-                },
-            },
-            Callback: {
-                RequestBody() { },
-                Response: {
-                    leave(response, ctx) {
-                        validateMimeTypeOAS3({ type: 'consumes', value: response }, ctx, allowedValues);
-                    },
-                },
-            },
-        },
-        WebhooksMap: {
-            Response: {
-                leave(response, ctx) {
-                    validateMimeTypeOAS3({ type: 'consumes', value: response }, ctx, allowedValues);
-                },
-            },
-        },
-    };
-};
-//# sourceMappingURL=request-mime-type.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/oas3/response-contains-property.js

@@ -1,36 +0,0 @@
-import { getMatchingStatusCodeRange } from '../../utils/get-matching-status-code-range.js';
-export const ResponseContainsProperty = (options) => {
-    const names = options.names || {};
-    let key;
-    return {
-        Operation: {
-            Response: {
-                skip: (_response, key) => {
-                    return `${key}` === '204';
-                },
-                enter: (_response, ctx) => {
-                    key = ctx.key;
-                },
-                MediaType: {
-                    Schema(schema, { report, location }) {
-                        if (schema.type !== 'object')
-                            return;
-                        const expectedProperties = names[key] ||
-                            names[getMatchingStatusCodeRange(key)] ||
-                            names[getMatchingStatusCodeRange(key).toLowerCase()] ||
-                            [];
-                        for (const expectedProperty of expectedProperties) {
-                            if (!schema.properties?.[expectedProperty]) {
-                                report({
-                                    message: `Response object must contain a top-level "${expectedProperty}" property.`,
-                                    location: location.child('properties').key(),
-                                });
-                            }
-                        }
-                    },
-                },
-            },
-        },
-    };
-};
-//# sourceMappingURL=response-contains-property.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/oas3/response-mime-type.js

@@ -1,28 +0,0 @@
-import { validateMimeTypeOAS3 } from '../../utils/validate-mime-type.js';
-export const ResponseMimeType = ({ allowedValues }) => {
-    return {
-        Paths: {
-            Response: {
-                leave(response, ctx) {
-                    validateMimeTypeOAS3({ type: 'produces', value: response }, ctx, allowedValues);
-                },
-            },
-            Callback: {
-                Response() { },
-                RequestBody: {
-                    leave(requestBody, ctx) {
-                        validateMimeTypeOAS3({ type: 'produces', value: requestBody }, ctx, allowedValues);
-                    },
-                },
-            },
-        },
-        WebhooksMap: {
-            RequestBody: {
-                leave(requestBody, ctx) {
-                    validateMimeTypeOAS3({ type: 'produces', value: requestBody }, ctx, allowedValues);
-                },
-            },
-        },
-    };
-};
-//# sourceMappingURL=response-mime-type.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/oas3/spec-components-invalid-map-name.js

@@ -1,59 +0,0 @@
-export const SpecComponentsInvalidMapName = () => {
-    const KEYS_REGEX = '^[a-zA-Z0-9\\.\\-_]+$';
-    function validateKey(key, report, location, component) {
-        if (!new RegExp(KEYS_REGEX).test(key)) {
-            report({
-                message: `The map key in ${component} "${key}" does not match the regular expression "${KEYS_REGEX}"`,
-                location: location.key(),
-            });
-        }
-    }
-    return {
-        NamedSchemas: {
-            Schema(_node, { key, report, location }) {
-                validateKey(key, report, location, 'schemas');
-            },
-        },
-        NamedParameters: {
-            Parameter(_node, { key, report, location }) {
-                validateKey(key, report, location, 'parameters');
-            },
-        },
-        NamedResponses: {
-            Response(_node, { key, report, location }) {
-                validateKey(key, report, location, 'responses');
-            },
-        },
-        NamedExamples: {
-            Example(_node, { key, report, location }) {
-                validateKey(key, report, location, 'examples');
-            },
-        },
-        NamedRequestBodies: {
-            RequestBody(_node, { key, report, location }) {
-                validateKey(key, report, location, 'requestBodies');
-            },
-        },
-        NamedHeaders: {
-            Header(_node, { key, report, location }) {
-                validateKey(key, report, location, 'headers');
-            },
-        },
-        NamedSecuritySchemes: {
-            SecurityScheme(_node, { key, report, location }) {
-                validateKey(key, report, location, 'securitySchemes');
-            },
-        },
-        NamedLinks: {
-            Link(_node, { key, report, location }) {
-                validateKey(key, report, location, 'links');
-            },
-        },
-        NamedCallbacks: {
-            Callback(_node, { key, report, location }) {
-                validateKey(key, report, location, 'callbacks');
-            },
-        },
-    };
-};
-//# sourceMappingURL=spec-components-invalid-map-name.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/oas3/spec-discriminator-defaultMapping.js

@@ -1,53 +0,0 @@
-import { resolveSchema } from '../utils.js';
-export const SpecDiscriminatorDefaultMapping = () => {
-    let componentsSchemaNames = [];
-    return {
-        Root: {
-            enter(root) {
-                // Starting from the Root to ensure it runs before other visitors that might use componentsSchemaNames.
-                componentsSchemaNames = Object.keys(root.components?.schemas || {});
-            },
-        },
-        Schema: {
-            leave(schema, ctx) {
-                const discriminatedPropertyName = schema.discriminator?.propertyName;
-                if (!discriminatedPropertyName)
-                    return;
-                const defaultMapping = schema.discriminator?.defaultMapping;
-                if (defaultMapping === undefined) {
-                    const visited = new Set();
-                    const isDiscriminatorPropertyRequired = (schemaOrRef, resolveFrom) => {
-                        const resolved = resolveSchema(schemaOrRef, ctx, resolveFrom);
-                        if (!resolved.schema || visited.has(resolved.schema)) {
-                            return true;
-                        }
-                        visited.add(resolved.schema);
-                        if (resolved.schema.required?.includes(discriminatedPropertyName) ||
-                            resolved.schema.allOf?.some((s) => isDiscriminatorPropertyRequired(s, resolved.location)) ||
-                            resolved.schema.oneOf?.every((s) => isDiscriminatorPropertyRequired(s, resolved.location)) ||
-                            resolved.schema.anyOf?.every((s) => isDiscriminatorPropertyRequired(s, resolved.location))) {
-                            return true;
-                        }
-                        return false;
-                    };
-                    if (!isDiscriminatorPropertyRequired(schema)) {
-                        ctx.report({
-                            message: `Discriminator with optional property '${discriminatedPropertyName}' must include a defaultMapping field.`,
-                            location: ctx.location.child('discriminator'),
-                        });
-                    }
-                }
-                else {
-                    if (ctx.resolve({ $ref: defaultMapping }).node === undefined &&
-                        !componentsSchemaNames.includes(defaultMapping)) {
-                        ctx.report({
-                            message: `defaultMapping value '${defaultMapping}' does not point to an existing schema component.`,
-                            location: ctx.location.child(['discriminator', 'defaultMapping']),
-                        });
-                    }
-                }
-            },
-        },
-    };
-};
-//# sourceMappingURL=spec-discriminator-defaultMapping.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/oas3/spec-example-values.js

@@ -1,31 +0,0 @@
-export const SpecExampleValues = () => {
-    return {
-        Example({ value, externalValue, dataValue, serializedValue }, { report, location }) {
-            if (value !== undefined && externalValue !== undefined) {
-                report({
-                    message: "The 'value' and 'externalValue' fields of an example object are mutually exclusive.",
-                    location: location,
-                });
-            }
-            if (serializedValue !== undefined && externalValue !== undefined) {
-                report({
-                    message: "The 'serializedValue' and 'externalValue' fields of an example object are mutually exclusive.",
-                    location: location,
-                });
-            }
-            if (value !== undefined && dataValue !== undefined) {
-                report({
-                    message: "The 'value' filed must be absent if 'dataValue' is present in an example object.",
-                    location: location.child('value').key(),
-                });
-            }
-            if (value !== undefined && serializedValue !== undefined) {
-                report({
-                    message: "The 'value' filed must be absent if 'serializedValue' is present in an example object.",
-                    location: location.child('value').key(),
-                });
-            }
-        },
-    };
-};
-//# sourceMappingURL=spec-example-values.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/oas3/spec-no-invalid-encoding-combinations.js

@@ -1,16 +0,0 @@
-export const SpecNoInvalidEncodingCombinations = () => {
-    return {
-        MediaType: {
-            leave(mediaType, ctx) {
-                if (('prefixEncoding' in mediaType && 'encoding' in mediaType) ||
-                    ('itemEncoding' in mediaType && 'encoding' in mediaType)) {
-                    ctx.report({
-                        message: "The 'encoding' field cannot be used together with 'prefixEncoding' or 'itemEncoding'.",
-                        location: ctx.location.child('encoding').key(),
-                    });
-                }
-            },
-        },
-    };
-};
-//# sourceMappingURL=spec-no-invalid-encoding-combinations.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/oas3/spec-no-invalid-tag-parents.js

@@ -1,38 +0,0 @@
-export const SpecNoInvalidTagParents = () => {
-    let tags;
-    return {
-        Root: {
-            enter(root) {
-                tags = root.tags ?? [];
-            },
-        },
-        Tag: {
-            leave(tag, { report, location }) {
-                if (tag?.parent === undefined) {
-                    return;
-                }
-                if (!tags.find((t) => t.name === tag.parent)) {
-                    report({
-                        message: `Tag parent '${tag.parent}' is not defined in the API description.`,
-                        location: location.child('parent'),
-                    });
-                    return;
-                }
-                const visited = new Set(tag.name);
-                let currentParent = tag.parent;
-                while (currentParent !== undefined) {
-                    if (visited.has(currentParent)) {
-                        report({
-                            message: `Circular reference detected in tag parent hierarchy for tag '${tag.name}'.`,
-                            location: location.child('parent'),
-                        });
-                        return;
-                    }
-                    visited.add(currentParent);
-                    currentParent = tags.find((t) => t.name === currentParent)?.parent;
-                }
-            },
-        },
-    };
-};
-//# sourceMappingURL=spec-no-invalid-tag-parents.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/oas3/spec-querystring-parameters.js

@@ -1,65 +0,0 @@
-function countQuerystring(parameters) {
-    return parameters.filter((p) => !('$ref' in p) && p.in === 'querystring').length;
-}
-function reportIfMultipleQuerystring(querystringCount, ctx) {
-    const parametersLocation = ctx.location.child('parameters');
-    if (querystringCount > 1) {
-        ctx.report({
-            message: 'Parameters with `in: querystring` should be defined only once per path/operation parameter set.',
-            location: parametersLocation,
-        });
-    }
-}
-function checkMixedUsage(parameter, parameterLocation, state, ctx) {
-    if (parameter.in === 'query') {
-        if (state.querystringLocation) {
-            ctx.report({
-                message: 'Parameters with `in: query` cannot be used together with `in: querystring` in the same operation/path parameter set.',
-                location: parameterLocation,
-            });
-        }
-        state.queryLocation ??= parameterLocation;
-        return;
-    }
-    if (parameter.in === 'querystring') {
-        if (state.queryLocation) {
-            ctx.report({
-                message: 'Parameters with `in: querystring` cannot be used together with `in: query` in the same operation/path parameter set.',
-                location: parameterLocation,
-            });
-        }
-        state.querystringLocation ??= parameterLocation;
-    }
-}
-export const SpecQuerystringParameters = () => {
-    let pathState = {};
-    let operationState = {};
-    let pathQuerystringCount = 0;
-    return {
-        PathItem: {
-            enter(pathItem, ctx) {
-                pathState = {};
-                operationState = {};
-                pathQuerystringCount = 0;
-                reportIfMultipleQuerystring(countQuerystring(pathItem.parameters || []), ctx);
-            },
-            Parameter(parameter, ctx) {
-                checkMixedUsage(parameter, ctx.location, pathState, ctx);
-                if (parameter.in === 'querystring') {
-                    pathQuerystringCount += 1;
-                }
-            },
-            Operation: {
-                enter(operation, ctx) {
-                    operationState = { ...pathState };
-                    const totalQuerystring = pathQuerystringCount + countQuerystring(operation.parameters || []);
-                    reportIfMultipleQuerystring(totalQuerystring, ctx);
-                },
-                Parameter(parameter, ctx) {
-                    checkMixedUsage(parameter, ctx.location, operationState, ctx);
-                },
-            },
-        },
-    };
-};
-//# sourceMappingURL=spec-querystring-parameters.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/openrpc/index.js

@@ -1,20 +0,0 @@
-import { Assertions } from '../common/assertions/index.js';
-import { InfoContact } from '../common/info-contact.js';
-import { InfoLicense } from '../common/info-license.js';
-import { NoUnresolvedRefs } from '../common/no-unresolved-refs.js';
-import { Struct } from '../common/struct.js';
-import { NoUnusedComponents } from './no-unused-components.js';
-import { NoDuplicatedMethodParams } from './spec-no-duplicated-method-params.js';
-import { NoRequiredParamsAfterOptional } from './spec-no-required-params-after-optional.js';
-export const rules = {
-    struct: Struct,
-    'no-unresolved-refs': NoUnresolvedRefs,
-    assertions: Assertions,
-    'info-license': InfoLicense,
-    'no-unused-components': NoUnusedComponents,
-    'info-contact': InfoContact,
-    'spec-no-duplicated-method-params': NoDuplicatedMethodParams,
-    'spec-no-required-params-after-optional': NoRequiredParamsAfterOptional,
-};
-export const preprocessors = {};
-//# sourceMappingURL=index.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/openrpc/no-unused-components.js

@@ -1,82 +0,0 @@
-export const NoUnusedComponents = () => {
-    const components = new Map();
-    function registerComponent(location, name) {
-        components.set(location.absolutePointer, {
-            used: components.get(location.absolutePointer)?.used || false,
-            location,
-            name,
-        });
-    }
-    return {
-        ref(ref, { type, resolve, key, location }) {
-            if ([
-                'Schema',
-                'ContentDescriptor',
-                'Example',
-                'Link',
-                'ErrorObject',
-                'ExamplePairing',
-                'Tag',
-            ].includes(type.name)) {
-                const resolvedRef = resolve(ref);
-                if (!resolvedRef.location)
-                    return;
-                components.set(resolvedRef.location.absolutePointer, {
-                    used: true,
-                    name: key.toString(),
-                    location,
-                });
-            }
-        },
-        Root: {
-            leave(_, { report }) {
-                components.forEach((usageInfo) => {
-                    if (!usageInfo.used) {
-                        report({
-                            message: `Component: "${usageInfo.name}" is never used.`,
-                            location: usageInfo.location.key(),
-                        });
-                    }
-                });
-            },
-        },
-        NamedSchemas: {
-            Schema(schema, { location, key }) {
-                if (!schema.allOf) {
-                    registerComponent(location, key.toString());
-                }
-            },
-        },
-        NamedContentDescriptors: {
-            ContentDescriptor(_node, { location, key }) {
-                registerComponent(location, key.toString());
-            },
-        },
-        NamedExamples: {
-            Example(_node, { location, key }) {
-                registerComponent(location, key.toString());
-            },
-        },
-        NamedLinks: {
-            Link(_node, { location, key }) {
-                registerComponent(location, key.toString());
-            },
-        },
-        NamedErrors: {
-            ErrorObject(_node, { location, key }) {
-                registerComponent(location, key.toString());
-            },
-        },
-        NamedExamplePairingObjects: {
-            ExamplePairing(_node, { location, key }) {
-                registerComponent(location, key.toString());
-            },
-        },
-        NamedTags: {
-            Tag(_node, { location, key }) {
-                registerComponent(location, key.toString());
-            },
-        },
-    };
-};
-//# sourceMappingURL=no-unused-components.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/openrpc/spec-no-duplicated-method-params.js

@@ -1,28 +0,0 @@
-export const NoDuplicatedMethodParams = () => {
-    return {
-        Method: {
-            leave(method, { report, resolve, location }) {
-                if (!method.params || !Array.isArray(method.params))
-                    return;
-                const seenParams = new Set();
-                method.params.forEach((paramOrRef, index) => {
-                    const resolved = resolve(paramOrRef);
-                    if (!resolved.node)
-                        return;
-                    const param = resolved.node;
-                    const paramName = param.name;
-                    if (!paramName)
-                        return;
-                    if (seenParams.has(paramName)) {
-                        report({
-                            message: `Parameter names must be unique. Duplicate parameter name '${param.name}' found.`,
-                            location: location.child([index, 'name']),
-                        });
-                    }
-                    seenParams.add(paramName);
-                });
-            },
-        },
-    };
-};
-//# sourceMappingURL=spec-no-duplicated-method-params.js.map