@kubb/agent 4.33.1 → 4.33.2

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/no-http-verbs-in-paths.js

@@ -0,0 +1,31 @@
+import { isPathParameter } from '../../utils/is-path-parameter.js';
+import { splitCamelCaseIntoWords } from '../../utils/split-camel-case-into-words.js';
+const httpMethods = ['get', 'head', 'post', 'put', 'patch', 'delete', 'options', 'trace'];
+export const NoHttpVerbsInPaths = ({ splitIntoWords }) => {
+    return {
+        PathItem(_path, { key, report, location }) {
+            const pathKey = key.toString();
+            if (!pathKey.startsWith('/'))
+                return;
+            const pathSegments = pathKey.split('/');
+            for (const pathSegment of pathSegments) {
+                if (!pathSegment || isPathParameter(pathSegment))
+                    continue;
+                const isHttpMethodIncluded = (method) => {
+                    return splitIntoWords
+                        ? splitCamelCaseIntoWords(pathSegment).has(method)
+                        : pathSegment.toLocaleLowerCase().includes(method);
+                };
+                for (const method of httpMethods) {
+                    if (isHttpMethodIncluded(method)) {
+                        report({
+                            message: `path \`${pathKey}\` should not contain http verb ${method}`,
+                            location: location.key(),
+                        });
+                    }
+                }
+            }
+        },
+    };
+};
+//# sourceMappingURL=no-http-verbs-in-paths.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/no-identical-paths.js

@@ -0,0 +1,21 @@
+export const NoIdenticalPaths = () => {
+    return {
+        Paths(pathMap, { report, location }) {
+            const Paths = new Map();
+            for (const pathName of Object.keys(pathMap)) {
+                const id = pathName.replace(/{.+?}/g, '{VARIABLE}');
+                const existingSamePath = Paths.get(id);
+                if (existingSamePath) {
+                    report({
+                        message: `The path already exists which differs only by path parameter name(s): \`${existingSamePath}\` and \`${pathName}\`.`,
+                        location: location.child([pathName]).key(),
+                    });
+                }
+                else {
+                    Paths.set(id, pathName);
+                }
+            }
+        },
+    };
+};
+//# sourceMappingURL=no-identical-paths.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/no-invalid-parameter-examples.js

@@ -0,0 +1,32 @@
+import { isDefined } from '../../utils/is-defined.js';
+import { isPlainObject } from '../../utils/is-plain-object.js';
+import { validateExample } from '../utils.js';
+export const NoInvalidParameterExamples = (opts) => {
+    return {
+        Parameter: {
+            leave(parameter, ctx) {
+                if (isDefined(parameter.example)) {
+                    validateExample(parameter.example, parameter.schema, {
+                        location: ctx.location.child('example'),
+                        ctx,
+                        allowAdditionalProperties: !!opts.allowAdditionalProperties,
+                        ajvContext: { apiContext: 'request' },
+                    });
+                }
+                if (isPlainObject(parameter.examples)) {
+                    for (const [key, example] of Object.entries(parameter.examples)) {
+                        if (isPlainObject(example) && 'value' in example) {
+                            validateExample(example.value, parameter.schema, {
+                                location: ctx.location.child(['examples', key]),
+                                ctx,
+                                allowAdditionalProperties: !!opts.allowAdditionalProperties,
+                                ajvContext: { apiContext: 'request' },
+                            });
+                        }
+                    }
+                }
+            },
+        },
+    };
+};
+//# sourceMappingURL=no-invalid-parameter-examples.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/no-invalid-schema-examples.js

@@ -0,0 +1,34 @@
+import { isDefined } from '../../utils/is-defined.js';
+import { validateExample } from '../utils.js';
+export const NoInvalidSchemaExamples = (opts) => {
+    return {
+        Schema: {
+            leave(schema, ctx) {
+                const examples = schema.examples;
+                if (Array.isArray(examples)) {
+                    for (const example of examples) {
+                        validateExample(example, schema, {
+                            location: ctx.location.child(['examples', examples.indexOf(example)]),
+                            ctx,
+                            allowAdditionalProperties: !!opts.allowAdditionalProperties,
+                        });
+                    }
+                }
+                if (isDefined(schema.example)) {
+                    // Handle nullable example for OAS3
+                    if (schema.nullable === true &&
+                        schema.example === null &&
+                        schema.type !== undefined) {
+                        return;
+                    }
+                    validateExample(schema.example, schema, {
+                        location: ctx.location.child('example'),
+                        ctx,
+                        allowAdditionalProperties: !!opts.allowAdditionalProperties,
+                    });
+                }
+            },
+        },
+    };
+};
+//# sourceMappingURL=no-invalid-schema-examples.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/no-path-trailing-slash.js

@@ -0,0 +1,13 @@
+export const NoPathTrailingSlash = () => {
+    return {
+        PathItem(_path, { report, key, rawLocation }) {
+            if (key.endsWith('/') && key !== '/') {
+                report({
+                    message: `\`${key}\` should not have a trailing slash.`,
+                    location: rawLocation.key(),
+                });
+            }
+        },
+    };
+};
+//# sourceMappingURL=no-path-trailing-slash.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/no-required-schema-properties-undefined.js

@@ -0,0 +1,78 @@
+import { isRef } from '../../ref-utils.js';
+import { getOwn } from '../../utils/get-own.js';
+export const NoRequiredSchemaPropertiesUndefined = () => {
+    const parents = [];
+    return {
+        Schema: {
+            leave(_) {
+                parents.pop();
+            },
+            enter(schema, { location, report, resolve }) {
+                parents.push(schema);
+                if (!schema.required)
+                    return;
+                const visitedSchemas = new Set();
+                const elevateProperties = (schema, from, includeFirstLevelExclusiveSchemas = true) => {
+                    // Check if the schema has been visited before processing it
+                    if (visitedSchemas.has(schema)) {
+                        return {};
+                    }
+                    visitedSchemas.add(schema);
+                    if (isRef(schema)) {
+                        const resolved = resolve(schema, from);
+                        if (!resolved.node) {
+                            return {};
+                        }
+                        return elevateProperties(resolved.node, resolved.location?.source.absoluteRef);
+                    }
+                    return Object.assign({}, schema.properties, ...(schema.allOf?.map((s) => elevateProperties(s, from)) ?? []), ...(('anyOf' in schema && includeFirstLevelExclusiveSchemas
+                        ? schema.anyOf?.map((s) => elevateProperties(s, from))
+                        : undefined) ?? []), ...(('oneOf' in schema && includeFirstLevelExclusiveSchemas
+                        ? schema.oneOf?.map((s) => elevateProperties(s, from))
+                        : undefined) ?? []));
+                };
+                /**
+                 * The index to use to lookup grand parent schemas when dealing with composed schemas.
+                 * @summary The current schema should always end up with under ../anyOf/1, if we get multiple ancestors, they should always be a multiple.
+                 */
+                const locationLookupIndex = 2;
+                const getParentSchema = (lookupIndex) => {
+                    lookupIndex++;
+                    if (!parents || parents.length < lookupIndex)
+                        return undefined;
+                    const parent = parents[parents.length - lookupIndex];
+                    return parent;
+                };
+                const recursivelyGetParentProperties = (splitLocation, parentLookupIndex = 0) => {
+                    const isMemberOfComposedType = splitLocation.length > locationLookupIndex &&
+                        !isNaN(parseInt(splitLocation[splitLocation.length - 1])) &&
+                        !!/(allOf|oneOf|anyOf)/.exec(splitLocation[splitLocation.length - locationLookupIndex]);
+                    const parentSchema = isMemberOfComposedType
+                        ? getParentSchema(++parentLookupIndex)
+                        : undefined;
+                    const grandParentProperties = splitLocation.length >= locationLookupIndex + locationLookupIndex
+                        ? recursivelyGetParentProperties(splitLocation.slice(0, -locationLookupIndex), parentLookupIndex)
+                        : {};
+                    return parentSchema
+                        ? {
+                            ...elevateProperties(parentSchema, undefined, false),
+                            ...grandParentProperties,
+                        }
+                        : undefined;
+                };
+                const allProperties = elevateProperties(schema);
+                const parentProperties = recursivelyGetParentProperties(location.pointer.split('/'));
+                for (const [i, requiredProperty] of schema.required.entries()) {
+                    if ((!allProperties || getOwn(allProperties, requiredProperty) === undefined) &&
+                        (!parentProperties || getOwn(parentProperties, requiredProperty) === undefined)) {
+                        report({
+                            message: `Required property '${requiredProperty}' is undefined.`,
+                            location: location.child(['required', i]),
+                        });
+                    }
+                }
+            },
+        },
+    };
+};
+//# sourceMappingURL=no-required-schema-properties-undefined.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/no-schema-type-mismatch.js

@@ -0,0 +1,19 @@
+export const NoSchemaTypeMismatch = () => {
+    return {
+        Schema(schema, { report, location }) {
+            if (schema.type === 'object' && schema.items) {
+                report({
+                    message: "Schema type mismatch: 'object' type should not contain 'items' field.",
+                    location: location.child('items'),
+                });
+            }
+            if (schema.type === 'array' && schema.properties) {
+                report({
+                    message: "Schema type mismatch: 'array' type should not contain 'properties' field.",
+                    location: location.child('properties'),
+                });
+            }
+        },
+    };
+};
+//# sourceMappingURL=no-schema-type-mismatch.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/no-unresolved-refs.js

@@ -0,0 +1,42 @@
+import { YamlParseError } from '../../errors/yaml-parse-error.js';
+export const NoUnresolvedRefs = () => {
+    return {
+        ref: {
+            leave(_, { report, location }, resolved) {
+                if (resolved.node !== undefined)
+                    return;
+                reportUnresolvedRef(resolved, report, location);
+            },
+        },
+        DiscriminatorMapping(mapping, { report, resolve, location }) {
+            for (const mappingName of Object.keys(mapping)) {
+                const resolved = resolve({ $ref: mapping[mappingName] });
+                if (resolved.node !== undefined)
+                    return;
+                reportUnresolvedRef(resolved, report, location.child(mappingName));
+            }
+        },
+    };
+};
+export function reportUnresolvedRef(resolved, report, location) {
+    const error = resolved.error;
+    if (error instanceof YamlParseError) {
+        report({
+            message: 'Failed to parse: ' + error.message,
+            location: {
+                source: error.source,
+                pointer: undefined,
+                start: {
+                    col: error.col,
+                    line: error.line,
+                },
+            },
+        });
+    }
+    const message = resolved.error?.message;
+    report({
+        location,
+        message: `Can't resolve $ref${message ? ': ' + message : ''}`,
+    });
+}
+//# sourceMappingURL=no-unresolved-refs.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/operation-2xx-response.js

@@ -0,0 +1,20 @@
+import { validateResponseCodes } from '../utils.js';
+export const Operation2xxResponse = ({ validateWebhooks }) => {
+    return {
+        Paths: {
+            Responses(responses, { report }) {
+                const codes = Object.keys(responses || {});
+                validateResponseCodes(codes, '2XX', { report });
+            },
+        },
+        WebhooksMap: {
+            Responses(responses, { report }) {
+                if (!validateWebhooks)
+                    return;
+                const codes = Object.keys(responses || {});
+                validateResponseCodes(codes, '2XX', { report });
+            },
+        },
+    };
+};
+//# sourceMappingURL=operation-2xx-response.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/operation-4xx-response.js

@@ -0,0 +1,20 @@
+import { validateResponseCodes } from '../utils.js';
+export const Operation4xxResponse = ({ validateWebhooks }) => {
+    return {
+        Paths: {
+            Responses(responses, { report }) {
+                const codes = Object.keys(responses || {});
+                validateResponseCodes(codes, '4XX', { report });
+            },
+        },
+        WebhooksMap: {
+            Responses(responses, { report }) {
+                if (!validateWebhooks)
+                    return;
+                const codes = Object.keys(responses || {});
+                validateResponseCodes(codes, '4XX', { report });
+            },
+        },
+    };
+};
+//# sourceMappingURL=operation-4xx-response.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/operation-description.js

@@ -0,0 +1,9 @@
+import { validateDefinedAndNonEmpty } from '../utils.js';
+export const OperationDescription = () => {
+    return {
+        Operation(operation, ctx) {
+            validateDefinedAndNonEmpty('description', operation, ctx);
+        },
+    };
+};
+//# sourceMappingURL=operation-description.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/operation-operationId-unique.js

@@ -0,0 +1,17 @@
+export const OperationIdUnique = () => {
+    const seenOperations = new Set();
+    return {
+        Operation(operation, { report, location }) {
+            if (!operation.operationId)
+                return;
+            if (seenOperations.has(operation.operationId)) {
+                report({
+                    message: 'Every operation must have a unique `operationId`.',
+                    location: location.child([operation.operationId]),
+                });
+            }
+            seenOperations.add(operation.operationId);
+        },
+    };
+};
+//# sourceMappingURL=operation-operationId-unique.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/operation-operationId-url-safe.js

@@ -0,0 +1,15 @@
+// eslint-disable-next-line no-useless-escape
+const validUrlSymbols = /^[A-Za-z0-9-._~:/?#\[\]@!\$&'()*+,;=]*$/;
+export const OperationIdUrlSafe = () => {
+    return {
+        Operation(operation, { report, location }) {
+            if (operation.operationId && !validUrlSymbols.test(operation.operationId)) {
+                report({
+                    message: 'Operation `operationId` should not have URL invalid characters.',
+                    location: location.child(['operationId']),
+                });
+            }
+        },
+    };
+};
+//# sourceMappingURL=operation-operationId-url-safe.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/operation-operationId.js

@@ -0,0 +1,13 @@
+import { validateDefinedAndNonEmpty } from '../utils.js';
+export const OperationOperationId = () => {
+    return {
+        Root: {
+            PathItem: {
+                Operation(operation, ctx) {
+                    validateDefinedAndNonEmpty('operationId', operation, ctx);
+                },
+            },
+        },
+    };
+};
+//# sourceMappingURL=operation-operationId.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/operation-parameters-unique.js

@@ -0,0 +1,37 @@
+export const OperationParametersUnique = () => {
+    let seenPathParams;
+    let seenOperationParams;
+    return {
+        PathItem: {
+            enter() {
+                seenPathParams = new Set();
+            },
+            Parameter(parameter, { report, key, parentLocations }) {
+                const paramId = `${parameter.in}___${parameter.name}`;
+                if (seenPathParams.has(paramId)) {
+                    report({
+                        message: `Paths must have unique \`name\` + \`in\` parameters.\nRepeats of \`in:${parameter.in}\` + \`name:${parameter.name}\`.`,
+                        location: parentLocations.PathItem.child(['parameters', key]),
+                    });
+                }
+                seenPathParams.add(`${parameter.in}___${parameter.name}`);
+            },
+            Operation: {
+                enter() {
+                    seenOperationParams = new Set();
+                },
+                Parameter(parameter, { report, key, parentLocations }) {
+                    const paramId = `${parameter.in}___${parameter.name}`;
+                    if (seenOperationParams.has(paramId)) {
+                        report({
+                            message: `Operations must have unique \`name\` + \`in\` parameters. Repeats of \`in:${parameter.in}\` + \`name:${parameter.name}\`.`,
+                            location: parentLocations.Operation.child(['parameters', key]),
+                        });
+                    }
+                    seenOperationParams.add(paramId);
+                },
+            },
+        },
+    };
+};
+//# sourceMappingURL=operation-parameters-unique.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/operation-singular-tag.js

@@ -0,0 +1,13 @@
+export const OperationSingularTag = () => {
+    return {
+        Operation(operation, { report, location }) {
+            if (operation.tags && operation.tags.length > 1) {
+                report({
+                    message: 'Operation `tags` object should have only one tag.',
+                    location: location.child(['tags']).key(),
+                });
+            }
+        },
+    };
+};
+//# sourceMappingURL=operation-singular-tag.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/operation-summary.js

@@ -0,0 +1,9 @@
+import { validateDefinedAndNonEmpty } from '../utils.js';
+export const OperationSummary = () => {
+    return {
+        Operation(operation, ctx) {
+            validateDefinedAndNonEmpty('summary', operation, ctx);
+        },
+    };
+};
+//# sourceMappingURL=operation-summary.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/operation-tag-defined.js

@@ -0,0 +1,27 @@
+export const OperationTagDefined = () => {
+    let definedTags;
+    return {
+        Root(root) {
+            definedTags = new Set((root.tags ?? []).map((t) => t.name));
+        },
+        Operation(operation, { report, location }) {
+            if (operation?.tags) {
+                for (let i = 0; i < operation.tags.length; i++) {
+                    if (!definedTags.has(operation.tags[i])) {
+                        report({
+                            message: `Operation tags should be defined in global tags.`,
+                            location: location.child(['tags', i]),
+                        });
+                    }
+                }
+            }
+            else {
+                report({
+                    message: `Operation tags should be defined`,
+                    location: location.key(),
+                });
+            }
+        },
+    };
+};
+//# sourceMappingURL=operation-tag-defined.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/parameter-description.js

@@ -0,0 +1,19 @@
+export const ParameterDescription = () => {
+    return {
+        Parameter(parameter, { report, location }) {
+            if (parameter.description === undefined) {
+                report({
+                    message: 'Parameter object description must be present.',
+                    location: { reportOnKey: true },
+                });
+            }
+            else if (!parameter.description) {
+                report({
+                    message: 'Parameter object description must be non-empty string.',
+                    location: location.child(['description']),
+                });
+            }
+        },
+    };
+};
+//# sourceMappingURL=parameter-description.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/path-declaration-must-exist.js

@@ -0,0 +1,13 @@
+export const PathDeclarationMustExist = () => {
+    return {
+        PathItem(_path, { report, key }) {
+            if (key.indexOf('{}') !== -1) {
+                report({
+                    message: 'Path parameter declarations must be non-empty. `{}` is invalid.',
+                    location: { reportOnKey: true },
+                });
+            }
+        },
+    };
+};
+//# sourceMappingURL=path-declaration-must-exist.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/path-http-verbs-order.js

@@ -0,0 +1,23 @@
+const defaultOrder = ['get', 'head', 'post', 'put', 'patch', 'delete', 'options', 'query', 'trace'];
+export const PathHttpVerbsOrder = (opts) => {
+    const order = (opts && opts.order) || defaultOrder;
+    if (!Array.isArray(order)) {
+        throw new Error('path-http-verbs-order `order` option must be an array');
+    }
+    return {
+        PathItem(path, { report, location }) {
+            const httpVerbs = Object.keys(path).filter((k) => order.includes(k));
+            for (let i = 0; i < httpVerbs.length - 1; i++) {
+                const aIdx = order.indexOf(httpVerbs[i]);
+                const bIdx = order.indexOf(httpVerbs[i + 1]);
+                if (bIdx < aIdx) {
+                    report({
+                        message: 'Operation http verbs must be ordered.',
+                        location: { reportOnKey: true, ...location.child(httpVerbs[i + 1]) },
+                    });
+                }
+            }
+        },
+    };
+};
+//# sourceMappingURL=path-http-verbs-order.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/path-not-include-query.js

@@ -0,0 +1,15 @@
+export const PathNotIncludeQuery = () => {
+    return {
+        Paths: {
+            PathItem(_operation, { report, key }) {
+                if (key.toString().includes('?')) {
+                    report({
+                        message: `Don't put query string items in the path, they belong in parameters with \`in: query\`.`,
+                        location: { reportOnKey: true },
+                    });
+                }
+            },
+        },
+    };
+};
+//# sourceMappingURL=path-not-include-query.js.map