@redocly/openapi-core 0.0.0-snapshot.1744188073 → 0.0.0-snapshot.1744801622

package/lib/redocly/registry-api.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegistryApi = void 0;
+const utils_1 = require("../utils");
+const domains_1 = require("./domains");
+const version = require('../../package.json').version;
+class RegistryApi {
+    constructor(accessTokens, region) {
+        this.accessTokens = accessTokens;
+        this.region = region;
+    }
+    get accessToken() {
+        return (0, utils_1.isNotEmptyObject)(this.accessTokens) && this.accessTokens[this.region];
+    }
+    getBaseUrl() {
+        return `https://api.${(0, domains_1.getRedoclyDomain)()}/registry`;
+    }
+    setAccessTokens(accessTokens) {
+        this.accessTokens = accessTokens;
+        return this;
+    }
+    async request(path = '', options = {}) {
+        const currentCommand = typeof process !== 'undefined' ? process.env?.REDOCLY_CLI_COMMAND || '' : '';
+        const redoclyEnv = typeof process !== 'undefined' ? process.env?.REDOCLY_ENVIRONMENT || '' : '';
+        const headers = Object.assign({}, options.headers || {}, {
+            'x-redocly-cli-version': version,
+            'user-agent': `redocly-cli / ${version} ${currentCommand} ${redoclyEnv}`,
+        });
+        if (!headers.hasOwnProperty('authorization')) {
+            throw new Error('Unauthorized');
+        }
+        const requestOptions = {
+            ...options,
+            headers,
+            agent: (0, utils_1.getProxyAgent)(),
+        };
+        const response = await fetch(`${this.getBaseUrl()}${path}`, requestOptions);
+        if (response.status === 401) {
+            throw new Error('Unauthorized');
+        }
+        if (response.status === 404) {
+            const body = await response.json();
+            throw new Error(body.code);
+        }
+        return response;
+    }
+    async authStatus(accessToken, verbose = false) {
+        try {
+            const response = await this.request('', { headers: { authorization: accessToken } });
+            return await response.json();
+        }
+        catch (error) {
+            if (verbose) {
+                console.log(error);
+            }
+            throw error;
+        }
+    }
+    async prepareFileUpload({ organizationId, name, version, filesHash, filename, isUpsert, }) {
+        const response = await this.request(`/${organizationId}/${name}/${version}/prepare-file-upload`, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                authorization: this.accessToken,
+            },
+            body: JSON.stringify({
+                filesHash,
+                filename,
+                isUpsert,
+            }),
+        });
+        if (response.ok) {
+            return response.json();
+        }
+        throw new Error('Could not prepare file upload');
+    }
+    async pushApi({ organizationId, name, version, rootFilePath, filePaths, branch, isUpsert, isPublic, batchId, batchSize, }) {
+        const response = await this.request(`/${organizationId}/${name}/${version}`, {
+            method: 'PUT',
+            headers: {
+                'content-type': 'application/json',
+                authorization: this.accessToken,
+            },
+            body: JSON.stringify({
+                rootFilePath,
+                filePaths,
+                branch,
+                isUpsert,
+                isPublic,
+                batchId,
+                batchSize,
+            }),
+        });
+        if (response.ok) {
+            return;
+        }
+        throw new Error('Could not push api');
+    }
+}
+exports.RegistryApi = RegistryApi;

package/lib/ref-utils.d.ts

@@ -1,5 +1,5 @@
-import type { Source } from './resolve.js';
-import type { OasRef } from './typings/openapi.js';
+import type { Source } from './resolve';
+import type { OasRef } from './typings/openapi';
 export declare function joinPointer(base: string, key: string | number): string;
 export declare function isRef(node: unknown): node is OasRef;
 export declare function isExternalValue(node: unknown): boolean;
@@ -25,4 +25,3 @@ export declare function refBaseName(ref: string): string;
 export declare function isAbsoluteUrl(ref: string): boolean;
 export declare function isMappingRef(mapping: string): boolean;
 export declare function isAnchor(ref: string): boolean;
-//# sourceMappingURL=ref-utils.d.ts.map

package/lib/ref-utils.js

@@ -1,16 +1,31 @@
-import { isPlainObject, isTruthy } from './utils.js';
-export function joinPointer(base, key) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Location = void 0;
+exports.joinPointer = joinPointer;
+exports.isRef = isRef;
+exports.isExternalValue = isExternalValue;
+exports.unescapePointer = unescapePointer;
+exports.escapePointer = escapePointer;
+exports.parseRef = parseRef;
+exports.parsePointer = parsePointer;
+exports.pointerBaseName = pointerBaseName;
+exports.refBaseName = refBaseName;
+exports.isAbsoluteUrl = isAbsoluteUrl;
+exports.isMappingRef = isMappingRef;
+exports.isAnchor = isAnchor;
+const utils_1 = require("./utils");
+function joinPointer(base, key) {
     if (base === '')
         base = '#/';
     return base[base.length - 1] === '/' ? base + key : base + '/' + key;
 }
-export function isRef(node) {
-    return isPlainObject(node) && typeof node.$ref === 'string';
+function isRef(node) {
+    return (0, utils_1.isPlainObject)(node) && typeof node.$ref === 'string';
 }
-export function isExternalValue(node) {
-    return isPlainObject(node) && typeof node.externalValue === 'string';
+function isExternalValue(node) {
+    return (0, utils_1.isPlainObject)(node) && typeof node.externalValue === 'string';
 }
-export class Location {
+class Location {
     constructor(source, pointer) {
         this.source = source;
         this.pointer = pointer;
@@ -25,37 +40,38 @@ export class Location {
         return this.source.absoluteRef + (this.pointer === '#/' ? '' : this.pointer);
     }
 }
-export function unescapePointer(fragment) {
+exports.Location = Location;
+function unescapePointer(fragment) {
     return decodeURIComponent(fragment.replace(/~1/g, '/').replace(/~0/g, '~'));
 }
-export function escapePointer(fragment) {
+function escapePointer(fragment) {
     if (typeof fragment === 'number')
         return fragment;
     return fragment.replace(/~/g, '~0').replace(/\//g, '~1');
 }
-export function parseRef(ref) {
+function parseRef(ref) {
     const [uri, pointer = ''] = ref.split('#/');
     return {
         uri: (uri.endsWith('#') ? uri.slice(0, -1) : uri) || null,
         pointer: parsePointer(pointer),
     };
 }
-export function parsePointer(pointer) {
-    return pointer.split('/').map(unescapePointer).filter(isTruthy);
+function parsePointer(pointer) {
+    return pointer.split('/').map(unescapePointer).filter(utils_1.isTruthy);
 }
-export function pointerBaseName(pointer) {
+function pointerBaseName(pointer) {
     const parts = pointer.split('/');
     return parts[parts.length - 1];
 }
-export function refBaseName(ref) {
+function refBaseName(ref) {
     // eslint-disable-next-line no-useless-escape
     const parts = ref.split(/[\/\\]/); // split by '\' and '/'
     return parts[parts.length - 1].replace(/\.[^.]+$/, ''); // replace extension with empty string
 }
-export function isAbsoluteUrl(ref) {
+function isAbsoluteUrl(ref) {
     return ref.startsWith('http://') || ref.startsWith('https://');
 }
-export function isMappingRef(mapping) {
+function isMappingRef(mapping) {
     // TODO: proper detection of mapping refs
     return (mapping.startsWith('#') ||
         mapping.startsWith('https://') ||
@@ -64,7 +80,6 @@ export function isMappingRef(mapping) {
         mapping.startsWith('../') ||
         mapping.indexOf('/') > -1);
 }
-export function isAnchor(ref) {
+function isAnchor(ref) {
     return /^#[A-Za-z][A-Za-z0-9\-_:.]*$/.test(ref);
 }
-//# sourceMappingURL=ref-utils.js.map

package/lib/resolve.d.ts

@@ -1,6 +1,6 @@
 import type { YAMLNode, LoadOptions } from 'yaml-ast-parser';
-import type { NormalizedNodeType } from './types/index.js';
-import type { ResolveConfig } from './config/types.js';
+import type { NormalizedNodeType } from './types';
+import type { ResolveConfig } from './config/types';
 export type CollectedRefs = Map<string, Document>;
 export declare class Source {
     absoluteRef: string;
@@ -64,4 +64,3 @@ export declare function resolveDocument(opts: {
     externalRefResolver: BaseResolver;
     rootType: NormalizedNodeType;
 }): Promise<ResolvedRefMap>;
-//# sourceMappingURL=resolve.d.ts.map

package/lib/resolve.js

@@ -1,9 +1,15 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { isRef, joinPointer, escapePointer, parseRef, isAbsoluteUrl, isAnchor, isExternalValue, } from './ref-utils.js';
-import { isNamedType, SpecExtension } from './types/index.js';
-import { readFileFromUrl, parseYaml, nextTick } from './utils.js';
-export class Source {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseResolver = exports.YamlParseError = exports.ResolveError = exports.Source = void 0;
+exports.makeRefId = makeRefId;
+exports.makeDocumentFromString = makeDocumentFromString;
+exports.resolveDocument = resolveDocument;
+const fs = require("fs");
+const path = require("path");
+const ref_utils_1 = require("./ref-utils");
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+class Source {
     constructor(absoluteRef, body, mimeType) {
         this.absoluteRef = absoluteRef;
         this.body = body;
@@ -31,7 +37,8 @@ export class Source {
         return this._lines;
     }
 }
-export class ResolveError extends Error {
+exports.Source = Source;
+class ResolveError extends Error {
     constructor(originalError) {
         super(originalError.message);
         this.originalError = originalError;
@@ -39,8 +46,9 @@ export class ResolveError extends Error {
         Object.setPrototypeOf(this, ResolveError.prototype);
     }
 }
+exports.ResolveError = ResolveError;
 const jsYamlErrorLineColRegexp = /\((\d+):(\d+)\)$/;
-export class YamlParseError extends Error {
+class YamlParseError extends Error {
     constructor(originalError, source) {
         super(originalError.message.split('\n')[0]);
         this.originalError = originalError;
@@ -52,22 +60,23 @@ export class YamlParseError extends Error {
         this.col = parseInt(col, 10);
     }
 }
-export function makeRefId(absoluteRef, pointer) {
+exports.YamlParseError = YamlParseError;
+function makeRefId(absoluteRef, pointer) {
     return absoluteRef + '::' + pointer;
 }
-export function makeDocumentFromString(sourceString, absoluteRef) {
+function makeDocumentFromString(sourceString, absoluteRef) {
     const source = new Source(absoluteRef, sourceString);
     try {
         return {
             source,
-            parsed: parseYaml(sourceString, { filename: absoluteRef }),
+            parsed: (0, utils_1.parseYaml)(sourceString, { filename: absoluteRef }),
         };
     }
     catch (e) {
         throw new YamlParseError(e, source);
     }
 }
-export class BaseResolver {
+class BaseResolver {
     constructor(config = { http: { headers: [] } }) {
         this.config = config;
         this.cache = new Map();
@@ -76,18 +85,18 @@ export class BaseResolver {
         return new Set(Array.from(this.cache.keys()));
     }
     resolveExternalRef(base, ref) {
-        if (isAbsoluteUrl(ref)) {
+        if ((0, ref_utils_1.isAbsoluteUrl)(ref)) {
             return ref;
         }
-        if (base && isAbsoluteUrl(base)) {
+        if (base && (0, ref_utils_1.isAbsoluteUrl)(base)) {
             return new URL(ref, base).href;
         }
         return path.resolve(base ? path.dirname(base) : process.cwd(), ref);
     }
     async loadExternalRef(absoluteRef) {
         try {
-            if (isAbsoluteUrl(absoluteRef)) {
-                const { body, mimeType } = await readFileFromUrl(absoluteRef, this.config.http);
+            if ((0, ref_utils_1.isAbsoluteUrl)(absoluteRef)) {
+                const { body, mimeType } = await (0, utils_1.readFileFromUrl)(absoluteRef, this.config.http);
                 return new Source(absoluteRef, body, mimeType);
             }
             else {
@@ -115,7 +124,7 @@ export class BaseResolver {
         try {
             return {
                 source,
-                parsed: parseYaml(source.body, { filename: source.absoluteRef }),
+                parsed: (0, utils_1.parseYaml)(source.body, { filename: source.absoluteRef }),
             };
         }
         catch (e) {
@@ -135,6 +144,7 @@ export class BaseResolver {
         return doc;
     }
 }
+exports.BaseResolver = BaseResolver;
 function pushRef(head, node) {
     return {
         prev: head,
@@ -152,7 +162,7 @@ function hasRef(head, node) {
 }
 const unknownType = { name: 'unknown', properties: {} };
 const resolvableScalarType = { name: 'scalar', properties: {} };
-export async function resolveDocument(opts) {
+async function resolveDocument(opts) {
     const { rootDocument, externalRefResolver, rootType } = opts;
     const resolvedRefMap = new Map();
     const seenNodes = new Set(); // format "${type}::${absoluteRef}${pointer}"
@@ -183,19 +193,19 @@ export async function resolveDocument(opts) {
             if (Array.isArray(node)) {
                 const itemsType = type.items;
                 // we continue resolving unknown types, but stop early on known scalars
-                if (itemsType === undefined && type !== unknownType && type !== SpecExtension) {
+                if (itemsType === undefined && type !== unknownType && type !== types_1.SpecExtension) {
                     return;
                 }
                 const isTypeAFunction = typeof itemsType === 'function';
                 for (let i = 0; i < node.length; i++) {
                     const itemType = isTypeAFunction
-                        ? itemsType(node[i], joinPointer(nodeAbsoluteRef, i))
+                        ? itemsType(node[i], (0, ref_utils_1.joinPointer)(nodeAbsoluteRef, i))
                         : itemsType;
                     // we continue resolving unknown types, but stop early on known scalars
-                    if (itemType === undefined && type !== unknownType && type !== SpecExtension) {
+                    if (itemType === undefined && type !== unknownType && type !== types_1.SpecExtension) {
                         continue;
                     }
-                    walk(node[i], isNamedType(itemType) ? itemType : unknownType, joinPointer(nodeAbsoluteRef, i));
+                    walk(node[i], (0, types_1.isNamedType)(itemType) ? itemType : unknownType, (0, ref_utils_1.joinPointer)(nodeAbsoluteRef, i));
                 }
                 return;
             }
@@ -211,21 +221,21 @@ export async function resolveDocument(opts) {
                 if (type.extensionsPrefix &&
                     propName.startsWith(type.extensionsPrefix) &&
                     propType === unknownType) {
-                    propType = SpecExtension;
+                    propType = types_1.SpecExtension;
                 }
-                if (!isNamedType(propType) && propType?.directResolveAs) {
+                if (!(0, types_1.isNamedType)(propType) && propType?.directResolveAs) {
                     propType = propType.directResolveAs;
                     propValue = { $ref: propValue };
                 }
                 if (propType && propType.name === undefined && propType.resolvable !== false) {
                     propType = resolvableScalarType;
                 }
-                if (!isNamedType(propType) || typeof propValue !== 'object') {
+                if (!(0, types_1.isNamedType)(propType) || typeof propValue !== 'object') {
                     continue;
                 }
-                walk(propValue, propType, joinPointer(nodeAbsoluteRef, escapePointer(propName)));
+                walk(propValue, propType, (0, ref_utils_1.joinPointer)(nodeAbsoluteRef, (0, ref_utils_1.escapePointer)(propName)));
             }
-            if (isRef(node)) {
+            if ((0, ref_utils_1.isRef)(node)) {
                 const promise = followRef(rootNodeDocument, node, {
                     prev: null,
                     node,
@@ -237,7 +247,7 @@ export async function resolveDocument(opts) {
                 resolvePromises.push(promise);
             }
             // handle example.externalValue as reference
-            if (isExternalValue(node)) {
+            if ((0, ref_utils_1.isExternalValue)(node)) {
                 const promise = followRef(rootNodeDocument, { $ref: node.externalValue }, {
                     prev: null,
                     node,
@@ -253,9 +263,9 @@ export async function resolveDocument(opts) {
             if (hasRef(refStack.prev, ref)) {
                 throw new Error('Self-referencing circular pointer');
             }
-            if (isAnchor(ref.$ref)) {
+            if ((0, ref_utils_1.isAnchor)(ref.$ref)) {
                 // Wait for all anchors in the document to be collected firstly.
-                await nextTick();
+                await (0, utils_1.nextTick)();
                 const resolvedRef = {
                     resolved: true,
                     isRemote: false,
@@ -267,7 +277,7 @@ export async function resolveDocument(opts) {
                 resolvedRefMap.set(refId, resolvedRef);
                 return resolvedRef;
             }
-            const { uri, pointer } = parseRef(ref.$ref);
+            const { uri, pointer } = (0, ref_utils_1.parseRef)(ref.$ref);
             const isRemote = uri !== null;
             let targetDoc;
             try {
@@ -302,9 +312,9 @@ export async function resolveDocument(opts) {
                 }
                 else if (target[segment] !== undefined) {
                     target = target[segment];
-                    resolvedRef.nodePointer = joinPointer(resolvedRef.nodePointer, escapePointer(segment));
+                    resolvedRef.nodePointer = (0, ref_utils_1.joinPointer)(resolvedRef.nodePointer, (0, ref_utils_1.escapePointer)(segment));
                 }
-                else if (isRef(target)) {
+                else if ((0, ref_utils_1.isRef)(target)) {
                     resolvedRef = await followRef(targetDoc, target, pushRef(refStack, target));
                     targetDoc = resolvedRef.document || targetDoc;
                     if (typeof resolvedRef.node !== 'object') {
@@ -312,7 +322,7 @@ export async function resolveDocument(opts) {
                         break;
                     }
                     target = resolvedRef.node[segment];
-                    resolvedRef.nodePointer = joinPointer(resolvedRef.nodePointer, escapePointer(segment));
+                    resolvedRef.nodePointer = (0, ref_utils_1.joinPointer)(resolvedRef.nodePointer, (0, ref_utils_1.escapePointer)(segment));
                 }
                 else {
                     target = undefined;
@@ -322,7 +332,7 @@ export async function resolveDocument(opts) {
             resolvedRef.node = target;
             resolvedRef.document = targetDoc;
             const refId = makeRefId(document.source.absoluteRef, ref.$ref);
-            if (resolvedRef.document && isRef(target)) {
+            if (resolvedRef.document && (0, ref_utils_1.isRef)(target)) {
                 resolvedRef = await followRef(resolvedRef.document, target, pushRef(refStack, target));
             }
             resolvedRefMap.set(refId, resolvedRef);
@@ -330,4 +340,3 @@ export async function resolveDocument(opts) {
         }
     }
 }
-//# sourceMappingURL=resolve.js.map

package/lib/rules/ajv.d.ts

@@ -1,6 +1,6 @@
-import type { Location } from '../ref-utils.js';
-import type { ErrorObject } from '@redocly/ajv/dist/2020.js';
-import type { ResolveFn } from '../walk.js';
+import type { Location } from '../ref-utils';
+import type { ErrorObject } from '@redocly/ajv/dist/2020';
+import type { ResolveFn } from '../walk';
 export declare function releaseAjvInstance(): void;
 export declare function validateJsonSchema(data: any, schema: any, schemaLoc: Location, instancePath: string, resolve: ResolveFn, allowAdditionalProperties: boolean): {
     valid: boolean;
@@ -8,4 +8,3 @@ export declare function validateJsonSchema(data: any, schema: any, schemaLoc: Lo
         suggest?: string[];
     })[];
 };
-//# sourceMappingURL=ajv.d.ts.map

package/lib/rules/ajv.js

@@ -1,12 +1,16 @@
-import Ajv from '@redocly/ajv/dist/2020.js';
-import { escapePointer } from '../ref-utils.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.releaseAjvInstance = releaseAjvInstance;
+exports.validateJsonSchema = validateJsonSchema;
+const _2020_1 = require("@redocly/ajv/dist/2020");
+const ref_utils_1 = require("../ref-utils");
 let ajvInstance = null;
-export function releaseAjvInstance() {
+function releaseAjvInstance() {
     ajvInstance = null;
 }
 function getAjv(resolve, allowAdditionalProperties) {
     if (!ajvInstance) {
-        ajvInstance = new Ajv({
+        ajvInstance = new _2020_1.default({
             schemaId: '$id',
             meta: true,
             allErrors: true,
@@ -35,7 +39,7 @@ function getAjvValidator(schema, loc, resolve, allowAdditionalProperties) {
     }
     return ajv.getSchema(loc.absolutePointer);
 }
-export function validateJsonSchema(data, schema, schemaLoc, instancePath, resolve, allowAdditionalProperties) {
+function validateJsonSchema(data, schema, schemaLoc, instancePath, resolve, allowAdditionalProperties) {
     const validate = getAjvValidator(schema, schemaLoc, resolve, allowAdditionalProperties);
     if (!validate)
         return { valid: true, errors: [] }; // unresolved refs are reported
@@ -67,7 +71,7 @@ export function validateJsonSchema(data, schema, schemaLoc, instancePath, resolv
         if (error.keyword === 'additionalProperties' || error.keyword === 'unevaluatedProperties') {
             const property = error.params.additionalProperty || error.params.unevaluatedProperty;
             message = `${message} \`${property}\``;
-            error.instancePath += '/' + escapePointer(property);
+            error.instancePath += '/' + (0, ref_utils_1.escapePointer)(property);
         }
         return {
             ...error,
@@ -76,4 +80,3 @@ export function validateJsonSchema(data, schema, schemaLoc, instancePath, resolv
         };
     }
 }
-//# sourceMappingURL=ajv.js.map

package/lib/rules/arazzo/criteria-unique.d.ts

@@ -1,3 +1,2 @@
-import type { Arazzo1Rule } from '../../visitors.js';
+import type { Arazzo1Rule } from '../../visitors';
 export declare const CriteriaUnique: Arazzo1Rule;
-//# sourceMappingURL=criteria-unique.d.ts.map

package/lib/rules/arazzo/criteria-unique.js

@@ -1,4 +1,7 @@
-export const CriteriaUnique = () => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CriteriaUnique = void 0;
+const CriteriaUnique = () => {
     return {
         FailureActionObject: {
             enter(action, { report, location }) {
@@ -65,4 +68,4 @@ export const CriteriaUnique = () => {
         },
     };
 };
-//# sourceMappingURL=criteria-unique.js.map
+exports.CriteriaUnique = CriteriaUnique;

package/lib/rules/arazzo/index.d.ts

@@ -1,4 +1,3 @@
-import type { Arazzo1RuleSet } from '../../oas-types.js';
+import type { Arazzo1RuleSet } from '../../oas-types';
 export declare const rules: Arazzo1RuleSet<'built-in'>;
 export declare const preprocessors: {};
-//# sourceMappingURL=index.d.ts.map

package/lib/rules/arazzo/index.js

@@ -1,34 +1,36 @@
-import { Struct } from '../common/struct.js';
-import { Assertions } from '../common/assertions/index.js';
-import { SourceDescriptionType } from '../arazzo/sourceDescription-type.js';
-import { SourceDescriptionsNotEmpty } from './sourceDescriptions-not-empty.js';
-import { RespectSupportedVersions } from '../respect/respect-supported-versions.js';
-import { WorkflowIdUnique } from './workflowId-unique.js';
-import { StepIdUnique } from './stepId-unique.js';
-import { SourceDescriptionsNameUnique } from './sourceDescriptions-name-unique.js';
-import { WorkflowDependsOn } from './workflow-dependsOn.js';
-import { ParametersUnique } from './parameters-unique.js';
-import { StepOnSuccessUnique } from './step-onSuccess-unique.js';
-import { StepOnFailureUnique } from './step-onFailure-unique.js';
-import { RequestBodyReplacementsUnique } from './requestBody-replacements-unique.js';
-import { NoCriteriaXpath } from '../respect/no-criteria-xpath.js';
-import { CriteriaUnique } from './criteria-unique.js';
-export const rules = {
-    struct: Struct,
-    assertions: Assertions,
-    'sourceDescription-type': SourceDescriptionType,
-    'respect-supported-versions': RespectSupportedVersions,
-    'workflowId-unique': WorkflowIdUnique,
-    'stepId-unique': StepIdUnique,
-    'sourceDescription-name-unique': SourceDescriptionsNameUnique,
-    'sourceDescriptions-not-empty': SourceDescriptionsNotEmpty,
-    'workflow-dependsOn': WorkflowDependsOn,
-    'parameters-unique': ParametersUnique,
-    'step-onSuccess-unique': StepOnSuccessUnique,
-    'step-onFailure-unique': StepOnFailureUnique,
-    'requestBody-replacements-unique': RequestBodyReplacementsUnique,
-    'no-criteria-xpath': NoCriteriaXpath,
-    'criteria-unique': CriteriaUnique,
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preprocessors = exports.rules = void 0;
+const struct_1 = require("../common/struct");
+const assertions_1 = require("../common/assertions");
+const sourceDescription_type_1 = require("../arazzo/sourceDescription-type");
+const sourceDescriptions_not_empty_1 = require("./sourceDescriptions-not-empty");
+const respect_supported_versions_1 = require("../respect/respect-supported-versions");
+const workflowId_unique_1 = require("./workflowId-unique");
+const stepId_unique_1 = require("./stepId-unique");
+const sourceDescriptions_name_unique_1 = require("./sourceDescriptions-name-unique");
+const workflow_dependsOn_1 = require("./workflow-dependsOn");
+const parameters_unique_1 = require("./parameters-unique");
+const step_onSuccess_unique_1 = require("./step-onSuccess-unique");
+const step_onFailure_unique_1 = require("./step-onFailure-unique");
+const requestBody_replacements_unique_1 = require("./requestBody-replacements-unique");
+const no_criteria_xpath_1 = require("../respect/no-criteria-xpath");
+const criteria_unique_1 = require("./criteria-unique");
+exports.rules = {
+    struct: struct_1.Struct,
+    assertions: assertions_1.Assertions,
+    'sourceDescription-type': sourceDescription_type_1.SourceDescriptionType,
+    'respect-supported-versions': respect_supported_versions_1.RespectSupportedVersions,
+    'workflowId-unique': workflowId_unique_1.WorkflowIdUnique,
+    'stepId-unique': stepId_unique_1.StepIdUnique,
+    'sourceDescription-name-unique': sourceDescriptions_name_unique_1.SourceDescriptionsNameUnique,
+    'sourceDescriptions-not-empty': sourceDescriptions_not_empty_1.SourceDescriptionsNotEmpty,
+    'workflow-dependsOn': workflow_dependsOn_1.WorkflowDependsOn,
+    'parameters-unique': parameters_unique_1.ParametersUnique,
+    'step-onSuccess-unique': step_onSuccess_unique_1.StepOnSuccessUnique,
+    'step-onFailure-unique': step_onFailure_unique_1.StepOnFailureUnique,
+    'requestBody-replacements-unique': requestBody_replacements_unique_1.RequestBodyReplacementsUnique,
+    'no-criteria-xpath': no_criteria_xpath_1.NoCriteriaXpath,
+    'criteria-unique': criteria_unique_1.CriteriaUnique,
 };
-export const preprocessors = {};
-//# sourceMappingURL=index.js.map
+exports.preprocessors = {};

package/lib/rules/arazzo/parameters-unique.d.ts

@@ -1,3 +1,2 @@
-import type { Arazzo1Rule } from '../../visitors.js';
+import type { Arazzo1Rule } from '../../visitors';
 export declare const ParametersUnique: Arazzo1Rule;
-//# sourceMappingURL=parameters-unique.d.ts.map

package/lib/rules/arazzo/parameters-unique.js

@@ -1,4 +1,7 @@
-export const ParametersUnique = () => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParametersUnique = void 0;
+const ParametersUnique = () => {
     return {
         Parameters: {
             enter(parameters, { report, location }) {
@@ -26,4 +29,4 @@ export const ParametersUnique = () => {
         },
     };
 };
-//# sourceMappingURL=parameters-unique.js.map
+exports.ParametersUnique = ParametersUnique;

package/lib/rules/arazzo/requestBody-replacements-unique.d.ts

@@ -1,3 +1,2 @@
-import type { Arazzo1Rule } from '../../visitors.js';
+import type { Arazzo1Rule } from '../../visitors';
 export declare const RequestBodyReplacementsUnique: Arazzo1Rule;
-//# sourceMappingURL=requestBody-replacements-unique.d.ts.map