@kubb/agent 4.27.2 → 4.27.4

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/other/stats.js

@@ -1,74 +0,0 @@
-export const Stats = (statsAccumulator) => {
-    return {
-        ExternalDocs: {
-            leave() {
-                statsAccumulator.externalDocs.total++;
-            },
-        },
-        ref: {
-            enter(ref) {
-                statsAccumulator.refs.items.add(ref['$ref']);
-            },
-        },
-        Tag: {
-            leave(tag) {
-                statsAccumulator.tags.items.add(tag.name);
-            },
-        },
-        Link: {
-            leave(link) {
-                statsAccumulator.links.items.add(link.operationId);
-            },
-        },
-        Root: {
-            leave() {
-                statsAccumulator.parameters.total = statsAccumulator.parameters.items.size;
-                statsAccumulator.refs.total = statsAccumulator.refs.items.size;
-                statsAccumulator.links.total = statsAccumulator.links.items.size;
-                statsAccumulator.tags.total = statsAccumulator.tags.items.size;
-            },
-        },
-        WebhooksMap: {
-            Operation: {
-                leave(operation) {
-                    statsAccumulator.webhooks.total++;
-                    if (operation.tags) {
-                        for (const tag of operation.tags) {
-                            statsAccumulator.tags.items.add(tag);
-                        }
-                    }
-                },
-            },
-        },
-        Paths: {
-            PathItem: {
-                leave() {
-                    statsAccumulator.pathItems.total++;
-                },
-                Operation: {
-                    leave(operation) {
-                        statsAccumulator.operations.total++;
-                        if (operation.tags) {
-                            for (const tag of operation.tags) {
-                                statsAccumulator.tags.items.add(tag);
-                            }
-                        }
-                    },
-                },
-                Parameter: {
-                    leave(parameter) {
-                        statsAccumulator.parameters.items.add(parameter.name);
-                    },
-                },
-            },
-        },
-        NamedSchemas: {
-            Schema: {
-                leave() {
-                    statsAccumulator.schemas.total++;
-                },
-            },
-        },
-    };
-};
-//# sourceMappingURL=stats.js.map

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

@@ -1,12 +0,0 @@
-import { Assertions } from '../common/assertions/index.js';
-import { InfoContact } from '../common/info-contact.js';
-import { Struct } from '../common/struct.js';
-import { NoUnresolvedRefs } from '../common/no-unresolved-refs.js';
-export const rules = {
-    'info-contact': InfoContact,
-    struct: Struct,
-    'no-unresolved-refs': NoUnresolvedRefs,
-    assertions: Assertions,
-};
-export const preprocessors = {};
-//# sourceMappingURL=index.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/respect/no-criteria-xpath.js

@@ -1,20 +0,0 @@
-import { isPlainObject } from '../../utils/is-plain-object.js';
-export const NoCriteriaXpath = () => {
-    return {
-        CriterionObject: {
-            enter(criteria, { report, location }) {
-                if (!criteria.type) {
-                    return;
-                }
-                if (criteria.type === 'xpath' ||
-                    (isPlainObject(criteria.type) && criteria.type.type === 'xpath')) {
-                    report({
-                        message: 'The `xpath` type criteria is not supported by Respect.',
-                        location: location.child(['type']),
-                    });
-                }
-            },
-        },
-    };
-};
-//# sourceMappingURL=no-criteria-xpath.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/respect/no-x-security-both-scheme-and-scheme-name.js

@@ -1,30 +0,0 @@
-import { getOwn } from '../../utils/get-own.js';
-export const NoXSecurityBothSchemeAndSchemeName = () => {
-    function validate(extendedSecurity, { report, location }) {
-        if (!Array.isArray(extendedSecurity))
-            return;
-        for (const security of extendedSecurity) {
-            const hasScheme = getOwn(security, 'scheme');
-            const hasSchemeName = getOwn(security, 'schemeName');
-            if (hasScheme && hasSchemeName) {
-                report({
-                    message: '`x-security` item must not contain both `scheme` and `schemeName`.',
-                    location: location.child(['x-security', extendedSecurity.indexOf(security)]),
-                });
-            }
-        }
-    }
-    return {
-        Workflow: {
-            enter(workflow, context) {
-                validate(workflow?.['x-security'], context);
-            },
-        },
-        Step: {
-            enter(step, context) {
-                validate(step?.['x-security'], context);
-            },
-        },
-    };
-};
-//# sourceMappingURL=no-x-security-both-scheme-and-scheme-name.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/respect/no-x-security-scheme-name-without-openapi.js

@@ -1,25 +0,0 @@
-export const NoXSecuritySchemeNameWithoutOpenAPI = () => {
-    return {
-        Step: {
-            enter(step, { report, location }) {
-                const hasExtendedOperation = step?.['x-operation'];
-                if (!hasExtendedOperation) {
-                    return;
-                }
-                const extendedSecurity = step?.['x-security'];
-                if (!extendedSecurity) {
-                    return;
-                }
-                for (const security of extendedSecurity) {
-                    if ('schemeName' in security) {
-                        report({
-                            message: 'The `schemeName` can be only used in Step with OpenAPI operation, please use `scheme` instead.',
-                            location: location.child(['x-security', extendedSecurity.indexOf(security)]),
-                        });
-                    }
-                }
-            },
-        },
-    };
-};
-//# sourceMappingURL=no-x-security-scheme-name-without-openapi.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/respect/respect-supported-versions.js

@@ -1,18 +0,0 @@
-import { ARAZZO_VERSIONS_SUPPORTED_BY_RESPECT } from '../../typings/arazzo.js';
-import { pluralize } from '../../utils/pluralize.js';
-export const RespectSupportedVersions = () => {
-    const supportedVersions = ARAZZO_VERSIONS_SUPPORTED_BY_RESPECT.join(', ');
-    return {
-        Root: {
-            enter(root, { report, location }) {
-                if (!ARAZZO_VERSIONS_SUPPORTED_BY_RESPECT.includes(root.arazzo)) {
-                    report({
-                        message: `Only ${supportedVersions} Arazzo ${pluralize('version is', ARAZZO_VERSIONS_SUPPORTED_BY_RESPECT.length)} fully supported by Respect.`,
-                        location: location.child('arazzo'),
-                    });
-                }
-            },
-        },
-    };
-};
-//# sourceMappingURL=respect-supported-versions.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/respect/x-security-scheme-name-reference.js

@@ -1,35 +0,0 @@
-export const XSecuritySchemeNameReference = () => {
-    let sourceDescriptionsCount = 0;
-    return {
-        SourceDescriptions: {
-            enter(sourceDescriptions) {
-                sourceDescriptionsCount = Array.isArray(sourceDescriptions) ? sourceDescriptions.length : 0;
-            },
-        },
-        Workflow: {
-            leave(workflow, { report, location }) {
-                const extendedSecurity = workflow?.['x-security'];
-                if (!extendedSecurity || sourceDescriptionsCount <= 1) {
-                    return;
-                }
-                for (const security of extendedSecurity) {
-                    if ('schemeName' in security) {
-                        const schemeName = security.schemeName;
-                        const isReference = typeof schemeName === 'string' && schemeName.startsWith('$sourceDescriptions.');
-                        if (!isReference) {
-                            report({
-                                message: 'When multiple `sourceDescriptions` exist, `workflow.x-security.schemeName` must be a reference to a source description (e.g. `$sourceDescriptions.{name}.{schemeName}`)',
-                                location: location.child([
-                                    'x-security',
-                                    extendedSecurity.indexOf(security),
-                                    'schemeName',
-                                ]),
-                            });
-                        }
-                    }
-                }
-            },
-        },
-    };
-};
-//# sourceMappingURL=x-security-scheme-name-reference.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/rules/respect/x-security-scheme-required-values.js

@@ -1,60 +0,0 @@
-import { logger } from '../../logger.js';
-const REQUIRED_VALUES_BY_AUTH_TYPE = {
-    apiKey: ['apiKey'],
-    basic: ['username', 'password'],
-    digest: ['username', 'password'],
-    bearer: ['token'],
-    oauth2: ['accessToken'],
-    openIdConnect: ['accessToken'],
-    mutualTLS: [],
-};
-function validateSecuritySchemas(extendedSecurity, { report, location }) {
-    if (!extendedSecurity) {
-        return;
-    }
-    for (const securitySchema of extendedSecurity) {
-        // TODO: Handle schemeName case, this will require bundled OpenAPI definitions
-        if ('schemeName' in securitySchema) {
-            continue;
-        }
-        const { scheme, values } = securitySchema;
-        // TODO: Struct rule does not check before this point, so we need to check it here. Investigate if we can move this check to the Struct rule.
-        const authType = scheme?.type === 'http' ? scheme.scheme : scheme?.type;
-        if (authType === 'mutualTLS') {
-            logger.warn('Please use CLI option to provide mutualTLS certificates for mutualTls authentication security schema.');
-            continue;
-        }
-        const requiredValues = REQUIRED_VALUES_BY_AUTH_TYPE[authType];
-        if (requiredValues) {
-            for (const requiredValue of requiredValues) {
-                if (!values || !(requiredValue in values)) {
-                    report({
-                        message: `The \`${requiredValue}\` is required when using the ${authType} authentication security schema.`,
-                        location: location.child(['x-security', extendedSecurity.indexOf(securitySchema)]),
-                    });
-                }
-            }
-        }
-        else {
-            report({
-                message: `The \`${authType}\` authentication security schema is not supported.`,
-                location: location.child(['x-security', extendedSecurity.indexOf(securitySchema)]),
-            });
-        }
-    }
-}
-export const XSecuritySchemaRequiredValues = () => {
-    return {
-        Step: {
-            enter(step, context) {
-                validateSecuritySchemas(step?.['x-security'], context);
-            },
-        },
-        Workflow: {
-            enter(workflow, context) {
-                validateSecuritySchemas(workflow?.['x-security'], context);
-            },
-        },
-    };
-};
-//# sourceMappingURL=x-security-scheme-required-values.js.map

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

@@ -1,172 +0,0 @@
-import { default as levenshtein } from 'js-levenshtein';
-import { Location } from '../ref-utils.js';
-import { validateJsonSchema } from './ajv.js';
-import { isPlainObject } from '../utils/is-plain-object.js';
-export function oasTypeOf(value) {
-    if (Array.isArray(value)) {
-        return 'array';
-    }
-    else if (value === null) {
-        return 'null';
-    }
-    else if (Number.isInteger(value)) {
-        return 'integer';
-    }
-    else {
-        return typeof value;
-    }
-}
-/**
- * Checks if value matches specified JSON schema type
- *
- * @param {*} value - value to check
- * @param {JSONSchemaType} type - JSON Schema type
- * @returns boolean
- */
-export function matchesJsonSchemaType(value, type, nullable) {
-    if (nullable && value === null) {
-        return true;
-    }
-    switch (type) {
-        case 'array':
-            return Array.isArray(value);
-        case 'object':
-            return isPlainObject(value);
-        case 'null':
-            return value === null;
-        case 'integer':
-            return Number.isInteger(value);
-        default:
-            return typeof value === type;
-    }
-}
-export function missingRequiredField(type, field) {
-    return `${type} object should contain \`${field}\` field.`;
-}
-export function missingRequiredOneOfFields(type, fields) {
-    return `${type} object should contain one of the fields: ${fields
-        .map((field) => `\`${field}\``)
-        .join(', ')}.`;
-}
-export function fieldNonEmpty(type, field) {
-    return `${type} object \`${field}\` must be non-empty string.`;
-}
-export function validateDefinedAndNonEmpty(fieldName, value, ctx) {
-    if (!isPlainObject(value)) {
-        return;
-    }
-    if (value[fieldName] === undefined) {
-        ctx.report({
-            message: missingRequiredField(ctx.type.name, fieldName),
-            location: ctx.location.child([fieldName]).key(),
-        });
-    }
-    else if (!value[fieldName]) {
-        ctx.report({
-            message: fieldNonEmpty(ctx.type.name, fieldName),
-            location: ctx.location.child([fieldName]).key(),
-        });
-    }
-}
-export function validateOneOfDefinedAndNonEmpty(fieldNames, value, ctx) {
-    if (!isPlainObject(value)) {
-        return;
-    }
-    if (!fieldNames.some((fieldName) => value.hasOwnProperty(fieldName))) {
-        ctx.report({
-            message: missingRequiredOneOfFields(ctx.type.name, fieldNames),
-            location: ctx.location.key(),
-        });
-    }
-    for (const fieldName of fieldNames) {
-        if (value.hasOwnProperty(fieldName) && !value[fieldName]) {
-            ctx.report({
-                message: fieldNonEmpty(ctx.type.name, fieldName),
-                location: ctx.location.child([fieldName]).key(),
-            });
-        }
-    }
-}
-export function getSuggest(given, variants) {
-    if (given === null)
-        return variants;
-    if (typeof given !== 'string' || !variants.length)
-        return [];
-    const distances = [];
-    for (let i = 0; i < variants.length; i++) {
-        const distance = levenshtein(given, variants[i]);
-        if (distance < 4) {
-            distances.push({ distance, variant: variants[i] });
-        }
-    }
-    distances.sort((a, b) => a.distance - b.distance);
-    // if (bestMatch.distance <= 4) return bestMatch.string;
-    return distances.map((d) => d.variant);
-}
-export function validateExample(example, schema, options) {
-    const { location, ctx, allowAdditionalProperties, ajvContext } = options;
-    const { resolve, location: parentLocation, report, specVersion } = ctx;
-    try {
-        const { valid, errors } = validateJsonSchema(example, schema, {
-            schemaLoc: parentLocation.child('schema'),
-            instancePath: location.pointer,
-            resolve,
-            allowAdditionalProperties,
-            ajvContext,
-            specVersion,
-        });
-        if (!valid) {
-            for (const error of errors) {
-                report({
-                    message: `Example value must conform to the schema: ${error.message}.`,
-                    location: {
-                        ...new Location(location.source, error.instancePath),
-                        reportOnKey: error.keyword === 'unevaluatedProperties' || error.keyword === 'additionalProperties',
-                    },
-                    from: parentLocation,
-                    suggest: error.suggest,
-                });
-            }
-        }
-    }
-    catch (e) {
-        if (e.message === 'discriminator: requires oneOf or anyOf composite keyword') {
-            return;
-        }
-        report({
-            message: `Example validation errored: ${e.message}.`,
-            location: parentLocation.child('schema'),
-            from: parentLocation,
-        });
-    }
-}
-export function validateSchemaEnumType(schemaEnum, propertyValue, propName, refLocation, { report, location }) {
-    if (!schemaEnum) {
-        return;
-    }
-    if (!schemaEnum.includes(propertyValue)) {
-        report({
-            location,
-            message: `\`${propName}\` can be one of the following only: ${schemaEnum
-                .map((type) => `"${type}"`)
-                .join(', ')}.`,
-            from: refLocation,
-            suggest: getSuggest(propertyValue, schemaEnum),
-        });
-    }
-}
-export function validateResponseCodes(responseCodes, codeRange, { report }) {
-    const responseCodeRegexp = new RegExp(`^${codeRange[0]}[0-9Xx]{2}$`);
-    const containsNeededCode = responseCodes.some((code) => (codeRange === '2XX' && code === 'default') || // It's OK to replace 2xx codes with the default
-        responseCodeRegexp.test(code));
-    if (!containsNeededCode) {
-        report({
-            message: `Operation must have at least one \`${codeRange}\` response.`,
-            location: { reportOnKey: true },
-        });
-    }
-}
-export function getTagName(tag, ignoreCase) {
-    return ignoreCase ? tag.name.toLowerCase() : tag.name;
-}
-//# sourceMappingURL=utils.js.map