@kubb/agent 4.33.1 → 4.33.2

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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,83 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,32 @@
+export const SpecDiscriminatorDefaultMapping = () => {
+    let componentsSchemaNames;
+    return {
+        NamedSchemas: {
+            enter(schemas) {
+                componentsSchemaNames = Object.keys(schemas);
+            },
+        },
+        Schema: {
+            leave(schema, ctx) {
+                if (!schema.discriminator?.propertyName)
+                    return;
+                const defaultMapping = schema.discriminator.defaultMapping;
+                const isPropertyOptional = !schema.required?.includes(schema.discriminator.propertyName);
+                if (isPropertyOptional && defaultMapping === undefined) {
+                    ctx.report({
+                        message: `Discriminator with optional property '${schema.discriminator.propertyName}' must include a defaultMapping field.`,
+                        location: ctx.location.child('discriminator'),
+                    });
+                    return;
+                }
+                if (defaultMapping !== 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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,65 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,82 @@
+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

@@ -0,0 +1,28 @@
+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

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/openrpc/spec-no-required-params-after-optional.js

@@ -0,0 +1,31 @@
+export const NoRequiredParamsAfterOptional = () => {
+    return {
+        Method: {
+            leave(method, { report, resolve, location }) {
+                if (!method.params || !Array.isArray(method.params))
+                    return;
+                let foundOptional = false;
+                method.params.forEach((paramOrRef, index) => {
+                    const resolved = resolve(paramOrRef);
+                    if (!resolved.node)
+                        return;
+                    const param = resolved.node;
+                    const paramName = param.name;
+                    if (!paramName)
+                        return;
+                    const isRequired = param.required === true;
+                    if (!isRequired) {
+                        foundOptional = true;
+                    }
+                    else if (foundOptional) {
+                        report({
+                            message: `Required parameter '${param.name}' must be positioned before optional parameters.`,
+                            location: location.child([index, 'name']),
+                        });
+                    }
+                });
+            },
+        },
+    };
+};
+//# sourceMappingURL=spec-no-required-params-after-optional.js.map