@kubb/agent 4.33.1 → 4.33.3

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/assertions/asserts.js

@@ -0,0 +1,269 @@
+import { getIntersectionLength } from '../../../utils/get-intersection-length.js';
+import { isOrdered } from '../../../utils/is-ordered.js';
+import { isPlainObject } from '../../../utils/is-plain-object.js';
+import { isString as runOnValue } from '../../../utils/is-string.js';
+import { isTruthy } from '../../../utils/is-truthy.js';
+import { regexFromString } from '../../../utils/regex-from-string.js';
+export const runOnKeysSet = new Set([
+    'mutuallyExclusive',
+    'mutuallyRequired',
+    'enum',
+    'pattern',
+    'notPattern',
+    'minLength',
+    'maxLength',
+    'casing',
+    'sortOrder',
+    'disallowed',
+    'required',
+    'requireAny',
+    'ref',
+    'const',
+    'defined', // In case if `property` for assertions is not added
+]);
+export const runOnValuesSet = new Set([
+    'pattern',
+    'notPattern',
+    'enum',
+    'defined',
+    'nonEmpty',
+    'minLength',
+    'maxLength',
+    'casing',
+    'sortOrder',
+    'ref',
+    'const',
+]);
+export const asserts = {
+    pattern: (value, condition, { baseLocation, rawValue }) => {
+        if (typeof value === 'undefined' || isPlainObject(value))
+            return []; // property doesn't exist or is an object, no need to lint it with this assert
+        const values = Array.isArray(value) ? value : [value];
+        const regex = regexFromString(condition);
+        return values
+            .map((_val) => !regex?.test(_val) && {
+            message: `"${_val}" should match a regex ${condition}`,
+            location: runOnValue(value)
+                ? baseLocation
+                : isPlainObject(rawValue)
+                    ? baseLocation.child(_val).key()
+                    : baseLocation.key(),
+        })
+            .filter(isTruthy);
+    },
+    notPattern: (value, condition, { baseLocation, rawValue }) => {
+        if (typeof value === 'undefined' || isPlainObject(value))
+            return []; // property doesn't exist or is an object, no need to lint it with this assert
+        const values = Array.isArray(value) ? value : [value];
+        const regex = regexFromString(condition);
+        return values
+            .map((_val) => regex?.test(_val) && {
+            message: `"${_val}" should not match a regex ${condition}`,
+            location: runOnValue(value)
+                ? baseLocation
+                : isPlainObject(rawValue)
+                    ? baseLocation.child(_val).key()
+                    : baseLocation.key(),
+        })
+            .filter(isTruthy);
+    },
+    enum: (value, condition, { baseLocation }) => {
+        if (typeof value === 'undefined' || isPlainObject(value))
+            return []; // property doesn't exist or is an object, no need to lint it with this assert
+        const values = Array.isArray(value) ? value : [value];
+        return values
+            .map((_val) => !condition.includes(_val) && {
+            message: `"${_val}" should be one of the predefined values`,
+            location: runOnValue(value) ? baseLocation : baseLocation.child(_val).key(),
+        })
+            .filter(isTruthy);
+    },
+    defined: (value, condition = true, { baseLocation }) => {
+        const isDefined = typeof value !== 'undefined';
+        const isValid = condition ? isDefined : !isDefined;
+        return isValid
+            ? []
+            : [
+                {
+                    message: condition ? `Should be defined` : 'Should be not defined',
+                    location: baseLocation,
+                },
+            ];
+    },
+    required: (value, keys, { baseLocation }) => {
+        return keys
+            .map((requiredKey) => !value.includes(requiredKey) && {
+            message: `${requiredKey} is required`,
+            location: baseLocation.key(),
+        })
+            .filter(isTruthy);
+    },
+    disallowed: (value, condition, { baseLocation }) => {
+        if (typeof value === 'undefined' || isPlainObject(value))
+            return []; // property doesn't exist or is an object, no need to lint it with this assert
+        const values = Array.isArray(value) ? value : [value];
+        return values
+            .map((_val) => condition.includes(_val) && {
+            message: `"${_val}" is disallowed`,
+            location: runOnValue(value) ? baseLocation : baseLocation.child(_val).key(),
+        })
+            .filter(isTruthy);
+    },
+    const: (value, condition, { baseLocation }) => {
+        if (typeof value === 'undefined')
+            return [];
+        if (Array.isArray(value)) {
+            return value
+                .map((_val) => condition !== _val && {
+                message: `"${_val}" should be equal ${condition} `,
+                location: runOnValue(value) ? baseLocation : baseLocation.child(_val).key(),
+            })
+                .filter(isTruthy);
+        }
+        else {
+            return value !== condition
+                ? [
+                    {
+                        message: `${value} should be equal ${condition}`,
+                        location: baseLocation,
+                    },
+                ]
+                : [];
+        }
+    },
+    nonEmpty: (value, condition = true, { baseLocation }) => {
+        const isEmpty = typeof value === 'undefined' || value === null || value === '';
+        const isValid = condition ? !isEmpty : isEmpty;
+        return isValid
+            ? []
+            : [
+                {
+                    message: condition ? `Should not be empty` : 'Should be empty',
+                    location: baseLocation,
+                },
+            ];
+    },
+    minLength: (value, condition, { baseLocation }) => {
+        if (typeof value === 'undefined' || value.length >= condition)
+            return []; // property doesn't exist, no need to lint it with this assert
+        return [
+            {
+                message: `Should have at least ${condition} characters`,
+                location: baseLocation,
+            },
+        ];
+    },
+    maxLength: (value, condition, { baseLocation }) => {
+        if (typeof value === 'undefined' || value.length <= condition)
+            return []; // property doesn't exist, no need to lint it with this assert
+        return [
+            {
+                message: `Should have at most ${condition} characters`,
+                location: baseLocation,
+            },
+        ];
+    },
+    casing: (value, condition, { baseLocation }) => {
+        if (typeof value === 'undefined' || isPlainObject(value))
+            return []; // property doesn't exist or is an object, no need to lint it with this assert
+        const values = Array.isArray(value) ? value : [value];
+        const casingRegexes = {
+            camelCase: /^[a-z][a-zA-Z0-9]*$/g,
+            'kebab-case': /^([a-z][a-z0-9]*)(-[a-z0-9]+)*$/g,
+            snake_case: /^([a-z][a-z0-9]*)(_[a-z0-9]+)*$/g,
+            PascalCase: /^[A-Z][a-zA-Z0-9]+$/g,
+            MACRO_CASE: /^([A-Z][A-Z0-9]*)(_[A-Z0-9]+)*$/g,
+            'COBOL-CASE': /^([A-Z][A-Z0-9]*)(-[A-Z0-9]+)*$/g,
+            flatcase: /^[a-z][a-z0-9]+$/g,
+        };
+        return values
+            .map((_val) => !_val.match(casingRegexes[condition]) && {
+            message: `"${_val}" should use ${condition}`,
+            location: runOnValue(value) ? baseLocation : baseLocation.child(_val).key(),
+        })
+            .filter(isTruthy);
+    },
+    sortOrder: (value, condition, { baseLocation }) => {
+        const direction = condition.direction || condition;
+        const property = condition.property;
+        if (Array.isArray(value) && value.length > 0 && isPlainObject(value[0]) && !property) {
+            return [
+                {
+                    message: `Please define a property to sort objects by`,
+                    location: baseLocation,
+                },
+            ];
+        }
+        if (typeof value === 'undefined' || isOrdered(value, condition))
+            return [];
+        return [
+            {
+                message: `Should be sorted in ${direction === 'asc' ? 'an ascending' : 'a descending'} order${property ? ` by property ${property}` : ''}`,
+                location: baseLocation,
+            },
+        ];
+    },
+    mutuallyExclusive: (value, condition, { baseLocation }) => {
+        if (getIntersectionLength(value, condition) < 2)
+            return [];
+        return [
+            {
+                message: `${condition.join(', ')} keys should be mutually exclusive`,
+                location: baseLocation.key(),
+            },
+        ];
+    },
+    mutuallyRequired: (value, condition, { baseLocation }) => {
+        const isValid = getIntersectionLength(value, condition) > 0
+            ? getIntersectionLength(value, condition) === condition.length
+            : true;
+        return isValid
+            ? []
+            : [
+                {
+                    message: `Properties ${condition.join(', ')} are mutually required`,
+                    location: baseLocation.key(),
+                },
+            ];
+    },
+    requireAny: (value, condition, { baseLocation }) => {
+        return getIntersectionLength(value, condition) >= 1
+            ? []
+            : [
+                {
+                    message: `Should have any of ${condition.join(', ')}`,
+                    location: baseLocation.key(),
+                },
+            ];
+    },
+    ref: (_value, condition, { baseLocation, rawValue }) => {
+        if (typeof rawValue === 'undefined')
+            return []; // property doesn't exist, no need to lint it with this assert
+        const hasRef = rawValue.hasOwnProperty('$ref');
+        if (typeof condition === 'boolean') {
+            const isValid = condition ? hasRef : !hasRef;
+            return isValid
+                ? []
+                : [
+                    {
+                        message: condition ? `should use $ref` : 'should not use $ref',
+                        location: hasRef ? baseLocation : baseLocation.key(),
+                    },
+                ];
+        }
+        const regex = regexFromString(condition);
+        const isValid = hasRef && regex?.test(rawValue['$ref']);
+        return isValid
+            ? []
+            : [
+                {
+                    message: `$ref value should match ${condition}`,
+                    location: hasRef ? baseLocation : baseLocation.key(),
+                },
+            ];
+    },
+};
+export function buildAssertCustomFunction(fn) {
+    return (value, options, ctx) => fn.call(null, value, options, ctx);
+}
+//# sourceMappingURL=asserts.js.map

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

@@ -0,0 +1,22 @@
+import { isPlainObject } from '../../../utils/is-plain-object.js';
+import { isString } from '../../../utils/is-string.js';
+import { buildSubjectVisitor, buildVisitorObject } from './utils.js';
+export const Assertions = (opts) => {
+    const visitors = [];
+    // As 'Assertions' has an array of asserts,
+    // that array spreads into an 'opts' object on init rules phase here
+    // https://github.com/Redocly/redocly-cli/blob/main/packages/core/src/config/config.ts#L311
+    // that is why we need to iterate through 'opts' values;
+    // before - filter only object 'opts' values
+    const assertions = Object.values(opts).filter((opt) => isPlainObject(opt));
+    for (const [_, assertion] of assertions.entries()) {
+        if (!isString(assertion.subject.type)) {
+            throw new Error(`${assertion.assertionId}: 'type' (String) is required`);
+        }
+        const subjectVisitor = buildSubjectVisitor(assertion.assertionId, assertion);
+        const visitorObject = buildVisitorObject(assertion, subjectVisitor);
+        visitors.push(visitorObject);
+    }
+    return visitors;
+};
+//# sourceMappingURL=index.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/assertions/utils.js

@@ -0,0 +1,215 @@
+import { colorize } from '../../../logger.js';
+import { isRef, isAbsoluteUrl } from '../../../ref-utils.js';
+import { isString } from '../../../utils/is-string.js';
+import { isTruthy } from '../../../utils/is-truthy.js';
+import { keysOf } from '../../../utils/keys-of.js';
+import { regexFromString } from '../../../utils/regex-from-string.js';
+import { asserts, runOnKeysSet, runOnValuesSet } from './asserts.js';
+const assertionMessageTemplates = {
+    problems: '{{problems}}',
+    assertionName: '{{assertionName}}',
+    nodeType: '{{nodeType}}',
+    key: '{{key}}',
+    property: '{{property}}',
+    file: '{{file}}',
+    pointer: '{{pointer}}',
+};
+function getPredicatesFromLocators(locators) {
+    const { filterInParentKeys, filterOutParentKeys, matchParentKeys } = locators;
+    const keyMatcher = matchParentKeys && regexFromString(matchParentKeys);
+    const matchKeysPredicate = keyMatcher && ((key) => keyMatcher.test(key.toString()));
+    const filterInPredicate = Array.isArray(filterInParentKeys) &&
+        ((key) => filterInParentKeys.includes(key.toString()));
+    const filterOutPredicate = Array.isArray(filterOutParentKeys) &&
+        ((key) => !filterOutParentKeys.includes(key.toString()));
+    return [matchKeysPredicate, filterInPredicate, filterOutPredicate].filter(isTruthy);
+}
+export function getAssertsToApply(assertion) {
+    const assertsToApply = keysOf(asserts)
+        .filter((assertName) => assertion.assertions[assertName] !== undefined)
+        .map((assertName) => {
+        return {
+            name: assertName,
+            conditions: assertion.assertions[assertName],
+            runsOnKeys: runOnKeysSet.has(assertName),
+            runsOnValues: runOnValuesSet.has(assertName),
+        };
+    });
+    const shouldRunOnKeys = assertsToApply.find((assert) => assert.runsOnKeys && !assert.runsOnValues);
+    const shouldRunOnValues = assertsToApply.find((assert) => assert.runsOnValues && !assert.runsOnKeys);
+    if (shouldRunOnValues && !assertion.subject.property) {
+        throw new Error(`The '${shouldRunOnValues.name}' assertion can't be used on all keys. Please provide a single property.`);
+    }
+    if (shouldRunOnKeys && assertion.subject.property) {
+        throw new Error(`The '${shouldRunOnKeys.name}' assertion can't be used on properties. Please remove the 'property' key.`);
+    }
+    return assertsToApply;
+}
+function getAssertionProperties({ subject }) {
+    return (Array.isArray(subject.property) ? subject.property : [subject?.property]).filter(Boolean);
+}
+function applyAssertions(assertionDefinition, asserts, ctx) {
+    const properties = getAssertionProperties(assertionDefinition);
+    const assertResults = [];
+    for (const assert of asserts) {
+        if (properties.length) {
+            for (const property of properties) {
+                assertResults.push(runAssertion({
+                    assert,
+                    ctx,
+                    assertionProperty: property,
+                }));
+            }
+        }
+        else {
+            assertResults.push(runAssertion({
+                assert,
+                ctx,
+            }));
+        }
+    }
+    return assertResults.flat();
+}
+export function buildVisitorObject(assertion, subjectVisitor) {
+    const targetVisitorLocatorPredicates = getPredicatesFromLocators(assertion.subject);
+    const targetVisitorSkipFunction = targetVisitorLocatorPredicates.length
+        ? (_, key) => !targetVisitorLocatorPredicates.every((predicate) => predicate(key))
+        : undefined;
+    const targetVisitor = {
+        [assertion.subject.type]: {
+            enter: subjectVisitor,
+            ...(targetVisitorSkipFunction && { skip: targetVisitorSkipFunction }),
+        },
+    };
+    if (!Array.isArray(assertion.where)) {
+        return targetVisitor;
+    }
+    let currentVisitorLevel = {};
+    const visitor = currentVisitorLevel;
+    const context = assertion.where;
+    for (let index = 0; index < context.length; index++) {
+        const assertionDefinitionNode = context[index];
+        if (!isString(assertionDefinitionNode.subject?.type)) {
+            throw new Error(`${assertion.assertionId} -> where -> [${index}]: 'type' (String) is required`);
+        }
+        const locatorPredicates = getPredicatesFromLocators(assertionDefinitionNode.subject);
+        const assertsToApply = getAssertsToApply(assertionDefinitionNode);
+        const skipFunction = (node, key, ctx) => !locatorPredicates.every((predicate) => predicate(key)) ||
+            !!applyAssertions(assertionDefinitionNode, assertsToApply, { ...ctx, node }).length;
+        const nodeVisitor = {
+            ...((locatorPredicates.length || assertsToApply.length) && { skip: skipFunction }),
+        };
+        if (assertionDefinitionNode.subject.type === assertion.subject.type &&
+            index === context.length - 1) {
+            // We have to merge the visitors if the last node inside the `where` is the same as the subject.
+            targetVisitor[assertion.subject.type] = {
+                enter: subjectVisitor,
+                ...((nodeVisitor.skip && { skip: nodeVisitor.skip }) ||
+                    (targetVisitorSkipFunction && {
+                        skip: (node, key, ctx // We may have locators defined on assertion level and on where level for the same node type
+                        ) => !!(nodeVisitor.skip?.(node, key, ctx) || targetVisitorSkipFunction?.(node, key)),
+                    })),
+            };
+        }
+        else {
+            currentVisitorLevel = currentVisitorLevel[assertionDefinitionNode.subject?.type] =
+                nodeVisitor;
+        }
+    }
+    currentVisitorLevel[assertion.subject.type] = targetVisitor[assertion.subject.type];
+    return visitor;
+}
+export function buildSubjectVisitor(assertId, assertion) {
+    return (node, ctx) => {
+        const properties = getAssertionProperties(assertion);
+        const defaultMessage = `${colorize.blue(assertId)} failed because the ${colorize.blue(assertion.subject.type)} ${colorize.blue(properties.join(', '))} didn't meet the assertions: ${assertionMessageTemplates.problems}`.replace(/ +/g, ' ');
+        const problems = applyAssertions(assertion, getAssertsToApply(assertion), {
+            ...ctx,
+            node,
+        });
+        if (problems.length) {
+            for (const problemGroup of groupProblemsByPointer(problems)) {
+                const message = assertion.message || defaultMessage;
+                const problemMessage = getProblemsMessage(problemGroup);
+                const placeholders = {
+                    problems: problemMessage,
+                    assertionName: assertId,
+                    nodeType: assertion.subject.type,
+                    property: properties.join(', '),
+                    key: String(ctx.key),
+                    pointer: ctx.location.pointer,
+                    file: getFilenameFromPath(ctx.location.source.absoluteRef),
+                };
+                ctx.report({
+                    message: interpolateMessagePlaceholders(message, placeholders),
+                    location: getProblemsLocation(problemGroup) || ctx.location,
+                    forceSeverity: assertion.severity || 'error',
+                    suggest: assertion.suggest || [],
+                    ruleId: assertId,
+                });
+            }
+        }
+    };
+}
+function groupProblemsByPointer(problems) {
+    const groups = {};
+    for (const problem of problems) {
+        if (!problem.location)
+            continue;
+        const pointer = problem.location.pointer;
+        groups[pointer] = groups[pointer] || [];
+        groups[pointer].push(problem);
+    }
+    return Object.values(groups);
+}
+function getProblemsLocation(problems) {
+    return problems.length ? problems[0].location : undefined;
+}
+function getProblemsMessage(problems) {
+    return problems.length === 1
+        ? (problems[0].message ?? '')
+        : problems.map((problem) => `\n- ${problem.message ?? ''}`).join('');
+}
+function getFilenameFromPath(absoluteRef) {
+    if (isAbsoluteUrl(absoluteRef)) {
+        const parts = absoluteRef.split('/');
+        return parts.at(-1) || absoluteRef;
+    }
+    const parts = absoluteRef.split(/[/\\]/);
+    return parts.at(-1) || absoluteRef;
+}
+function interpolateMessagePlaceholders(message, placeholders) {
+    let result = message;
+    for (const key of Object.keys(assertionMessageTemplates)) {
+        const template = assertionMessageTemplates[key];
+        const value = placeholders[key];
+        if (!template)
+            continue;
+        result = result.split(template).join(value);
+    }
+    return result;
+}
+export function runAssertion({ assert, ctx, assertionProperty, }) {
+    const currentLocation = assert.name === 'ref' ? ctx.rawLocation : ctx.location;
+    if (assertionProperty) {
+        const values = isRef(ctx.node[assertionProperty])
+            ? ctx.resolve(ctx.node[assertionProperty])?.node
+            : ctx.node[assertionProperty];
+        const rawValues = ctx.rawNode[assertionProperty];
+        const location = currentLocation.child(assertionProperty);
+        return asserts[assert.name](values, assert.conditions, {
+            ...ctx,
+            baseLocation: location,
+            rawValue: rawValues,
+        });
+    }
+    else {
+        const value = Array.isArray(ctx.node) ? ctx.node : Object.keys(ctx.node);
+        return asserts[assert.name](value, assert.conditions, {
+            ...ctx,
+            rawValue: ctx.rawNode,
+            baseLocation: currentLocation,
+        });
+    }
+}
+//# sourceMappingURL=utils.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/info-contact.js

@@ -0,0 +1,14 @@
+import { missingRequiredField } from '../utils.js';
+export const InfoContact = () => {
+    return {
+        Info(info, { report, location }) {
+            if (!info.contact) {
+                report({
+                    message: missingRequiredField('Info', 'contact'),
+                    location: location.child('contact').key(),
+                });
+            }
+        },
+    };
+};
+//# sourceMappingURL=info-contact.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/info-license-strict.js

@@ -0,0 +1,23 @@
+import { detectSpec } from '../../detect-spec.js';
+import { validateDefinedAndNonEmpty, validateOneOfDefinedAndNonEmpty } from '../utils.js';
+export const InfoLicenseStrict = () => {
+    let specVersion;
+    return {
+        Root: {
+            enter(root) {
+                specVersion = detectSpec(root);
+            },
+            License: {
+                leave(license, ctx) {
+                    if (specVersion === 'oas3_1' || specVersion === 'oas3_2') {
+                        validateOneOfDefinedAndNonEmpty(['url', 'identifier'], license, ctx);
+                    }
+                    else {
+                        validateDefinedAndNonEmpty('url', license, ctx);
+                    }
+                },
+            },
+        },
+    };
+};
+//# sourceMappingURL=info-license-strict.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/info-license.js

@@ -0,0 +1,14 @@
+import { missingRequiredField } from '../utils.js';
+export const InfoLicense = () => {
+    return {
+        Info(info, { report }) {
+            if (!info.license) {
+                report({
+                    message: missingRequiredField('Info', 'license'),
+                    location: { reportOnKey: true },
+                });
+            }
+        },
+    };
+};
+//# sourceMappingURL=info-license.js.map

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

@@ -0,0 +1,42 @@
+export const NoAmbiguousPaths = () => {
+    return {
+        Paths(pathMap, { report, location }) {
+            const seenPaths = [];
+            for (const currentPath of Object.keys(pathMap)) {
+                const ambiguousPath = seenPaths.find((seenPath) => arePathsAmbiguous(seenPath, currentPath));
+                if (ambiguousPath) {
+                    report({
+                        message: `Paths should resolve unambiguously. Found two ambiguous paths: \`${ambiguousPath}\` and \`${currentPath}\`.`,
+                        location: location.child([currentPath]).key(),
+                    });
+                }
+                seenPaths.push(currentPath);
+            }
+        },
+    };
+};
+function arePathsAmbiguous(a, b) {
+    const partsA = a.split('/');
+    const partsB = b.split('/');
+    if (partsA.length !== partsB.length)
+        return false;
+    let aVars = 0;
+    let bVars = 0;
+    let ambiguous = true;
+    for (let i = 0; i < partsA.length; i++) {
+        const aIsVar = partsA[i].match(/^{.+?}$/);
+        const bIsVar = partsB[i].match(/^{.+?}$/);
+        if (aIsVar || bIsVar) {
+            if (aIsVar)
+                aVars++;
+            if (bIsVar)
+                bVars++;
+            continue;
+        }
+        else if (partsA[i] !== partsB[i]) {
+            ambiguous = false;
+        }
+    }
+    return ambiguous && aVars === bVars;
+}
+//# sourceMappingURL=no-ambiguous-paths.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/no-duplicated-tag-names.js

@@ -0,0 +1,21 @@
+import { getTagName } from '../utils.js';
+export const NoDuplicatedTagNames = ({ ignoreCase = false, }) => {
+    const tagNames = new Set();
+    return {
+        Tag: {
+            leave(tag, ctx) {
+                const tagName = getTagName(tag, ignoreCase);
+                if (tagNames.has(tagName)) {
+                    ctx.report({
+                        message: `Duplicate tag name found: '${tag.name}'.`,
+                        location: ctx.location,
+                    });
+                }
+                else {
+                    tagNames.add(tagName);
+                }
+            },
+        },
+    };
+};
+//# sourceMappingURL=no-duplicated-tag-names.js.map

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

@@ -0,0 +1,38 @@
+import { matchesJsonSchemaType, oasTypeOf } from '../utils.js';
+export const NoEnumTypeMismatch = () => {
+    return {
+        Schema(schema, { report, location }) {
+            if (schema.enum && !Array.isArray(schema.enum))
+                return;
+            if (schema.enum && schema.type && !Array.isArray(schema.type)) {
+                const typeMismatchedValues = schema.enum.filter((item) => !matchesJsonSchemaType(item, schema.type, schema.nullable));
+                for (const mismatchedValue of typeMismatchedValues) {
+                    report({
+                        message: `All values of \`enum\` field must be of the same type as the \`type\` field: expected "${schema.type}" but received "${oasTypeOf(mismatchedValue)}".`,
+                        location: location.child(['enum', schema.enum.indexOf(mismatchedValue)]),
+                    });
+                }
+            }
+            if (schema.enum && schema.type && Array.isArray(schema.type)) {
+                const mismatchedResults = {};
+                for (const enumValue of schema.enum) {
+                    mismatchedResults[enumValue] = [];
+                    for (const type of schema.type) {
+                        const valid = matchesJsonSchemaType(enumValue, type, schema.nullable);
+                        if (!valid)
+                            mismatchedResults[enumValue].push(type);
+                    }
+                    if (mismatchedResults[enumValue].length !== schema.type.length)
+                        delete mismatchedResults[enumValue];
+                }
+                for (const mismatchedKey of Object.keys(mismatchedResults)) {
+                    report({
+                        message: `Enum value \`${mismatchedKey}\` must be of allowed types: \`${schema.type}\`.`,
+                        location: location.child(['enum', schema.enum.indexOf(mismatchedKey)]),
+                    });
+                }
+            }
+        },
+    };
+};
+//# sourceMappingURL=no-enum-type-mismatch.js.map