@redocly/openapi-core 1.17.0 → 1.18.0

package/lib/types/arazzo.js

@@ -0,0 +1,381 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArazzoTypes = exports.arazzoSchema = exports.ARAZZO_ROOT_TYPE = void 0;
+const json_schema_adapter_1 = require("./json-schema-adapter");
+exports.ARAZZO_ROOT_TYPE = 'Root';
+const operationMethod = {
+    type: 'string',
+    enum: ['get', 'post', 'put', 'delete', 'patch'],
+};
+const expectSchema = {
+    type: 'object',
+    properties: {
+        statusCode: { type: 'number' },
+        mimeType: { type: 'string' },
+        body: {},
+        schema: {
+            type: 'object',
+            additionalProperties: true,
+        },
+    },
+    additionalProperties: false,
+    oneOf: [
+        { required: ['statusCode'] },
+        { required: ['mimeType'] },
+        { required: ['body'] },
+        { required: ['schema'] },
+    ],
+};
+const openAPISourceDescriptionSchema = {
+    type: 'object',
+    properties: {
+        name: { type: 'string' },
+        type: { type: 'string', enum: ['openapi'] },
+        url: { type: 'string' },
+        'x-serverUrl': { type: 'string' },
+    },
+    additionalProperties: false,
+    required: ['name', 'type', 'url'],
+};
+const noneSourceDescriptionSchema = {
+    type: 'object',
+    properties: {
+        name: { type: 'string' },
+        type: { type: 'string', enum: ['none'] },
+        'x-serverUrl': { type: 'string' },
+    },
+    additionalProperties: false,
+    required: ['name', 'type', 'x-serverUrl'],
+};
+const arazzoSourceDescriptionSchema = {
+    type: 'object',
+    properties: {
+        name: { type: 'string' },
+        type: { type: 'string', enum: ['arazzo'] },
+        url: { type: 'string' },
+    },
+    additionalProperties: false,
+    required: ['name', 'type', 'url'],
+};
+const sourceDescriptionSchema = {
+    type: 'object',
+    oneOf: [
+        openAPISourceDescriptionSchema,
+        noneSourceDescriptionSchema,
+        arazzoSourceDescriptionSchema,
+    ],
+};
+const sourceDescriptionsSchema = {
+    type: 'array',
+    items: sourceDescriptionSchema,
+};
+const extendedOperation = {
+    type: 'object',
+    properties: {
+        path: { type: 'string' },
+        method: operationMethod,
+        sourceDescriptionName: { type: 'string' },
+        serverUrl: { type: 'string' },
+    },
+    additionalProperties: false,
+    required: ['path', 'method'],
+};
+const parameter = {
+    type: 'object',
+    oneOf: [
+        {
+            type: 'object',
+            properties: {
+                in: { type: 'string', enum: ['header', 'query', 'path', 'cookie', 'body'] },
+                name: { type: 'string' },
+                value: {
+                    oneOf: [{ type: 'string' }, { type: 'number' }, { type: 'boolean' }],
+                },
+            },
+            required: ['name', 'value'],
+            additionalProperties: false,
+        },
+        {
+            type: 'object',
+            properties: {
+                $ref: { type: 'string' },
+                value: {
+                    oneOf: [{ type: 'string' }, { type: 'number' }, { type: 'boolean' }],
+                },
+            },
+            required: ['$ref'],
+            additionalProperties: false,
+        },
+        {
+            type: 'object',
+            properties: {
+                reference: { type: 'string' },
+                value: {
+                    oneOf: [{ type: 'string' }, { type: 'number' }, { type: 'boolean' }],
+                },
+            },
+            required: ['reference'],
+            additionalProperties: false,
+        },
+    ],
+};
+const parameters = {
+    type: 'array',
+    items: parameter,
+};
+const infoObject = {
+    type: 'object',
+    properties: {
+        title: { type: 'string' },
+        description: { type: 'string' },
+        summary: { type: 'string' },
+        version: { type: 'string' },
+    },
+    additionalProperties: false,
+    required: ['title', 'version'],
+};
+const replacement = {
+    type: 'object',
+    properties: {
+        target: { type: 'string' },
+        value: {
+            oneOf: [
+                { type: 'string' },
+                { type: 'object' },
+                { type: 'array' },
+                { type: 'number' },
+                { type: 'boolean' },
+            ],
+        },
+    },
+};
+const requestBody = {
+    type: 'object',
+    properties: {
+        contentType: { type: 'string' },
+        payload: {
+            oneOf: [
+                { type: 'string' },
+                { type: 'object', additionalProperties: true },
+                { type: 'array' },
+                { type: 'number' },
+                { type: 'boolean' },
+            ],
+        },
+        encoding: { type: 'string' },
+        replacements: {
+            type: 'array',
+            items: replacement,
+        },
+    },
+    additionalProperties: false,
+    required: ['payload'],
+};
+const criteriaObject = {
+    type: 'object',
+    properties: {
+        condition: { type: 'string' },
+        context: { type: 'string' },
+        type: {
+            oneOf: [
+                { type: 'string', enum: ['regex', 'jsonpath', 'simple', 'xpath'] },
+                {
+                    type: 'object',
+                    properties: {
+                        type: { type: 'string', enum: ['jsonpath'] },
+                        version: { type: 'string', enum: ['draft-goessner-dispatch-jsonpath-00'] },
+                    },
+                },
+                {
+                    type: 'object',
+                    properties: {
+                        type: { type: 'string', enum: ['xpath'] },
+                        version: { type: 'string', enum: ['xpath-30', 'xpath-20', 'xpath-10'] },
+                    },
+                },
+            ],
+        },
+    },
+    required: ['condition'],
+    additionalProperties: false,
+};
+const criteriaObjects = {
+    type: 'array',
+    items: criteriaObject,
+};
+const inherit = {
+    type: 'string',
+    enum: ['auto', 'none'],
+};
+const onSuccessObject = {
+    type: 'object',
+    properties: {
+        name: { type: 'string' },
+        type: { type: 'string', enum: ['goto', 'end'] },
+        stepId: { type: 'string' },
+        workflowId: { type: 'string' },
+        criteria: criteriaObjects,
+    },
+    additionalProperties: false,
+    required: ['type', 'name'],
+};
+const onSuccessList = {
+    type: 'array',
+    items: onSuccessObject,
+};
+const onFailureObject = {
+    type: 'object',
+    properties: {
+        name: { type: 'string' },
+        type: { type: 'string', enum: ['goto', 'retry', 'end'] },
+        workflowId: { type: 'string' },
+        stepId: { type: 'string' },
+        retryAfter: { type: 'number' },
+        retryLimit: { type: 'number' },
+        criteria: criteriaObjects,
+    },
+    additionalProperties: false,
+    required: ['type', 'name'],
+};
+const onFailureList = {
+    type: 'array',
+    items: onFailureObject,
+};
+const step = {
+    type: 'object',
+    properties: {
+        stepId: { type: 'string' },
+        description: { type: 'string' },
+        operationId: { type: 'string' },
+        operationPath: { type: 'string' },
+        workflowId: { type: 'string' },
+        parameters: parameters,
+        successCriteria: criteriaObjects,
+        onSuccess: onSuccessList,
+        onFailure: onFailureList,
+        outputs: {
+            type: 'object',
+            additionalProperties: {
+                type: 'string',
+            },
+        },
+        'x-inherit': inherit,
+        'x-expect': expectSchema,
+        'x-assert': { type: 'string' },
+        'x-operation': extendedOperation,
+        requestBody: requestBody,
+    },
+    required: ['stepId'],
+    oneOf: [
+        { required: ['x-operation'] },
+        { required: ['operationId'] },
+        { required: ['operationPath'] },
+        { required: ['workflowId'] },
+    ],
+};
+const steps = {
+    type: 'array',
+    items: step,
+};
+const JSONSchema = {
+    type: 'object',
+    properties: {
+        type: {
+            type: 'string',
+            enum: ['object', 'array', 'string', 'number', 'integer', 'boolean', 'null'],
+        },
+        properties: {
+            type: 'object',
+            additionalProperties: true,
+        },
+        required: {
+            type: 'array',
+            items: { type: 'string' },
+        },
+        items: {
+            type: 'object',
+            additionalProperties: true,
+        },
+    },
+    required: ['type'],
+    additionalProperties: true,
+};
+const workflow = {
+    type: 'object',
+    properties: {
+        workflowId: { type: 'string' },
+        summary: { type: 'string' },
+        description: { type: 'string' },
+        parameters: parameters,
+        dependsOn: { type: 'array', items: { type: 'string' } },
+        inputs: JSONSchema,
+        outputs: {
+            type: 'object',
+            additionalProperties: {
+                type: 'string',
+            },
+        },
+        steps: steps,
+        successActions: {
+            type: 'array',
+            items: onSuccessObject,
+        },
+        failureActions: {
+            type: 'array',
+            items: onFailureObject,
+        },
+    },
+    additionalProperties: false,
+    required: ['workflowId', 'steps'],
+};
+const workflows = {
+    type: 'array',
+    items: workflow,
+};
+exports.arazzoSchema = {
+    type: 'object',
+    properties: {
+        arazzo: { type: 'string', enum: ['1.0.0'] },
+        info: infoObject,
+        sourceDescriptions: sourceDescriptionsSchema,
+        'x-parameters': parameters,
+        workflows: workflows,
+        components: {
+            type: 'object',
+            properties: {
+                inputs: {
+                    type: 'object',
+                    additionalProperties: {
+                        type: 'object',
+                        additionalProperties: true,
+                        properties: {
+                            type: {
+                                type: 'string',
+                            },
+                            properties: {
+                                type: 'object',
+                                additionalProperties: true,
+                            },
+                        },
+                        required: ['type'],
+                    },
+                },
+                parameters: {
+                    type: 'object',
+                    additionalProperties: parameter,
+                },
+                successActions: {
+                    type: 'object',
+                    additionalProperties: onSuccessObject,
+                },
+                failureActions: {
+                    type: 'object',
+                    additionalProperties: onFailureObject,
+                },
+            },
+        },
+    },
+    additionalProperties: false,
+    required: ['arazzo', 'info', 'sourceDescriptions', 'workflows'],
+};
+exports.ArazzoTypes = (0, json_schema_adapter_1.getNodeTypesFromJSONSchema)(exports.ARAZZO_ROOT_TYPE, exports.arazzoSchema);

package/lib/types/oas3.js

@@ -316,14 +316,6 @@ const Schema = {
                 return 'Schema';
             }
         },
-        additionalItems: (value) => {
-            if (typeof value === 'boolean') {
-                return { type: 'boolean' };
-            }
-            else {
-                return 'Schema';
-            }
-        },
         additionalProperties: (value) => {
             if (typeof value === 'boolean') {
                 return { type: 'boolean' };

package/lib/types/oas3_1.js

@@ -129,6 +129,7 @@ const Schema = {
         then: 'Schema',
         else: 'Schema',
         dependentSchemas: (0, _1.listOf)('Schema'),
+        dependentRequired: 'DependentRequired',
         prefixItems: (0, _1.listOf)('Schema'),
         contains: 'Schema',
         minContains: { type: 'integer', minimum: 0 },
@@ -262,10 +263,15 @@ const SecurityScheme = {
     },
     extensionsPrefix: 'x-',
 };
+const DependentRequired = {
+    properties: {},
+    additionalProperties: { type: 'array', items: { type: 'string' } },
+};
 exports.Oas3_1Types = Object.assign(Object.assign({}, oas3_1.Oas3Types), { Info,
     Root,
     Schema,
     SchemaProperties,
     License,
     Components, NamedPathItems: (0, _1.mapOf)('PathItem'), SecurityScheme,
-    Operation });
+    Operation,
+    DependentRequired });

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

@@ -1,21 +1,21 @@
 import type { NodeType } from '.';
 import type { JSONSchema } from 'json-schema-to-ts';
 import { Config } from '../config';
-declare const builtInCommonRules: readonly ["spec", "info-contact", "operation-operationId", "tag-description", "tags-alphabetical"];
-export type BuiltInCommonRuleId = typeof builtInCommonRules[number];
-declare const builtInCommonOASRules: readonly ["info-license-url", "info-license", "no-ambiguous-paths", "no-enum-type-mismatch", "no-http-verbs-in-paths", "no-identical-paths", "no-invalid-parameter-examples", "no-invalid-schema-examples", "no-path-trailing-slash", "operation-2xx-response", "operation-4xx-response", "operation-description", "operation-operationId-unique", "operation-operationId-url-safe", "operation-parameters-unique", "operation-singular-tag", "operation-summary", "operation-tag-defined", "parameter-description", "path-declaration-must-exist", "path-excludes-patterns", "path-http-verbs-order", "path-not-include-query", "path-params-defined", "path-parameters-defined", "path-segment-plural", "paths-kebab-case", "required-string-property-missing-min-length", "response-contains-header", "scalar-property-missing-example", "security-defined", "spec-strict-refs", "no-unresolved-refs", "no-required-schema-properties-undefined"];
+declare const builtInCommonOASRules: readonly ["spec", "info-contact", "operation-operationId", "tag-description", "tags-alphabetical", "info-license-url", "info-license", "no-ambiguous-paths", "no-enum-type-mismatch", "no-http-verbs-in-paths", "no-identical-paths", "no-invalid-parameter-examples", "no-invalid-schema-examples", "no-path-trailing-slash", "operation-2xx-response", "operation-4xx-response", "operation-description", "operation-operationId-unique", "operation-operationId-url-safe", "operation-parameters-unique", "operation-singular-tag", "operation-summary", "operation-tag-defined", "parameter-description", "path-declaration-must-exist", "path-excludes-patterns", "path-http-verbs-order", "path-not-include-query", "path-params-defined", "path-parameters-defined", "path-segment-plural", "paths-kebab-case", "required-string-property-missing-min-length", "response-contains-header", "scalar-property-missing-example", "security-defined", "spec-strict-refs", "no-unresolved-refs", "no-required-schema-properties-undefined"];
 export type BuiltInCommonOASRuleId = typeof builtInCommonOASRules[number];
 declare const builtInOAS2Rules: readonly ["boolean-parameter-prefixes", "request-mime-type", "response-contains-property", "response-mime-type"];
 export type BuiltInOAS2RuleId = typeof builtInOAS2Rules[number];
 declare const builtInOAS3Rules: readonly ["boolean-parameter-prefixes", "component-name-unique", "no-empty-servers", "no-example-value-and-externalValue", "no-invalid-media-type-examples", "no-server-example.com", "no-server-trailing-slash", "no-server-variables-empty-enum", "no-undefined-server-variable", "no-unused-components", "operation-4xx-problem-details-rfc7807", "request-mime-type", "response-contains-property", "response-mime-type", "spec-components-invalid-map-name", "array-parameter-serialization"];
 export type BuiltInOAS3RuleId = typeof builtInOAS3Rules[number];
-declare const builtInAsync2Rules: readonly ["channels-kebab-case", "no-channel-trailing-slash"];
+declare const builtInAsync2Rules: readonly ["spec", "info-contact", "operation-operationId", "tag-description", "tags-alphabetical", "channels-kebab-case", "no-channel-trailing-slash"];
 export type BuiltInAsync2RuleId = typeof builtInAsync2Rules[number];
+declare const builtInArazzoRules: readonly ["spec"];
+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];
 declare const oas3NodeTypesList: readonly ["Root", "Tag", "TagList", "ExternalDocs", "Server", "ServerList", "ServerVariable", "ServerVariablesMap", "SecurityRequirement", "SecurityRequirementList", "Info", "Contact", "License", "Paths", "PathItem", "Parameter", "ParameterList", "Operation", "Callback", "CallbacksMap", "RequestBody", "MediaTypesMap", "MediaType", "Example", "ExamplesMap", "Encoding", "EncodingMap", "Header", "HeadersMap", "Responses", "Response", "Link", "LinksMap", "Schema", "Xml", "SchemaProperties", "DiscriminatorMapping", "Discriminator", "Components", "NamedSchemas", "NamedResponses", "NamedParameters", "NamedExamples", "NamedRequestBodies", "NamedHeaders", "NamedSecuritySchemes", "NamedLinks", "NamedCallbacks", "ImplicitFlow", "PasswordFlow", "ClientCredentials", "AuthorizationCode", "OAuth2Flows", "SecurityScheme", "TagGroup", "TagGroups", "EnumDescriptions", "Logo", "XCodeSample", "XCodeSampleList", "XUsePkce", "WebhooksMap"];
 export type Oas3NodeType = typeof oas3NodeTypesList[number];
-declare const oas3_1NodeTypesList: readonly ["Root", "Schema", "SchemaProperties", "Info", "License", "Components", "NamedPathItems", "SecurityScheme", "Operation"];
+declare const oas3_1NodeTypesList: readonly ["Root", "Schema", "SchemaProperties", "Info", "License", "Components", "NamedPathItems", "SecurityScheme", "Operation", "DependentRequired"];
 export type Oas3_1NodeType = typeof oas3_1NodeTypesList[number];
 export declare function createConfigTypes(extraSchemas: JSONSchema, config?: Config): {
     ConfigRoot: NodeType;

package/lib/types/redocly-yaml.js

@@ -6,14 +6,12 @@ const _1 = require(".");
 const utils_1 = require("../utils");
 const json_schema_adapter_1 = require("./json-schema-adapter");
 const oas_types_1 = require("../oas-types");
-const builtInCommonRules = [
+const builtInCommonOASRules = [
     'spec',
     'info-contact',
     'operation-operationId',
     'tag-description',
     'tags-alphabetical',
-];
-const builtInCommonOASRules = [
     'info-license-url',
     'info-license',
     'no-ambiguous-paths',
@@ -73,13 +71,22 @@ const builtInOAS3Rules = [
     'spec-components-invalid-map-name',
     'array-parameter-serialization',
 ];
-const builtInAsync2Rules = ['channels-kebab-case', 'no-channel-trailing-slash'];
+const builtInAsync2Rules = [
+    'spec',
+    'info-contact',
+    'operation-operationId',
+    'tag-description',
+    'tags-alphabetical',
+    'channels-kebab-case',
+    'no-channel-trailing-slash',
+];
+const builtInArazzoRules = ['spec'];
 const builtInRules = [
-    ...builtInCommonRules,
     ...builtInCommonOASRules,
     ...builtInOAS2Rules,
     ...builtInOAS3Rules,
     ...builtInAsync2Rules,
+    ...builtInArazzoRules,
 ];
 const oas2NodeTypesList = [
     'Root',
@@ -194,6 +201,7 @@ const oas3_1NodeTypesList = [
     'NamedPathItems',
     'SecurityScheme',
     'Operation',
+    'DependentRequired',
 ];
 const ConfigStyleguide = {
     properties: {
@@ -208,16 +216,19 @@ const ConfigStyleguide = {
         oas3_0Rules: 'Rules',
         oas3_1Rules: 'Rules',
         async2Rules: 'Rules',
+        arazzoRules: 'Rules',
         preprocessors: { type: 'object' },
         oas2Preprocessors: { type: 'object' },
         oas3_0Preprocessors: { type: 'object' },
         oas3_1Preprocessors: { type: 'object' },
         async2Preprocessors: { type: 'object' },
+        arazzoPreprocessors: { type: 'object' },
         decorators: { type: 'object' },
         oas2Decorators: { type: 'object' },
         oas3_0Decorators: { type: 'object' },
         oas3_1Decorators: { type: 'object' },
         async2Decorators: { type: 'object' },
+        arazzoDecorators: { type: 'object' },
     },
 };
 const createConfigRoot = (nodeTypes) => (Object.assign(Object.assign({}, nodeTypes.rootRedoclyConfigSchema), { properties: Object.assign(Object.assign(Object.assign({}, nodeTypes.rootRedoclyConfigSchema.properties), ConfigStyleguide.properties), { apis: 'ConfigApis', 'features.openapi': 'ConfigReferenceDocs', 'features.mockServer': 'ConfigMockServer', organization: { type: 'string' }, region: { enum: ['us', 'eu'] }, telemetry: { enum: ['on', 'off'] }, resolve: {

package/lib/typings/arazzo.d.ts

@@ -0,0 +1,3 @@
+import type { FromSchema } from 'json-schema-to-ts';
+import type { arazzoSchema } from '../types/arazzo';
+export type ArazzoDefinition = FromSchema<typeof arazzoSchema>;

package/lib/typings/arazzo.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/visitors.d.ts

@@ -5,6 +5,7 @@ import type { Location } from './ref-utils';
 import type { Oas3Definition, Oas3ExternalDocs, Oas3Info, Oas3Contact, Oas3Components, Oas3License, Oas3Schema, Oas3Header, Oas3Parameter, Oas3Operation, Oas3PathItem, Oas3ServerVariable, Oas3Server, Oas3MediaType, Oas3Response, Oas3Example, Oas3RequestBody, Oas3Tag, OasRef, Oas3SecurityScheme, Oas3SecurityRequirement, Oas3Encoding, Oas3Link, Oas3Xml, Oas3Discriminator, Oas3Callback } from './typings/openapi';
 import type { Oas2Definition, Oas2Tag, Oas2ExternalDocs, Oas2SecurityRequirement, Oas2Info, Oas2Contact, Oas2License, Oas2PathItem, Oas2Operation, Oas2Header, Oas2Response, Oas2Schema, Oas2Xml, Oas2Parameter, Oas2SecurityScheme } from './typings/swagger';
 import type { Async2Definition } from './typings/asyncapi';
+import type { ArazzoDefinition } from './typings/arazzo';
 export type SkipFunctionContext = Pick<UserContext, 'location' | 'rawNode' | 'resolve' | 'rawLocation'>;
 export type VisitFunction<T> = (node: T, ctx: UserContext & {
     ignoreNextVisitorsOnNode: () => void;
@@ -139,6 +140,9 @@ type Oas2FlatVisitor = {
 type Async2FlatVisitor = {
     Root?: VisitFunctionOrObject<Async2Definition>;
 };
+type ArazzoFlatVisitor = {
+    Root?: VisitFunctionOrObject<ArazzoDefinition>;
+};
 type Oas3NestedVisitor = {
     [T in keyof Oas3FlatVisitor]: Oas3FlatVisitor[T] extends Function ? Oas3FlatVisitor[T] : Oas3FlatVisitor[T] & NestedVisitor<Oas3NestedVisitor>;
 };
@@ -148,9 +152,13 @@ type Oas2NestedVisitor = {
 type Async2NestedVisitor = {
     [T in keyof Async2FlatVisitor]: Async2FlatVisitor[T] extends Function ? Async2FlatVisitor[T] : Async2FlatVisitor[T] & NestedVisitor<Async2NestedVisitor>;
 };
+type ArazzoNestedVisitor = {
+    [T in keyof ArazzoFlatVisitor]: ArazzoFlatVisitor[T] extends Function ? ArazzoFlatVisitor[T] : ArazzoFlatVisitor[T] & NestedVisitor<ArazzoNestedVisitor>;
+};
 export type Oas3Visitor = BaseVisitor & Oas3NestedVisitor & Record<string, VisitFunction<any> | NestedVisitObject<any, Oas3NestedVisitor>>;
 export type Oas2Visitor = BaseVisitor & Oas2NestedVisitor & Record<string, VisitFunction<any> | NestedVisitObject<any, Oas2NestedVisitor>>;
 export type Async2Visitor = BaseVisitor & Async2NestedVisitor & Record<string, VisitFunction<any> | NestedVisitObject<any, Async2NestedVisitor>>;
+export type ArazzoVisitor = BaseVisitor & ArazzoNestedVisitor & Record<string, VisitFunction<any> | NestedVisitObject<any, ArazzoNestedVisitor>>;
 export type NestedVisitor<T> = Exclude<T, 'any' | 'ref' | 'Root'>;
 export type NormalizedOasVisitors<T extends BaseVisitor> = {
     [V in keyof T]-?: {
@@ -170,12 +178,15 @@ export type NormalizedOasVisitors<T extends BaseVisitor> = {
 export type Oas3Rule = (options: Record<string, any>) => Oas3Visitor | Oas3Visitor[];
 export type Oas2Rule = (options: Record<string, any>) => Oas2Visitor | Oas2Visitor[];
 export type Async2Rule = (options: Record<string, any>) => Async2Visitor | Async2Visitor[];
+export type ArazzoRule = (options: Record<string, any>) => ArazzoVisitor | ArazzoVisitor[];
 export type Oas3Preprocessor = (options: Record<string, any>) => Oas3Visitor;
 export type Oas2Preprocessor = (options: Record<string, any>) => Oas2Visitor;
 export type Async2Preprocessor = (options: Record<string, any>) => Async2Visitor;
+export type ArazzoPreprocessor = (options: Record<string, any>) => ArazzoVisitor;
 export type Oas3Decorator = (options: Record<string, any>) => Oas3Visitor;
 export type Oas2Decorator = (options: Record<string, any>) => Oas2Visitor;
 export type Async2Decorator = (options: Record<string, any>) => Async2Visitor;
+export type ArazzoDecorator = (options: Record<string, any>) => ArazzoVisitor;
 export type OasRule = Oas3Rule;
 export type OasPreprocessor = Oas3Preprocessor;
 export type OasDecorator = Oas3Decorator;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redocly/openapi-core",
-  "version": "1.17.0",
+  "version": "1.18.0",
   "description": "",
   "main": "lib/index.js",
   "engines": {
@@ -36,7 +36,7 @@
   ],
   "dependencies": {
     "@redocly/ajv": "^8.11.0",
-    "@redocly/config": "^0.6.0",
+    "@redocly/config": "^0.6.2",
     "colorette": "^1.2.0",
     "https-proxy-agent": "^7.0.4",
     "js-levenshtein": "^1.1.6",
@@ -55,6 +55,7 @@
     "@types/node": "^20.11.5",
     "@types/node-fetch": "^2.5.7",
     "@types/pluralize": "^0.0.29",
+    "json-schema-to-ts": "^3.1.0",
     "typescript": "^5.2.2"
   }
 }