@kubb/agent 4.33.1 → 4.33.3

package/.output/server/node_modules/@redocly/config/lib/scorecards-config-schema.js

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scorecardsConfigSchema = exports.scorecardSchema = void 0;
+const common_1 = require("./common");
+const comparisonOperatorSchema = {
+    type: 'string',
+    enum: [
+        'eq',
+        'in',
+        'gt',
+        'gte',
+        'lt',
+        'lte',
+        'contains',
+        'startsWith',
+        'endsWith',
+        'exists',
+        'isEmpty',
+        'between',
+        'matches',
+        'some',
+        'every',
+        'none',
+    ],
+};
+const logicalOperatorSchema = {
+    type: 'string',
+    enum: ['and', 'or'],
+};
+// Base condition schema with field, operator, value, modifier, and match properties
+const conditionSchema = {
+    type: 'object',
+    properties: {
+        field: { type: 'string' },
+        operator: comparisonOperatorSchema,
+        value: {
+            oneOf: [{ type: 'boolean' }, { type: 'string' }, { type: 'number' }],
+        },
+        modifier: { type: 'string', enum: ['not'] },
+        match: {
+            type: 'array',
+            items: {
+                type: 'object',
+                properties: {
+                    field: { type: 'string' },
+                    operator: comparisonOperatorSchema,
+                    value: {
+                        oneOf: [{ type: 'boolean' }, { type: 'string' }, { type: 'number' }],
+                    },
+                    modifier: { type: 'string', enum: ['not'] },
+                },
+            },
+        },
+    },
+};
+// Schema for a logical operator with conditions (used for nesting)
+const logicalOperatorConditionSchema = {
+    type: 'object',
+    properties: {
+        operator: logicalOperatorSchema,
+        conditions: {
+            type: 'array',
+            items: conditionSchema, // At the deepest level, only simple conditions
+        },
+    },
+    required: ['operator', 'conditions'],
+    additionalProperties: false,
+};
+// Conditions schema allowing nested conditions with up to 2 levels of recursion
+const conditionsSchema = {
+    type: 'array',
+    items: {
+        oneOf: [
+            conditionSchema,
+            {
+                type: 'object',
+                properties: {
+                    operator: logicalOperatorSchema,
+                    conditions: {
+                        type: 'array',
+                        items: {
+                            oneOf: [conditionSchema, logicalOperatorConditionSchema],
+                        },
+                    },
+                },
+                required: ['operator', 'conditions'],
+                additionalProperties: false,
+            },
+        ],
+    },
+};
+const entityRuleAssertionSchema = {
+    type: 'object',
+    properties: {
+        defined: { type: 'boolean' },
+        nonEmpty: { type: 'boolean' },
+        eq: {},
+        gt: { type: 'number' },
+        gte: { type: 'number' },
+        lt: { type: 'number' },
+        lte: { type: 'number' },
+        const: {},
+    },
+    additionalProperties: false,
+};
+const entityRuleWhereSchema = {
+    type: 'array',
+    items: {
+        type: 'object',
+        properties: {
+            subject: {
+                type: 'object',
+                properties: {
+                    type: {
+                        type: 'string',
+                        enum: ['Entity', 'EntityMetadata', 'EntityRelations', 'EntityRelation'],
+                    },
+                    property: { type: 'string' },
+                },
+                required: ['type', 'property'],
+                additionalProperties: false,
+            },
+            assertions: entityRuleAssertionSchema,
+        },
+        required: ['subject', 'assertions'],
+        additionalProperties: false,
+    },
+};
+const entityRuleSchema = {
+    type: 'object',
+    properties: {
+        title: { type: 'string' },
+        subject: {
+            type: 'object',
+            properties: {
+                type: {
+                    type: 'string',
+                    enum: ['Entity', 'EntityMetadata', 'EntityRelations', 'EntityRelation'],
+                },
+                property: { type: 'string' },
+            },
+            required: ['type', 'property'],
+            additionalProperties: false,
+        },
+        severity: {
+            type: 'string',
+            enum: ['error', 'warn', 'off'],
+        },
+        message: { type: 'string' },
+        assertions: entityRuleAssertionSchema,
+        where: entityRuleWhereSchema,
+        weight: { type: 'number', default: 1 },
+    },
+    required: ['subject', 'assertions'],
+    additionalProperties: false,
+};
+// Supports both OpenAPI/AsyncAPI rules (backward compatibility) and entity rules
+const levelRulesSchema = {
+    type: 'object',
+    additionalProperties: {
+        oneOf: [
+            { type: 'string' },
+            {
+                type: 'object',
+                properties: {
+                    severity: {
+                        type: 'string',
+                        enum: ['error', 'warn', 'off'],
+                    },
+                    weight: { type: 'number', default: 1 },
+                },
+                additionalProperties: true,
+            },
+            entityRuleSchema,
+        ],
+    },
+};
+const levelSchema = {
+    type: 'object',
+    properties: {
+        name: { type: 'string' },
+        extends: common_1.configGovernanceSchema.extends,
+        rules: levelRulesSchema,
+    },
+    required: ['name'],
+    additionalProperties: false,
+};
+const triggerEventSchema = {
+    type: 'object',
+    properties: {
+        event: {
+            type: 'string',
+            enum: ['runtime', 'manual'],
+        },
+    },
+    required: ['event'],
+    additionalProperties: false,
+};
+const triggerSchema = {
+    oneOf: [
+        triggerEventSchema,
+        {
+            type: 'array',
+            items: triggerEventSchema,
+        },
+    ],
+};
+exports.scorecardSchema = {
+    type: 'object',
+    properties: {
+        name: { type: 'string' },
+        key: { type: 'string' },
+        description: { type: 'string' },
+        entities: {
+            oneOf: [
+                conditionsSchema,
+                {
+                    type: 'object',
+                    properties: {
+                        operator: logicalOperatorSchema,
+                        conditions: conditionsSchema,
+                    },
+                    required: ['operator', 'conditions'],
+                    additionalProperties: false,
+                },
+            ],
+        },
+        levels: {
+            type: 'array',
+            items: levelSchema,
+            minItems: 1,
+        },
+        trigger: triggerSchema,
+    },
+    required: ['name', 'key', 'entities', 'levels'],
+    additionalProperties: false,
+};
+exports.scorecardsConfigSchema = {
+    type: 'array',
+    items: exports.scorecardSchema,
+};
+//# sourceMappingURL=scorecards-config-schema.js.map

package/.output/server/node_modules/@redocly/config/lib/types/api-functions-types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=api-functions-types.js.map

package/.output/server/node_modules/@redocly/config/lib/types/catalog-entity-types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=catalog-entity-types.js.map

package/.output/server/node_modules/@redocly/config/lib/types/code-walkthrough-types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=code-walkthrough-types.js.map

package/.output/server/node_modules/@redocly/config/lib/types/config-types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=config-types.js.map

package/.output/server/node_modules/@redocly/config/lib/types/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./api-functions-types"), exports);
+__exportStar(require("./config-types"), exports);
+__exportStar(require("./portal-shared-types"), exports);
+__exportStar(require("./catalog-entity-types"), exports);
+//# sourceMappingURL=index.js.map

package/.output/server/node_modules/@redocly/config/lib/types/portal-shared-types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./code-walkthrough-types"), exports);
+//# sourceMappingURL=portal-shared-types.js.map

package/.output/server/node_modules/@redocly/config/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@redocly/config",
+  "version": "0.44.1",
+  "license": "MIT",
+  "main": "./lib/index.js",
+  "module": "./lib-esm/index.js",
+  "types": "./lib/index.d.ts",
+  "devDependencies": {
+    "@markdoc/markdoc": "0.5.2",
+    "@redocly/openapi-core": "2.20.4",
+    "@types/node": "22.18.13",
+    "@types/react": "^19.2.7",
+    "@vitest/coverage-v8": "4.0.10",
+    "react-router-dom": "^6.30.3",
+    "rimraf": "5.0.7",
+    "typescript": "5.9.3",
+    "vitest": "4.0.10"
+  },
+  "dependencies": {
+    "json-schema-to-ts": "2.7.2"
+  },
+  "scripts": {
+    "clean": "rimraf lib",
+    "compile": "tsc -p tsconfig.build.json && tsc -p tsconfig.lib-esm.json",
+    "build": "pnpm run clean && pnpm run compile",
+    "test": "vitest run src"
+  }
+}

package/.output/server/node_modules/@redocly/openapi-core/lib/bundle/bundle-document.js

@@ -0,0 +1,85 @@
+import { makeBundleVisitor } from '../bundle/bundle-visitor.js';
+import { initRules } from '../config/rules.js';
+import { RemoveUnusedComponents as RemoveUnusedComponentsOas2 } from '../decorators/oas2/remove-unused-components.js';
+import { RemoveUnusedComponents as RemoveUnusedComponentsOas3 } from '../decorators/oas3/remove-unused-components.js';
+import { detectSpec, getMajorSpecVersion } from '../detect-spec.js';
+import { resolveDocument } from '../resolve.js';
+import { normalizeTypes } from '../types/index.js';
+import { normalizeVisitors } from '../visitors.js';
+import { walkDocument } from '../walk.js';
+export async function bundleDocument(opts) {
+    const { document, config, types, externalRefResolver, dereference = false, removeUnusedComponents = false, keepUrlRefs = false, componentRenamingConflicts, } = opts;
+    const specVersion = detectSpec(document.parsed);
+    const specMajorVersion = getMajorSpecVersion(specVersion);
+    const rules = config.getRulesForSpecVersion(specMajorVersion);
+    const normalizedTypes = normalizeTypes(config.extendTypes(types, specVersion), config);
+    const preprocessors = initRules(rules, config, 'preprocessors', specVersion);
+    const decorators = initRules(rules, config, 'decorators', specVersion);
+    const ctx = {
+        problems: [],
+        specVersion,
+        config,
+        refTypes: new Map(),
+        visitorsData: {},
+    };
+    if (removeUnusedComponents && !decorators.some((d) => d.ruleId === 'remove-unused-components')) {
+        decorators.push({
+            severity: 'error',
+            ruleId: 'remove-unused-components',
+            visitor: specMajorVersion === 'oas2'
+                ? RemoveUnusedComponentsOas2({})
+                : RemoveUnusedComponentsOas3({}),
+        });
+    }
+    let resolvedRefMap = await resolveDocument({
+        rootDocument: document,
+        rootType: normalizedTypes.Root,
+        externalRefResolver,
+    });
+    if (preprocessors.length > 0) {
+        // Make additional pass to resolve refs defined in preprocessors.
+        walkDocument({
+            document,
+            rootType: normalizedTypes.Root,
+            normalizedVisitors: normalizeVisitors(preprocessors, normalizedTypes),
+            resolvedRefMap,
+            ctx,
+        });
+        resolvedRefMap = await resolveDocument({
+            rootDocument: document,
+            rootType: normalizedTypes.Root,
+            externalRefResolver,
+        });
+    }
+    const bundleVisitor = normalizeVisitors([
+        {
+            severity: 'error',
+            ruleId: 'bundler',
+            visitor: makeBundleVisitor({
+                version: specMajorVersion,
+                dereference,
+                rootDocument: document,
+                resolvedRefMap,
+                keepUrlRefs,
+                componentRenamingConflicts,
+            }),
+        },
+        ...decorators,
+    ], normalizedTypes);
+    walkDocument({
+        document,
+        rootType: normalizedTypes.Root,
+        normalizedVisitors: bundleVisitor,
+        resolvedRefMap,
+        ctx,
+    });
+    return {
+        bundle: document,
+        problems: ctx.problems.map((problem) => config.addProblemToIgnore(problem)),
+        fileDependencies: externalRefResolver.getFiles(),
+        rootType: normalizedTypes.Root,
+        refTypes: ctx.refTypes,
+        visitorsData: ctx.visitorsData,
+    };
+}
+//# sourceMappingURL=bundle-document.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/bundle/bundle-visitor.js

@@ -0,0 +1,257 @@
+import { isAbsoluteUrl, replaceRef, isExternalValue, isRef, refBaseName } from '../ref-utils.js';
+import { reportUnresolvedRef } from '../rules/common/no-unresolved-refs.js';
+import { dequal } from '../utils/dequal.js';
+import { isTruthy } from '../utils/is-truthy.js';
+import { makeRefId } from '../utils/make-ref-id.js';
+export function mapTypeToComponent(typeName, version) {
+    switch (version) {
+        case 'oas3':
+            switch (typeName) {
+                case 'Schema':
+                    return 'schemas';
+                case 'Parameter':
+                    return 'parameters';
+                case 'Response':
+                    return 'responses';
+                case 'Example':
+                    return 'examples';
+                case 'RequestBody':
+                    return 'requestBodies';
+                case 'Header':
+                    return 'headers';
+                case 'SecuritySchema':
+                    return 'securitySchemes';
+                case 'Link':
+                    return 'links';
+                case 'Callback':
+                    return 'callbacks';
+                case 'MediaTypesMap':
+                    return 'mediaTypes';
+                default:
+                    return null;
+            }
+        case 'oas2':
+            switch (typeName) {
+                case 'Schema':
+                    return 'definitions';
+                case 'Parameter':
+                    return 'parameters';
+                case 'Response':
+                    return 'responses';
+                default:
+                    return null;
+            }
+        case 'async2':
+            switch (typeName) {
+                case 'Schema':
+                    return 'schemas';
+                case 'Parameter':
+                    return 'parameters';
+                default:
+                    return null;
+            }
+        case 'async3':
+            switch (typeName) {
+                case 'Schema':
+                    return 'schemas';
+                case 'Parameter':
+                    return 'parameters';
+                default:
+                    return null;
+            }
+        case 'arazzo1':
+            switch (typeName) {
+                case 'Root.workflows_items.parameters_items':
+                case 'Root.workflows_items.steps_items.parameters_items':
+                    return 'parameters';
+                default:
+                    return null;
+            }
+        case 'overlay1':
+            switch (typeName) {
+                default:
+                    return null;
+            }
+        case 'openrpc1':
+            switch (typeName) {
+                case 'ContentDescriptor':
+                    return 'contentDescriptors';
+                case 'Schema':
+                    return 'schemas';
+                case 'Example':
+                    return 'examples';
+                case 'Link':
+                    return 'links';
+                case 'ErrorObject':
+                    return 'errors';
+                case 'ExamplePairing':
+                    return 'examplePairingObjects';
+                case 'Tag':
+                    return 'tags';
+                default:
+                    return null;
+            }
+    }
+}
+export function makeBundleVisitor({ version, dereference, rootDocument, resolvedRefMap, keepUrlRefs, componentRenamingConflicts = 'warn', }) {
+    let components;
+    let rootLocation;
+    const visitor = {
+        ref: {
+            leave(node, ctx, resolved) {
+                if (!resolved.location || resolved.node === undefined) {
+                    reportUnresolvedRef(resolved, ctx.report, ctx.location);
+                    return;
+                }
+                if (resolved.location.source === rootDocument.source &&
+                    resolved.location.source === ctx.location.source &&
+                    ctx.type.name !== 'scalar' &&
+                    !dereference) {
+                    // Normalize explicit self-file refs to internal pointer
+                    if (node.$ref !== resolved.location.pointer) {
+                        node.$ref = resolved.location.pointer;
+                    }
+                    return;
+                }
+                if (keepUrlRefs && isAbsoluteUrl(node.$ref)) {
+                    return;
+                }
+                const componentType = mapTypeToComponent(ctx.type.name, version);
+                if (!componentType) {
+                    replaceRef(node, resolved, ctx);
+                }
+                else {
+                    if (dereference) {
+                        saveComponent(componentType, resolved, ctx);
+                        replaceRef(node, resolved, ctx);
+                    }
+                    else {
+                        node.$ref = saveComponent(componentType, resolved, ctx);
+                        resolveBundledComponent(node, resolved, ctx);
+                    }
+                }
+            },
+        },
+        Example: {
+            leave(node, ctx) {
+                if (isExternalValue(node) && node.value === undefined) {
+                    const resolved = ctx.resolve({ $ref: node.externalValue });
+                    if (!resolved.location || resolved.node === undefined) {
+                        reportUnresolvedRef(resolved, ctx.report, ctx.location);
+                        return;
+                    }
+                    if (keepUrlRefs && isAbsoluteUrl(node.externalValue)) {
+                        return;
+                    }
+                    node.value = ctx.resolve({ $ref: node.externalValue }).node;
+                    delete node.externalValue;
+                }
+            },
+        },
+        Root: {
+            enter(root, ctx) {
+                rootLocation = ctx.location;
+                if (version === 'oas3') {
+                    components = root.components = root.components || {};
+                }
+                else if (version === 'oas2') {
+                    components = root;
+                }
+                else if (version === 'async2') {
+                    components = root.components = root.components || {};
+                }
+                else if (version === 'async3') {
+                    components = root.components = root.components || {};
+                }
+                else if (version === 'arazzo1') {
+                    components = root.components = root.components || {};
+                }
+                else if (version === 'openrpc1') {
+                    components = root.components = root.components || {};
+                }
+            },
+        },
+    };
+    if (version === 'oas3') {
+        visitor.DiscriminatorMapping = {
+            leave(mapping, ctx) {
+                for (const name of Object.keys(mapping)) {
+                    const $ref = mapping[name];
+                    const resolved = ctx.resolve({ $ref });
+                    if (!resolved.location || resolved.node === undefined) {
+                        reportUnresolvedRef(resolved, ctx.report, ctx.location.child(name));
+                        return;
+                    }
+                    const componentType = mapTypeToComponent('Schema', version);
+                    mapping[name] = saveComponent(componentType, resolved, ctx);
+                }
+            },
+        };
+    }
+    function resolveBundledComponent(node, resolved, ctx) {
+        const newRefId = makeRefId(ctx.location.source.absoluteRef, node.$ref);
+        resolvedRefMap.set(newRefId, {
+            document: rootDocument,
+            isRemote: false,
+            node: resolved.node,
+            nodePointer: node.$ref,
+            resolved: true,
+        });
+    }
+    function saveComponent(componentType, target, ctx) {
+        components[componentType] = components[componentType] || {};
+        const name = getComponentName(target, componentType, ctx);
+        components[componentType][name] = target.node;
+        if (version === 'oas3' ||
+            version === 'async2' ||
+            version === 'async3' ||
+            version === 'openrpc1') {
+            return `#/components/${componentType}/${name}`;
+        }
+        else {
+            return `#/${componentType}/${name}`;
+        }
+    }
+    function isEqualOrEqualRef(node, target, ctx) {
+        if (isRef(node) &&
+            ctx.resolve(node, rootLocation.absolutePointer).location?.absolutePointer ===
+                target.location.absolutePointer) {
+            return true;
+        }
+        return dequal(node, target.node);
+    }
+    function getComponentName(target, componentType, ctx) {
+        const [fileRef, pointer] = [target.location.source.absoluteRef, target.location.pointer];
+        const componentsGroup = components[componentType];
+        let name = '';
+        const refParts = pointer.slice(2).split('/').filter(isTruthy); // slice(2) removes "#/"
+        while (refParts.length > 0) {
+            name = refParts.pop() + (name ? `-${name}` : '');
+            if (!componentsGroup ||
+                !componentsGroup[name] ||
+                isEqualOrEqualRef(componentsGroup[name], target, ctx)) {
+                return name;
+            }
+        }
+        name = refBaseName(fileRef) + (name ? `_${name}` : '');
+        if (!componentsGroup[name] || isEqualOrEqualRef(componentsGroup[name], target, ctx)) {
+            return name;
+        }
+        const prevName = name;
+        let serialId = 2;
+        while (componentsGroup[name] && !isEqualOrEqualRef(componentsGroup[name], target, ctx)) {
+            name = `${prevName}-${serialId}`;
+            serialId++;
+        }
+        if (!componentsGroup[name]) {
+            ctx.report({
+                message: `Two schemas are referenced with the same name but different content. Renamed ${prevName} to ${name}.`,
+                location: ctx.location,
+                forceSeverity: componentRenamingConflicts,
+            });
+        }
+        return name;
+    }
+    return visitor;
+}
+//# sourceMappingURL=bundle-visitor.js.map