@kubb/agent 4.27.2 → 4.28.0

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

@@ -1,125 +0,0 @@
-import { isPlainObject } from '../../utils/is-plain-object.js';
-const pathRegex = /\{([a-zA-Z0-9_.-]+)\}+/g;
-const MAX_DEPTH = 2; // Only first callback level is supported
-export const PathParamsDefined = () => {
-    const pathContext = { current: null };
-    const currentOperationParams = new Set();
-    return {
-        PathItem: {
-            enter(_, { key }) {
-                pathItemEnter(pathContext, key);
-            },
-            leave() {
-                pathItemLeave(pathContext);
-            },
-            Parameter(parameter, { report, location }) {
-                createPathItemParameterHandler(parameter, pathContext, report, location);
-            },
-            Operation: createOperationHandlers(pathContext, currentOperationParams),
-        },
-    };
-};
-const pathItemEnter = (pathContext, key) => {
-    pathContext.current = {
-        path: key,
-        templateParams: extractTemplateParams(key),
-        definedParams: new Set(),
-    };
-};
-const pathItemLeave = (pathContext) => {
-    pathContext.current = null;
-};
-const createPathItemParameterHandler = (parameter, pathContext, report, location) => {
-    if (parameter.in === 'path' && parameter.name && pathContext.current) {
-        pathContext.current.definedParams.add(parameter.name);
-        validatePathParameter(parameter.name, pathContext.current.templateParams, pathContext.current.path, report, location);
-    }
-};
-const createOperationHandlers = (pathContext, currentOperationParams, depth = 0) => {
-    const reportMaxDepthWarning = (report, location, depth) => {
-        report({
-            message: `Maximum callback nesting depth (${depth}) reached. Path parameter validation is limited beyond this depth to prevent infinite recursion.`,
-            location: location,
-        });
-    };
-    if (depth >= MAX_DEPTH) {
-        return {
-            enter: () => { },
-            leave: (_op, { report, location }) => {
-                reportMaxDepthWarning(report, location, depth);
-            },
-            Parameter: () => { },
-            Callback: undefined,
-        };
-    }
-    const createCallbackPathItem = () => {
-        let parentPathContext = null;
-        return {
-            enter(_, { key }) {
-                parentPathContext = pathContext.current;
-                pathItemEnter(pathContext, key);
-            },
-            leave() {
-                pathContext.current = parentPathContext;
-            },
-            Parameter(parameter, { report, location }) {
-                createPathItemParameterHandler(parameter, pathContext, report, location);
-            },
-            get Operation() {
-                return createOperationHandlers(pathContext, currentOperationParams, depth + 1);
-            },
-        };
-    };
-    return {
-        enter() {
-            currentOperationParams = new Set();
-        },
-        leave(_operation, { report, location }) {
-            if (!pathContext.current || !currentOperationParams)
-                return;
-            validateRequiredPathParams(pathContext.current.templateParams, currentOperationParams, pathContext.current.definedParams, pathContext.current.path, report, location);
-        },
-        Parameter(parameter, { report, location }) {
-            collectPathParamsFromOperation(parameter, currentOperationParams);
-            if (parameter.in === 'path' && parameter.name && pathContext.current) {
-                currentOperationParams.add(parameter.name);
-                validatePathParameter(parameter.name, pathContext.current.templateParams, pathContext.current.path, report, location);
-            }
-        },
-        Callback: {
-            get PathItem() {
-                return createCallbackPathItem();
-            },
-        },
-    };
-};
-const extractTemplateParams = (path) => {
-    return new Set(Array.from(path.matchAll(pathRegex)).map((m) => m[1]));
-};
-const collectPathParamsFromOperation = (parameter, targetSet) => {
-    if (isPlainObject(parameter) && 'in' in parameter && 'name' in parameter) {
-        if (parameter.in === 'path' && parameter.name) {
-            targetSet.add(parameter.name);
-        }
-    }
-};
-const validatePathParameter = (paramName, templateParams, path, report, location) => {
-    if (!templateParams.has(paramName)) {
-        report({
-            message: `Path parameter \`${paramName}\` is not used in the path \`${path}\`.`,
-            location: location.child(['name']),
-        });
-    }
-};
-const validateRequiredPathParams = (templateParams, definedOperationParams, definedPathParams, path, report, location) => {
-    const allDefinedParams = new Set([...definedOperationParams, ...definedPathParams]);
-    for (const templateParam of templateParams) {
-        if (!allDefinedParams.has(templateParam)) {
-            report({
-                message: `The operation does not define the path parameter \`{${templateParam}}\` expected by path \`${path}\`.`,
-                location: location.child(['parameters']).key(),
-            });
-        }
-    }
-};
-//# sourceMappingURL=path-params-defined.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/path-segment-plural.js

@@ -1,30 +0,0 @@
-import pluralize from 'pluralize';
-import { isPathParameter } from '../../utils/is-path-parameter.js';
-export const PathSegmentPlural = (opts) => {
-    const { ignoreLastPathSegment, exceptions } = opts;
-    return {
-        PathItem: {
-            leave(_path, { report, key, location }) {
-                const pathKey = key.toString();
-                if (pathKey.startsWith('/')) {
-                    const pathSegments = pathKey.split('/');
-                    pathSegments.shift();
-                    if (ignoreLastPathSegment && pathSegments.length > 0) {
-                        pathSegments.pop();
-                    }
-                    for (const pathSegment of pathSegments) {
-                        if (exceptions && exceptions.includes(pathSegment))
-                            continue;
-                        if (!isPathParameter(pathSegment) && pluralize.isSingular(pathSegment)) {
-                            report({
-                                message: `path segment \`${pathSegment}\` should be plural.`,
-                                location: location.key(),
-                            });
-                        }
-                    }
-                }
-            },
-        },
-    };
-};
-//# sourceMappingURL=path-segment-plural.js.map

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

@@ -1,17 +0,0 @@
-export const PathsKebabCase = () => {
-    return {
-        PathItem(_path, { report, key }) {
-            const segments = key
-                .substr(1)
-                .split('/')
-                .filter((s) => s !== ''); // filter out empty segments
-            if (!segments.every((segment) => /^{.+}$/.test(segment) || /^[a-z0-9-.]+$/.test(segment))) {
-                report({
-                    message: `\`${key}\` does not use kebab-case.`,
-                    location: { reportOnKey: true },
-                });
-            }
-        },
-    };
-};
-//# sourceMappingURL=paths-kebab-case.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/required-string-property-missing-min-length.js

@@ -1,34 +0,0 @@
-export const RequiredStringPropertyMissingMinLength = () => {
-    let skipSchemaProperties;
-    let requiredPropertiesSet;
-    return {
-        Schema: {
-            enter(schema) {
-                if (!schema?.required) {
-                    skipSchemaProperties = true;
-                    return;
-                }
-                requiredPropertiesSet = new Set(schema.required);
-                skipSchemaProperties = false;
-            },
-            SchemaProperties: {
-                skip() {
-                    return skipSchemaProperties;
-                },
-                Schema: {
-                    enter(schema, { key, location, report }) {
-                        if (requiredPropertiesSet.has(key) && schema.type === 'string') {
-                            if (!schema?.minLength) {
-                                report({
-                                    message: 'Property minLength is required.',
-                                    location: location.key(),
-                                });
-                            }
-                        }
-                    },
-                },
-            },
-        },
-    };
-};
-//# sourceMappingURL=required-string-property-missing-min-length.js.map

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

@@ -1,26 +0,0 @@
-import { getMatchingStatusCodeRange } from '../../utils/get-matching-status-code-range.js';
-export const ResponseContainsHeader = (options) => {
-    const names = options.names || {};
-    return {
-        Operation: {
-            Response: {
-                enter: (response, { report, location, key }) => {
-                    const expectedHeaders = names[key] ||
-                        names[getMatchingStatusCodeRange(key)] ||
-                        names[getMatchingStatusCodeRange(key).toLowerCase()] ||
-                        [];
-                    for (const expectedHeader of expectedHeaders) {
-                        if (!response?.headers ||
-                            !Object.keys(response?.headers).some((header) => header.toLowerCase() === expectedHeader.toLowerCase())) {
-                            report({
-                                message: `Response object must contain a "${expectedHeader}" header.`,
-                                location: location.child('headers').key(),
-                            });
-                        }
-                    }
-                },
-            },
-        },
-    };
-};
-//# sourceMappingURL=response-contains-header.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/scalar-property-missing-example.js

@@ -1,39 +0,0 @@
-import { getOwn } from '../../utils/get-own.js';
-const SCALAR_TYPES = ['string', 'integer', 'number', 'boolean', 'null'];
-export const ScalarPropertyMissingExample = () => {
-    return {
-        SchemaProperties(properties, { report, location, specVersion, resolve }) {
-            for (const propName of Object.keys(properties)) {
-                const propSchema = resolve(getOwn(properties, propName)).node;
-                if (!propSchema || !isScalarSchema(propSchema)) {
-                    continue;
-                }
-                if (propSchema.example === undefined &&
-                    propSchema.examples === undefined) {
-                    report({
-                        message: `Scalar property should have "example"${specVersion === 'oas3_1' || specVersion === 'oas3_2' ? ' or "examples"' : ''} defined.`,
-                        location: location.child(propName).key(),
-                    });
-                }
-            }
-        },
-    };
-};
-function isScalarSchema(schema) {
-    if (!schema.type) {
-        return false;
-    }
-    if (schema.allOf || schema.anyOf || schema.oneOf) {
-        // Skip allOf/oneOf/anyOf as it's complicated to validate it right now.
-        // We need core support for checking contrstrains through those keywords.
-        return false;
-    }
-    if (schema.format === 'binary') {
-        return false;
-    }
-    if (Array.isArray(schema.type)) {
-        return schema.type.every((t) => SCALAR_TYPES.includes(t));
-    }
-    return SCALAR_TYPES.includes(schema.type);
-}
-//# sourceMappingURL=scalar-property-missing-example.js.map

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

@@ -1,62 +0,0 @@
-export const SecurityDefined = (opts) => {
-    const referencedSchemes = new Map();
-    const operationsWithoutSecurity = [];
-    let eachOperationHasSecurity = true;
-    let path;
-    return {
-        Root: {
-            leave(root, { report }) {
-                for (const [name, scheme] of referencedSchemes.entries()) {
-                    if (scheme.defined)
-                        continue;
-                    for (const reportedFromLocation of scheme.from) {
-                        report({
-                            message: `There is no \`${name}\` security scheme defined.`,
-                            location: reportedFromLocation.key(),
-                        });
-                    }
-                }
-                if (root.security || eachOperationHasSecurity) {
-                    return;
-                }
-                else {
-                    for (const operationLocation of operationsWithoutSecurity) {
-                        report({
-                            message: `Every operation should have security defined on it or on the root level.`,
-                            location: operationLocation.key(),
-                        });
-                    }
-                }
-            },
-        },
-        SecurityScheme(_securityScheme, { key }) {
-            referencedSchemes.set(key.toString(), { defined: true, from: [] });
-        },
-        SecurityRequirement(requirements, { location }) {
-            for (const requirement of Object.keys(requirements)) {
-                const authScheme = referencedSchemes.get(requirement);
-                const requirementLocation = location.child([requirement]);
-                if (!authScheme) {
-                    referencedSchemes.set(requirement, { from: [requirementLocation] });
-                }
-                else {
-                    authScheme.from.push(requirementLocation);
-                }
-            }
-        },
-        PathItem: {
-            enter(pathItem, { key }) {
-                path = key;
-            },
-            Operation(operation, { location, key }) {
-                const isException = opts.exceptions?.some((item) => item.path === path &&
-                    (!item.methods || item.methods?.some((method) => method.toLowerCase() === key)));
-                if (!operation?.security && !isException) {
-                    eachOperationHasSecurity = false;
-                    operationsWithoutSecurity.push(location);
-                }
-            },
-        },
-    };
-};
-//# sourceMappingURL=security-defined.js.map

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

@@ -1,27 +0,0 @@
-import { isRef } from '../../ref-utils.js';
-export const SpecStrictRefs = () => {
-    const nodesToSkip = [
-        'Schema',
-        'Response',
-        'Parameter',
-        'RequestBody',
-        'Example',
-        'Header',
-        'SecurityScheme',
-        'Link',
-        'Callback',
-        'PathItem',
-    ];
-    return {
-        any(_node, { report, rawNode, rawLocation, type }) {
-            const shouldCheck = !nodesToSkip.includes(type.name);
-            if (shouldCheck && isRef(rawNode)) {
-                report({
-                    message: 'Field $ref is not expected here.',
-                    location: rawLocation.child('$ref').key(),
-                });
-            }
-        },
-    };
-};
-//# sourceMappingURL=spec-strict-refs.js.map

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

@@ -1,150 +0,0 @@
-import { isNamedType, SpecExtension } from '../../types/index.js';
-import { oasTypeOf, matchesJsonSchemaType, getSuggest, validateSchemaEnumType } from '../utils.js';
-import { isRef } from '../../ref-utils.js';
-import { isPlainObject } from '../../utils/is-plain-object.js';
-import { getOwn } from '../../utils/get-own.js';
-export const Struct = () => {
-    return {
-        any(node, { report, type, location, rawLocation, key, resolve, ignoreNextVisitorsOnNode }) {
-            const nodeType = oasTypeOf(node);
-            const refLocation = rawLocation !== location ? rawLocation : undefined;
-            if (type.items) {
-                if (nodeType !== 'array') {
-                    report({
-                        message: `Expected type \`${type.name}\` (array) but got \`${nodeType}\``,
-                        from: refLocation,
-                    });
-                    ignoreNextVisitorsOnNode();
-                }
-                return;
-            }
-            else if (nodeType !== 'object') {
-                if (type !== SpecExtension) {
-                    // do not validate unknown extensions structure
-                    report({
-                        message: `Expected type \`${type.name}\` (object) but got \`${nodeType}\``,
-                        from: refLocation,
-                    });
-                }
-                ignoreNextVisitorsOnNode();
-                return;
-            }
-            const required = typeof type.required === 'function' ? type.required(node, key) : type.required;
-            for (const propName of required || []) {
-                if (!node.hasOwnProperty(propName)) {
-                    report({
-                        message: `The field \`${propName}\` must be present on this level.`,
-                        from: refLocation,
-                        location: [{ reportOnKey: true }],
-                    });
-                }
-            }
-            const allowed = type.allowed?.(node);
-            if (allowed && isPlainObject(node)) {
-                for (const propName in node) {
-                    if (allowed.includes(propName) ||
-                        (type.extensionsPrefix && propName.startsWith(type.extensionsPrefix)) ||
-                        !Object.keys(type.properties).includes(propName)) {
-                        continue;
-                    }
-                    report({
-                        message: `The field \`${propName}\` is not allowed here.`,
-                        from: refLocation,
-                        location: location.child([propName]).key(),
-                    });
-                }
-            }
-            const requiredOneOf = type.requiredOneOf || null;
-            if (requiredOneOf) {
-                let hasProperty = false;
-                for (const propName of requiredOneOf || []) {
-                    if (node.hasOwnProperty(propName)) {
-                        hasProperty = true;
-                    }
-                }
-                if (!hasProperty)
-                    report({
-                        message: `Must contain at least one of the following fields: ${type.requiredOneOf?.join(', ')}.`,
-                        from: refLocation,
-                        location: [{ reportOnKey: true }],
-                    });
-            }
-            for (const propName of Object.keys(node)) {
-                const propLocation = location.child([propName]);
-                let propValue = node[propName];
-                let propType = getOwn(type.properties, propName);
-                if (propType === undefined)
-                    propType = type.additionalProperties;
-                if (typeof propType === 'function')
-                    propType = propType(propValue, propName);
-                if (isNamedType(propType)) {
-                    continue; // do nothing for named schema, it is executed with the next any call
-                }
-                const propSchema = propType;
-                const propValueType = oasTypeOf(propValue);
-                if (propSchema === undefined) {
-                    if (propName.startsWith('x-'))
-                        continue;
-                    report({
-                        message: `Property \`${propName}\` is not expected here.`,
-                        suggest: getSuggest(propName, Object.keys(type.properties)),
-                        from: refLocation,
-                        location: propLocation.key(),
-                    });
-                    continue;
-                }
-                if (propSchema === null) {
-                    continue; // just defined, no validation
-                }
-                if (propSchema.resolvable !== false && isRef(propValue)) {
-                    propValue = resolve(propValue).node;
-                }
-                if (propSchema.items && propSchema.items?.enum && Array.isArray(propValue)) {
-                    for (let i = 0; i < propValue.length; i++) {
-                        validateSchemaEnumType(propSchema.items?.enum, propValue[i], propName, refLocation, {
-                            report,
-                            location: location.child([propName, i]),
-                        });
-                    }
-                }
-                if (propSchema.enum) {
-                    validateSchemaEnumType(propSchema.enum, propValue, propName, refLocation, {
-                        report,
-                        location: location.child([propName]),
-                    });
-                }
-                else if (propSchema.type && !matchesJsonSchemaType(propValue, propSchema.type, false)) {
-                    report({
-                        message: `Expected type \`${propSchema.type}\` but got \`${propValueType}\`.`,
-                        from: refLocation,
-                        location: propLocation,
-                    });
-                    ignoreNextVisitorsOnNode();
-                }
-                else if (propValueType === 'array' && propSchema.items?.type) {
-                    const itemsType = propSchema.items?.type;
-                    for (let i = 0; i < propValue.length; i++) {
-                        const item = propValue[i];
-                        if (!matchesJsonSchemaType(item, itemsType, false)) {
-                            report({
-                                message: `Expected type \`${itemsType}\` but got \`${oasTypeOf(item)}\`.`,
-                                from: refLocation,
-                                location: propLocation.child([i]),
-                            });
-                        }
-                    }
-                }
-                if (typeof propSchema.minimum === 'number') {
-                    if (propSchema.minimum > node[propName]) {
-                        report({
-                            message: `The value of the ${propName} field must be greater than or equal to ${propSchema.minimum}`,
-                            from: refLocation,
-                            location: location.child([propName]),
-                        });
-                    }
-                }
-            }
-        },
-    };
-};
-//# sourceMappingURL=struct.js.map

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

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

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/common/tags-alphabetical.js

@@ -1,18 +0,0 @@
-import { getTagName } from '../utils.js';
-export const TagsAlphabetical = ({ ignoreCase = false }) => {
-    return {
-        Root(root, { report, location }) {
-            if (!root.tags)
-                return;
-            for (let i = 0; i < root.tags.length - 1; i++) {
-                if (getTagName(root.tags[i], ignoreCase) > getTagName(root.tags[i + 1], ignoreCase)) {
-                    report({
-                        message: 'The `tags` array should be in alphabetical order.',
-                        location: location.child(['tags', i]),
-                    });
-                }
-            }
-        },
-    };
-};
-//# sourceMappingURL=tags-alphabetical.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/oas2/boolean-parameter-prefixes.js

@@ -1,19 +0,0 @@
-export const BooleanParameterPrefixes = (options) => {
-    const prefixes = options.prefixes || ['is', 'has'];
-    const regexp = new RegExp(`^(${prefixes.join('|')})[A-Z-_]`);
-    const wrappedPrefixes = prefixes.map((p) => `\`${p}\``);
-    const prefixesString = wrappedPrefixes.length === 1
-        ? wrappedPrefixes[0]
-        : wrappedPrefixes.slice(0, -1).join(', ') + ' or ' + wrappedPrefixes[prefixes.length - 1];
-    return {
-        Parameter(param, { report, location }) {
-            if (param.type === 'boolean' && !regexp.test(param.name)) {
-                report({
-                    message: `Boolean parameter \`${param.name}\` should have ${prefixesString} prefix.`,
-                    location: location.child('name'),
-                });
-            }
-        },
-    };
-};
-//# sourceMappingURL=boolean-parameter-prefixes.js.map

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

@@ -1,93 +0,0 @@
-import { Struct } from '../common/struct.js';
-import { NoInvalidSchemaExamples } from '../common/no-invalid-schema-examples.js';
-import { NoInvalidParameterExamples } from '../common/no-invalid-parameter-examples.js';
-import { InfoContact } from '../common/info-contact.js';
-import { InfoLicense } from '../common/info-license.js';
-import { InfoLicenseStrict } from '../common/info-license-strict.js';
-import { BooleanParameterPrefixes } from './boolean-parameter-prefixes.js';
-import { TagDescription } from '../common/tag-description.js';
-import { TagsAlphabetical } from '../common/tags-alphabetical.js';
-import { PathsKebabCase } from '../common/paths-kebab-case.js';
-import { NoEnumTypeMismatch } from '../common/no-enum-type-mismatch.js';
-import { NoPathTrailingSlash } from '../common/no-path-trailing-slash.js';
-import { Operation2xxResponse } from '../common/operation-2xx-response.js';
-import { Operation4xxResponse } from '../common/operation-4xx-response.js';
-import { Assertions } from '../common/assertions/index.js';
-import { OperationIdUnique } from '../common/operation-operationId-unique.js';
-import { OperationParametersUnique } from '../common/operation-parameters-unique.js';
-import { PathParamsDefined } from '../common/path-params-defined.js';
-import { OperationTagDefined } from '../common/operation-tag-defined.js';
-import { PathDeclarationMustExist } from '../common/path-declaration-must-exist.js';
-import { OperationIdUrlSafe } from '../common/operation-operationId-url-safe.js';
-import { OperationDescription } from '../common/operation-description.js';
-import { PathNotIncludeQuery } from '../common/path-not-include-query.js';
-import { ParameterDescription } from '../common/parameter-description.js';
-import { OperationSingularTag } from '../common/operation-singular-tag.js';
-import { SecurityDefined } from '../common/security-defined.js';
-import { NoUnresolvedRefs } from '../common/no-unresolved-refs.js';
-import { PathHttpVerbsOrder } from '../common/path-http-verbs-order.js';
-import { NoIdenticalPaths } from '../common/no-identical-paths.js';
-import { OperationOperationId } from '../common/operation-operationId.js';
-import { OperationSummary } from '../common/operation-summary.js';
-import { NoAmbiguousPaths } from '../common/no-ambiguous-paths.js';
-import { NoHttpVerbsInPaths } from '../common/no-http-verbs-in-paths.js';
-import { RequestMimeType } from './request-mime-type.js';
-import { ResponseMimeType } from './response-mime-type.js';
-import { PathSegmentPlural } from '../common/path-segment-plural.js';
-import { ResponseContainsHeader } from '../common/response-contains-header.js';
-import { ResponseContainsProperty } from './response-contains-property.js';
-import { ScalarPropertyMissingExample } from '../common/scalar-property-missing-example.js';
-import { RequiredStringPropertyMissingMinLength } from '../common/required-string-property-missing-min-length.js';
-import { SpecStrictRefs } from '../common/spec-strict-refs.js';
-import { NoRequiredSchemaPropertiesUndefined } from '../common/no-required-schema-properties-undefined.js';
-import { NoSchemaTypeMismatch } from '../common/no-schema-type-mismatch.js';
-import { NoDuplicatedTagNames } from '../common/no-duplicated-tag-names.js';
-export const rules = {
-    struct: Struct,
-    'no-invalid-schema-examples': NoInvalidSchemaExamples,
-    'no-invalid-parameter-examples': NoInvalidParameterExamples,
-    'info-contact': InfoContact,
-    'info-license': InfoLicense,
-    'info-license-strict': InfoLicenseStrict,
-    'tag-description': TagDescription,
-    'tags-alphabetical': TagsAlphabetical,
-    'paths-kebab-case': PathsKebabCase,
-    'no-enum-type-mismatch': NoEnumTypeMismatch,
-    'boolean-parameter-prefixes': BooleanParameterPrefixes,
-    'no-path-trailing-slash': NoPathTrailingSlash,
-    'operation-2xx-response': Operation2xxResponse,
-    'operation-4xx-response': Operation4xxResponse,
-    assertions: Assertions,
-    'operation-operationId-unique': OperationIdUnique,
-    'operation-parameters-unique': OperationParametersUnique,
-    'path-parameters-defined': PathParamsDefined,
-    'operation-tag-defined': OperationTagDefined,
-    'path-declaration-must-exist': PathDeclarationMustExist,
-    'operation-operationId-url-safe': OperationIdUrlSafe,
-    'operation-operationId': OperationOperationId,
-    'operation-summary': OperationSummary,
-    'operation-description': OperationDescription,
-    'path-not-include-query': PathNotIncludeQuery,
-    'path-params-defined': PathParamsDefined,
-    'parameter-description': ParameterDescription,
-    'operation-singular-tag': OperationSingularTag,
-    'security-defined': SecurityDefined,
-    'no-unresolved-refs': NoUnresolvedRefs,
-    'no-identical-paths': NoIdenticalPaths,
-    'no-ambiguous-paths': NoAmbiguousPaths,
-    'path-http-verbs-order': PathHttpVerbsOrder,
-    'no-http-verbs-in-paths': NoHttpVerbsInPaths,
-    'request-mime-type': RequestMimeType,
-    'response-mime-type': ResponseMimeType,
-    'path-segment-plural': PathSegmentPlural,
-    'response-contains-header': ResponseContainsHeader,
-    'response-contains-property': ResponseContainsProperty,
-    'scalar-property-missing-example': ScalarPropertyMissingExample,
-    'required-string-property-missing-min-length': RequiredStringPropertyMissingMinLength,
-    'spec-strict-refs': SpecStrictRefs,
-    'no-required-schema-properties-undefined': NoRequiredSchemaPropertiesUndefined,
-    'no-schema-type-mismatch': NoSchemaTypeMismatch,
-    'no-duplicated-tag-names': NoDuplicatedTagNames,
-};
-export const preprocessors = {};
-//# sourceMappingURL=index.js.map