@redocly/openapi-core 1.21.1 → 1.22.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @redocly/openapi-core
 
+## 1.22.0
+
+### Minor Changes
+
+- Updated the Arazzo validation types for workflows input, parameter objects, and criteria to match the specification.
+- Added Arazzo rulesets so that users can customize their linting rules for this format.
+
+### Patch Changes
+
+- Updated @redocly/config to v0.10.1.
+
 ## 1.21.1
 
 ### Patch Changes

package/lib/config/all.js

@@ -126,6 +126,19 @@ const all = {
         'channels-kebab-case': 'error',
         'no-channel-trailing-slash': 'error',
     },
-    arazzoRules: { spec: 'error', 'parameters-no-body-inside-in': 'off' },
+    arazzoRules: {
+        spec: 'error',
+        'parameters-not-in-body': 'error',
+        'sourceDescription-type': 'error',
+        'version-enum': 'error',
+        'workflowId-unique': 'error',
+        'stepId-unique': 'error',
+        'sourceDescription-name-unique': 'error',
+        'workflow-dependsOn': 'error',
+        'parameters-unique': 'error',
+        'step-onSuccess-unique': 'error',
+        'step-onFailure-unique': 'error',
+        'requestBody-replacements-unique': 'error',
+    },
 };
 exports.default = all;

package/lib/config/minimal.js

@@ -110,7 +110,17 @@ const minimal = {
     },
     arazzoRules: {
         spec: 'error',
-        'parameters-no-body-inside-in': 'off',
+        'parameters-not-in-body': 'off',
+        'sourceDescription-type': 'off',
+        'version-enum': 'warn',
+        'workflowId-unique': 'error',
+        'stepId-unique': 'error',
+        'sourceDescription-name-unique': 'off',
+        'workflow-dependsOn': 'off',
+        'parameters-unique': 'off',
+        'step-onSuccess-unique': 'off',
+        'step-onFailure-unique': 'off',
+        'requestBody-replacements-unique': 'off',
     },
 };
 exports.default = minimal;

package/lib/config/recommended-strict.js

@@ -110,7 +110,17 @@ const recommendedStrict = {
     },
     arazzoRules: {
         spec: 'error',
-        'parameters-no-body-inside-in': 'off',
+        'parameters-not-in-body': 'error',
+        'sourceDescription-type': 'error',
+        'version-enum': 'error',
+        'workflowId-unique': 'error',
+        'stepId-unique': 'error',
+        'sourceDescription-name-unique': 'error',
+        'workflow-dependsOn': 'error',
+        'parameters-unique': 'error',
+        'step-onSuccess-unique': 'error',
+        'step-onFailure-unique': 'error',
+        'requestBody-replacements-unique': 'error',
     },
 };
 exports.default = recommendedStrict;

package/lib/config/recommended.js

@@ -110,7 +110,17 @@ const recommended = {
     },
     arazzoRules: {
         spec: 'error',
-        'parameters-no-body-inside-in': 'off',
+        'parameters-not-in-body': 'warn',
+        'sourceDescription-type': 'error',
+        'version-enum': 'warn',
+        'workflowId-unique': 'error',
+        'stepId-unique': 'error',
+        'sourceDescription-name-unique': 'error',
+        'workflow-dependsOn': 'error',
+        'parameters-unique': 'error',
+        'step-onSuccess-unique': 'warn',
+        'step-onFailure-unique': 'warn',
+        'requestBody-replacements-unique': 'warn',
     },
 };
 exports.default = recommended;

package/lib/oas-types.js

@@ -11,6 +11,7 @@ const asyncapi2_1 = require("./types/asyncapi2");
 const asyncapi3_1 = require("./types/asyncapi3");
 const arazzo_1 = require("./types/arazzo");
 const utils_1 = require("./utils");
+const arazzo_2 = require("./typings/arazzo");
 var SpecVersion;
 (function (SpecVersion) {
     SpecVersion["OAS2"] = "oas2";
@@ -64,7 +65,7 @@ function detectSpec(root) {
     if (root.asyncapi) {
         throw new Error(`Unsupported AsyncAPI version: ${root.asyncapi}`);
     }
-    if (typeof root.arazzo === 'string' && root.arazzo.startsWith('1.')) {
+    if (typeof root.arazzo === 'string' && arazzo_2.VERSION_PATTERN.test(root.arazzo)) {
         return SpecVersion.Arazzo;
     }
     throw new Error(`Unsupported specification`);

package/lib/rules/arazzo/index.js

@@ -3,10 +3,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.preprocessors = exports.rules = void 0;
 const spec_1 = require("../common/spec");
 const assertions_1 = require("../common/assertions");
-const parameters_no_body_inside_in_1 = require("../spot/parameters-no-body-inside-in");
+const parameters_not_in_body_1 = require("../spot/parameters-not-in-body");
+const source_description_type_1 = require("../arazzo/source-description-type");
+const version_enum_1 = require("../spot/version-enum");
+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");
 exports.rules = {
     spec: spec_1.Spec,
     assertions: assertions_1.Assertions,
-    'parameters-no-body-inside-in': parameters_no_body_inside_in_1.ParametersNoBodyInsideIn,
+    'parameters-not-in-body': parameters_not_in_body_1.ParametersNotInBody,
+    'sourceDescription-type': source_description_type_1.SourceDescriptionType,
+    'version-enum': version_enum_1.VersionEnum,
+    'workflowId-unique': workflowId_unique_1.WorkflowIdUnique,
+    'stepId-unique': stepId_unique_1.StepIdUnique,
+    'sourceDescription-name-unique': sourceDescriptions_name_unique_1.SourceDescriptionsNameUnique,
+    '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,
 };
 exports.preprocessors = {};

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

@@ -0,0 +1,2 @@
+import type { ArazzoRule } from '../../visitors';
+export declare const ParametersUnique: ArazzoRule;

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParametersUnique = void 0;
+const ParametersUnique = () => {
+    return {
+        Parameters: {
+            enter(parameters, { report, location }) {
+                if (!parameters)
+                    return;
+                const seenParameters = new Set();
+                for (const parameter of parameters) {
+                    if (seenParameters.has(parameter?.name)) {
+                        report({
+                            message: 'The parameter `name` must be unique amongst listed parameters.',
+                            location: location.child([parameters.indexOf(parameter)]),
+                        });
+                    }
+                    if (seenParameters.has(parameter?.reference)) {
+                        report({
+                            message: 'The parameter `reference` must be unique amongst listed parameters.',
+                            location: location.child([parameters.indexOf(parameter)]),
+                        });
+                    }
+                    parameter?.name
+                        ? seenParameters.add(parameter.name)
+                        : seenParameters.add(parameter.reference);
+                }
+            },
+        },
+    };
+};
+exports.ParametersUnique = ParametersUnique;

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

@@ -0,0 +1,2 @@
+import type { ArazzoRule } from '../../visitors';
+export declare const RequestBodyReplacementsUnique: ArazzoRule;

package/lib/rules/arazzo/requestBody-replacements-unique.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestBodyReplacementsUnique = void 0;
+const RequestBodyReplacementsUnique = () => {
+    const seenReplacements = new Set();
+    return {
+        RequestBody: {
+            enter(requestBody, { report, location }) {
+                if (!requestBody.replacements)
+                    return;
+                for (const replacement of requestBody.replacements) {
+                    if (seenReplacements.has(replacement.target)) {
+                        report({
+                            message: 'Every `replacement` in `requestBody` must be unique.',
+                            location: location.child([
+                                'replacements',
+                                requestBody.replacements.indexOf(replacement),
+                                `target`,
+                            ]),
+                        });
+                    }
+                    seenReplacements.add(replacement.target);
+                }
+            },
+        },
+    };
+};
+exports.RequestBodyReplacementsUnique = RequestBodyReplacementsUnique;

package/lib/rules/arazzo/source-description-type.d.ts

@@ -0,0 +1,2 @@
+import type { ArazzoRule } from '../../visitors';
+export declare const SourceDescriptionType: ArazzoRule;

package/lib/rules/arazzo/source-description-type.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceDescriptionType = void 0;
+const SourceDescriptionType = () => {
+    return {
+        SourceDescriptions: {
+            enter(SourceDescriptions, { report, location }) {
+                for (const sourceDescription of SourceDescriptions) {
+                    if (!['openapi', 'arazzo'].includes(sourceDescription?.type)) {
+                        report({
+                            message: 'The `type` property of the `sourceDescription` object must be either `openapi` or `arazzo`.',
+                            location: location.child([SourceDescriptions.indexOf(sourceDescription)]),
+                        });
+                    }
+                }
+            },
+        },
+    };
+};
+exports.SourceDescriptionType = SourceDescriptionType;

package/lib/rules/arazzo/sourceDescriptions-name-unique.d.ts

@@ -0,0 +1,2 @@
+import type { ArazzoRule } from '../../visitors';
+export declare const SourceDescriptionsNameUnique: ArazzoRule;

package/lib/rules/arazzo/sourceDescriptions-name-unique.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceDescriptionsNameUnique = void 0;
+const SourceDescriptionsNameUnique = () => {
+    const seenSourceDescriptions = new Set();
+    return {
+        SourceDescriptions: {
+            enter(sourceDescriptions, { report, location }) {
+                if (!sourceDescriptions.length)
+                    return;
+                for (const sourceDescription of sourceDescriptions) {
+                    if (seenSourceDescriptions.has(sourceDescription.name)) {
+                        report({
+                            message: 'The `name` must be unique amongst all SourceDescriptions.',
+                            location: location.child([sourceDescriptions.indexOf(sourceDescription)]),
+                        });
+                    }
+                    seenSourceDescriptions.add(sourceDescription.name);
+                }
+            },
+        },
+    };
+};
+exports.SourceDescriptionsNameUnique = SourceDescriptionsNameUnique;

package/lib/rules/arazzo/step-onFailure-unique.d.ts

@@ -0,0 +1,2 @@
+import type { ArazzoRule } from '../../visitors';
+export declare const StepOnFailureUnique: ArazzoRule;

package/lib/rules/arazzo/step-onFailure-unique.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StepOnFailureUnique = void 0;
+const StepOnFailureUnique = () => {
+    return {
+        OnFailureActionList: {
+            enter(onFailureActionList, { report, location }) {
+                if (!onFailureActionList)
+                    return;
+                const seenFailureActions = new Set();
+                for (const onFailureAction of onFailureActionList) {
+                    if (seenFailureActions.has(onFailureAction?.name)) {
+                        report({
+                            message: 'The action `name` must be unique amongst listed `onFailure` actions.',
+                            location: location.child([onFailureActionList.indexOf(onFailureAction)]),
+                        });
+                    }
+                    if (seenFailureActions.has(onFailureAction?.reference)) {
+                        report({
+                            message: 'The action `reference` must be unique amongst listed `onFailure` actions.',
+                            location: location.child([onFailureActionList.indexOf(onFailureAction)]),
+                        });
+                    }
+                    onFailureAction?.name
+                        ? seenFailureActions.add(onFailureAction.name)
+                        : seenFailureActions.add(onFailureAction.reference);
+                }
+            },
+        },
+    };
+};
+exports.StepOnFailureUnique = StepOnFailureUnique;

package/lib/rules/arazzo/step-onSuccess-unique.d.ts

@@ -0,0 +1,2 @@
+import type { ArazzoRule } from '../../visitors';
+export declare const StepOnSuccessUnique: ArazzoRule;

package/lib/rules/arazzo/step-onSuccess-unique.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StepOnSuccessUnique = void 0;
+const StepOnSuccessUnique = () => {
+    return {
+        OnSuccessActionList: {
+            enter(onSuccessActionList, { report, location }) {
+                if (!onSuccessActionList)
+                    return;
+                const seenSuccessActions = new Set();
+                for (const onSuccessAction of onSuccessActionList) {
+                    if (seenSuccessActions.has(onSuccessAction?.name)) {
+                        report({
+                            message: 'The action `name` must be unique amongst listed `onSuccess` actions.',
+                            location: location.child([onSuccessActionList.indexOf(onSuccessAction)]),
+                        });
+                    }
+                    if (seenSuccessActions.has(onSuccessAction?.reference)) {
+                        report({
+                            message: 'The action `reference` must be unique amongst listed `onSuccess` actions.',
+                            location: location.child([onSuccessActionList.indexOf(onSuccessAction)]),
+                        });
+                    }
+                    onSuccessAction?.name
+                        ? seenSuccessActions.add(onSuccessAction.name)
+                        : seenSuccessActions.add(onSuccessAction.reference);
+                }
+            },
+        },
+    };
+};
+exports.StepOnSuccessUnique = StepOnSuccessUnique;

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

@@ -0,0 +1,2 @@
+import type { ArazzoRule } from '../../visitors';
+export declare const StepIdUnique: ArazzoRule;

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StepIdUnique = void 0;
+const StepIdUnique = () => {
+    return {
+        Workflow: {
+            enter(workflow, { report, location }) {
+                if (!workflow.steps)
+                    return;
+                const seenSteps = new Set();
+                for (const step of workflow.steps) {
+                    if (!step.stepId)
+                        return;
+                    if (seenSteps.has(step.stepId)) {
+                        report({
+                            message: 'The `stepId` must be unique amongst all steps described in the workflow.',
+                            location: location.child(['steps', workflow.steps.indexOf(step)]),
+                        });
+                    }
+                    seenSteps.add(step.stepId);
+                }
+            },
+        },
+    };
+};
+exports.StepIdUnique = StepIdUnique;

package/lib/rules/arazzo/workflow-dependsOn.d.ts

@@ -0,0 +1,2 @@
+import type { ArazzoRule } from '../../visitors';
+export declare const WorkflowDependsOn: ArazzoRule;

package/lib/rules/arazzo/workflow-dependsOn.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowDependsOn = void 0;
+const WorkflowDependsOn = () => {
+    const seenWorkflow = new Set();
+    const existingSourceDescriptions = new Set();
+    const existingWorkflowIds = new Set();
+    return {
+        SourceDescriptions: {
+            enter(sourceDescriptions) {
+                for (const sourceDescription of sourceDescriptions) {
+                    existingSourceDescriptions.add(sourceDescription.name);
+                }
+            },
+        },
+        Workflows: {
+            enter(workflows) {
+                for (const workflow of workflows) {
+                    existingWorkflowIds.add(workflow.workflowId);
+                }
+            },
+        },
+        Workflow: {
+            leave(workflow, { report, location }) {
+                if (!workflow.dependsOn)
+                    return;
+                for (const item of workflow.dependsOn) {
+                    // Possible dependsOn workflow pattern: $sourceDescriptions.<name>.<workflowId>
+                    if (item.startsWith('$sourceDescriptions.')) {
+                        const sourceDescriptionName = item.split('.')[1];
+                        if (!existingSourceDescriptions.has(sourceDescriptionName)) {
+                            report({
+                                message: `SourceDescription ${sourceDescriptionName} must be defined in sourceDescriptions.`,
+                                location: location.child([`dependsOn`, workflow.dependsOn.indexOf(item)]),
+                            });
+                        }
+                    }
+                    if (!item.startsWith('$sourceDescriptions') && !existingWorkflowIds.has(item)) {
+                        report({
+                            message: `Workflow ${item} must be defined in workflows.`,
+                            location: location.child([`dependsOn`, workflow.dependsOn.indexOf(item)]),
+                        });
+                    }
+                    if (seenWorkflow.has(item)) {
+                        report({
+                            message: 'Every workflow in dependsOn must be unique.',
+                            location: location.child([`dependsOn`]),
+                        });
+                    }
+                    seenWorkflow.add(item);
+                }
+            },
+        },
+    };
+};
+exports.WorkflowDependsOn = WorkflowDependsOn;

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

@@ -0,0 +1,2 @@
+import type { ArazzoRule } from '../../visitors';
+export declare const WorkflowIdUnique: ArazzoRule;

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowIdUnique = void 0;
+const WorkflowIdUnique = () => {
+    const seenWorkflow = new Set();
+    return {
+        Workflow: {
+            enter(workflow, { report, location }) {
+                if (!workflow.workflowId)
+                    return;
+                if (seenWorkflow.has(workflow.workflowId)) {
+                    report({
+                        message: 'Every workflow must have a unique `workflowId`.',
+                        location: location.child([workflow.workflowId]),
+                    });
+                }
+                seenWorkflow.add(workflow.workflowId);
+            },
+        },
+    };
+};
+exports.WorkflowIdUnique = WorkflowIdUnique;

package/lib/rules/spot/parameters-not-in-body.d.ts

@@ -0,0 +1,2 @@
+import type { ArazzoRule } from '../../visitors';
+export declare const ParametersNotInBody: ArazzoRule;

package/lib/rules/spot/{parameters-no-body-inside-in.js → parameters-not-in-body.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ParametersNoBodyInsideIn = void 0;
-const ParametersNoBodyInsideIn = () => {
+exports.ParametersNotInBody = void 0;
+const ParametersNotInBody = () => {
     return {
         Parameter: {
             enter(parameter, { report, location }) {
@@ -15,4 +15,4 @@ const ParametersNoBodyInsideIn = () => {
         },
     };
 };
-exports.ParametersNoBodyInsideIn = ParametersNoBodyInsideIn;
+exports.ParametersNotInBody = ParametersNotInBody;

package/lib/rules/spot/version-enum.d.ts

@@ -0,0 +1,2 @@
+import type { ArazzoRule } from '../../visitors';
+export declare const VersionEnum: ArazzoRule;

package/lib/rules/spot/version-enum.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersionEnum = void 0;
+const arazzo_1 = require("../../typings/arazzo");
+const utils_1 = require("../../utils");
+const VersionEnum = () => {
+    const supportedVersions = arazzo_1.ARAZZO_VERSIONS_SUPPORTED_BY_SPOT.join(', ');
+    return {
+        Root: {
+            enter(root, { report, location }) {
+                if (!arazzo_1.ARAZZO_VERSIONS_SUPPORTED_BY_SPOT.includes(root.arazzo)) {
+                    report({
+                        message: `Only ${supportedVersions} Arazzo ${(0, utils_1.pluralize)('version is', arazzo_1.ARAZZO_VERSIONS_SUPPORTED_BY_SPOT.length)} supported by Spot.`,
+                        location: location.child('arazzo'),
+                    });
+                }
+            },
+        },
+    };
+};
+exports.VersionEnum = VersionEnum;

package/lib/types/arazzo.js

@@ -6,7 +6,7 @@ const oas3_1_1 = require("./oas3_1");
 const oas3_1 = require("./oas3");
 const Root = {
     properties: {
-        arazzo: { type: 'string', enum: ['1.0.0'] },
+        arazzo: { type: 'string' },
         info: 'Info',
         sourceDescriptions: 'SourceDescriptions',
         'x-parameters': 'Parameters',
@@ -93,9 +93,7 @@ const ArazzoSourceDescription = {
 const ReusableObject = {
     properties: {
         reference: { type: 'string' },
-        value: {
-            type: 'string',
-        },
+        value: {}, // any
     },
     required: ['reference'],
     extensionsPrefix: 'x-',
@@ -112,11 +110,11 @@ const Parameter = {
 const Parameters = {
     properties: {},
     items: (value) => {
-        if (value?.in) {
-            return 'Parameter';
+        if (value?.reference) {
+            return 'ReusableObject';
         }
         else {
-            return 'ReusableObject';
+            return 'Parameter';
         }
     },
 };
@@ -127,7 +125,7 @@ const Workflow = {
         description: { type: 'string' },
         parameters: 'Parameters',
         dependsOn: { type: 'array', items: { type: 'string' } },
-        inputs: 'NamedInputs',
+        inputs: 'Schema',
         outputs: 'Outputs',
         steps: 'Steps',
         successActions: 'OnSuccessActionList',
@@ -242,7 +240,7 @@ const SuccessActionObject = {
         type: { type: 'string', enum: ['goto', 'end'] },
         stepId: { type: 'string' },
         workflowId: { type: 'string' },
-        criteria: 'CriterionObject',
+        criteria: (0, _1.listOf)('CriterionObject'),
     },
     required: ['type', 'name'],
 };
@@ -265,7 +263,7 @@ const FailureActionObject = {
         stepId: { type: 'string' },
         retryAfter: { type: 'number' },
         retryLimit: { type: 'number' },
-        criteria: 'CriterionObject',
+        criteria: (0, _1.listOf)('CriterionObject'),
     },
     required: ['type', 'name'],
 };

package/lib/types/redocly-yaml.d.ts

@@ -11,7 +11,7 @@ declare const builtInAsync2Rules: readonly ["spec", "info-contact", "info-licens
 declare const builtInAsync3Rules: readonly ["spec", "info-contact", "info-license-strict", "operation-operationId", "tag-description", "tags-alphabetical", "channels-kebab-case", "no-channel-trailing-slash"];
 export type BuiltInAsync2RuleId = typeof builtInAsync2Rules[number];
 export type BuiltInAsync3RuleId = typeof builtInAsync3Rules[number];
-declare const builtInArazzoRules: readonly ["spec", "parameters-no-body-inside-in"];
+declare const builtInArazzoRules: readonly ["spec", "parameters-not-in-body", "sourceDescription-type", "version-enum", "workflowId-unique", "stepId-unique", "sourceDescription-name-unique", "workflow-dependsOn", "parameters-unique", "step-onSuccess-unique", "step-onFailure-unique", "requestBody-replacements-unique"];
 export type BuiltInArazzoRuleId = typeof builtInArazzoRules[number];
 declare const oas2NodeTypesList: readonly ["Root", "Tag", "TagList", "ExternalDocs", "SecurityRequirement", "SecurityRequirementList", "Info", "Contact", "License", "Paths", "PathItem", "Parameter", "ParameterList", "ParameterItems", "Operation", "Example", "ExamplesMap", "Examples", "Header", "Responses", "Response", "Schema", "Xml", "SchemaProperties", "NamedSchemas", "NamedResponses", "NamedParameters", "NamedSecuritySchemes", "SecurityScheme", "TagGroup", "TagGroups", "EnumDescriptions", "Logo", "XCodeSample", "XCodeSampleList", "XServer", "XServerList"];
 export type Oas2NodeType = typeof oas2NodeTypesList[number];

package/lib/types/redocly-yaml.js

@@ -93,7 +93,20 @@ const builtInAsync3Rules = [
     'channels-kebab-case',
     'no-channel-trailing-slash',
 ];
-const builtInArazzoRules = ['spec', 'parameters-no-body-inside-in'];
+const builtInArazzoRules = [
+    'spec',
+    'parameters-not-in-body',
+    'sourceDescription-type',
+    'version-enum',
+    'workflowId-unique',
+    'stepId-unique',
+    'sourceDescription-name-unique',
+    'workflow-dependsOn',
+    'parameters-unique',
+    'step-onSuccess-unique',
+    'step-onFailure-unique',
+    'requestBody-replacements-unique',
+];
 const builtInRules = [
     ...builtInCommonOASRules,
     ...builtInOAS2Rules,

package/lib/typings/arazzo.d.ts

@@ -146,3 +146,5 @@ export interface ArazzoDefinition {
         };
     };
 }
+export declare const VERSION_PATTERN: RegExp;
+export declare const ARAZZO_VERSIONS_SUPPORTED_BY_SPOT: string[];

package/lib/typings/arazzo.js

@@ -1,2 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ARAZZO_VERSIONS_SUPPORTED_BY_SPOT = exports.VERSION_PATTERN = void 0;
+exports.VERSION_PATTERN = /^1\.0\.\d+(-.+)?$/;
+exports.ARAZZO_VERSIONS_SUPPORTED_BY_SPOT = ['1.0.0'];

package/lib/utils.d.ts

@@ -12,6 +12,7 @@ export declare function pushStack<T, P extends Stack<T> = Stack<T>>(head: P, val
     prev: P;
     value: T;
 };
+export declare function pluralize(sentence: string, count?: number, inclusive?: boolean): string;
 export declare function popStack<T, P extends Stack<T>>(head: P): StackFrame<T> | null;
 export type BundleOutputFormat = 'json' | 'yml' | 'yaml';
 export declare function loadYaml<T>(filename: string): Promise<T>;