@kubb/agent 4.27.2 → 4.28.0

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

@@ -1,269 +0,0 @@
-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 { getIntersectionLength } from '../../../utils/get-intersection-length.js';
-import { isOrdered } from '../../../utils/is-ordered.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

@@ -1,22 +0,0 @@
-import { buildSubjectVisitor, buildVisitorObject } from './utils.js';
-import { isString } from '../../../utils/is-string.js';
-import { isPlainObject } from '../../../utils/is-plain-object.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

@@ -1,215 +0,0 @@
-import { asserts, runOnKeysSet, runOnValuesSet } from './asserts.js';
-import { colorize } from '../../../logger.js';
-import { isRef, isAbsoluteUrl } from '../../../ref-utils.js';
-import { isTruthy } from '../../../utils/is-truthy.js';
-import { keysOf } from '../../../utils/keys-of.js';
-import { isString } from '../../../utils/is-string.js';
-import { regexFromString } from '../../../utils/regex-from-string.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

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

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

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

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

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

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