@redocly/openapi-core 1.17.1 → 1.18.1

package/lib/types/arazzo.js

@@ -0,0 +1,386 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArazzoTypes = exports.arazzoSchema = exports.workflow = exports.step = exports.inherit = exports.criteriaObject = exports.requestBody = exports.replacement = exports.infoObject = exports.parameter = exports.sourceDescriptionSchema = exports.expectSchema = exports.operationMethod = exports.ARAZZO_ROOT_TYPE = void 0;
+const json_schema_adapter_1 = require("./json-schema-adapter");
+exports.ARAZZO_ROOT_TYPE = 'Root';
+exports.operationMethod = {
+    type: 'string',
+    enum: ['get', 'post', 'put', 'delete', 'patch'],
+};
+exports.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'],
+};
+exports.sourceDescriptionSchema = {
+    type: 'object',
+    oneOf: [
+        openAPISourceDescriptionSchema,
+        noneSourceDescriptionSchema,
+        arazzoSourceDescriptionSchema,
+    ],
+};
+const sourceDescriptionsSchema = {
+    type: 'array',
+    items: exports.sourceDescriptionSchema,
+};
+const extendedOperation = {
+    type: 'object',
+    properties: {
+        path: { type: 'string' },
+        method: exports.operationMethod,
+        sourceDescriptionName: { type: 'string' },
+        serverUrl: { type: 'string' },
+    },
+    additionalProperties: false,
+    required: ['path', 'method'],
+};
+exports.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: {
+                reference: { type: 'string' },
+                value: {
+                    oneOf: [{ type: 'string' }, { type: 'number' }, { type: 'boolean' }],
+                },
+            },
+            required: ['reference'],
+            additionalProperties: false,
+        },
+    ],
+};
+const parameters = {
+    type: 'array',
+    items: exports.parameter,
+};
+exports.infoObject = {
+    type: 'object',
+    properties: {
+        title: { type: 'string' },
+        description: { type: 'string' },
+        summary: { type: 'string' },
+        version: { type: 'string' },
+    },
+    additionalProperties: false,
+    required: ['title', 'version'],
+};
+exports.replacement = {
+    type: 'object',
+    properties: {
+        target: { type: 'string' },
+        value: {
+            oneOf: [
+                { type: 'string' },
+                { type: 'object' },
+                { type: 'array' },
+                { type: 'number' },
+                { type: 'boolean' },
+            ],
+        },
+    },
+};
+exports.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: exports.replacement,
+        },
+    },
+    additionalProperties: false,
+    required: ['payload'],
+};
+exports.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: exports.criteriaObject,
+};
+exports.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,
+};
+exports.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: {
+                oneOf: [
+                    {
+                        type: 'string',
+                    },
+                    {
+                        type: 'object',
+                    },
+                    {
+                        type: 'array',
+                    },
+                    {
+                        type: 'boolean',
+                    },
+                    {
+                        type: 'number',
+                    },
+                ],
+            },
+        },
+        'x-inherit': exports.inherit,
+        'x-expect': exports.expectSchema,
+        'x-assert': { type: 'string' },
+        'x-operation': extendedOperation,
+        requestBody: exports.requestBody,
+    },
+    required: ['stepId'],
+    oneOf: [
+        { required: ['x-operation'] },
+        { required: ['operationId'] },
+        { required: ['operationPath'] },
+        { required: ['workflowId'] },
+    ],
+};
+const steps = {
+    type: 'array',
+    items: exports.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,
+};
+exports.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: exports.workflow,
+};
+exports.arazzoSchema = {
+    type: 'object',
+    properties: {
+        arazzo: { type: 'string', enum: ['1.0.0'] },
+        info: exports.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: exports.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/asyncapi.js

@@ -308,11 +308,8 @@ const MessageExample = {
 const Schema = {
     properties: {
         $id: { type: 'string' },
-        id: { type: 'string' },
         $schema: { type: 'string' },
         definitions: 'NamedSchemas',
-        $defs: 'NamedSchemas',
-        $vocabulary: { type: 'string' },
         externalDocs: 'ExternalDocs',
         discriminator: 'Discriminator',
         myArbitraryKeyword: { type: 'boolean' },
@@ -333,17 +330,14 @@ const Schema = {
         required: { type: 'array', items: { type: 'string' } },
         enum: { type: 'array' },
         type: (value) => {
-            if (Array.isArray(value)) {
-                return {
+            return Array.isArray(value)
+                ? {
                     type: 'array',
                     items: { enum: ['object', 'array', 'string', 'number', 'integer', 'boolean', 'null'] },
-                };
-            }
-            else {
-                return {
+                }
+                : {
                     enum: ['object', 'array', 'string', 'number', 'integer', 'boolean', 'null'],
                 };
-            }
         },
         allOf: (0, _1.listOf)('Schema'),
         anyOf: (0, _1.listOf)('Schema'),
@@ -352,38 +346,12 @@ const Schema = {
         if: 'Schema',
         then: 'Schema',
         else: 'Schema',
-        dependentSchemas: (0, _1.listOf)('Schema'),
-        prefixItems: (0, _1.listOf)('Schema'),
         contains: 'Schema',
-        minContains: { type: 'integer', minimum: 0 },
-        maxContains: { type: 'integer', minimum: 0 },
         patternProperties: { type: 'object' },
         propertyNames: 'Schema',
-        unevaluatedItems: (value) => {
-            if (typeof value === 'boolean') {
-                return { type: 'boolean' };
-            }
-            else {
-                return 'Schema';
-            }
-        },
-        unevaluatedProperties: (value) => {
-            if (typeof value === 'boolean') {
-                return { type: 'boolean' };
-            }
-            else {
-                return 'Schema';
-            }
-        },
-        summary: { type: 'string' },
         properties: 'SchemaProperties',
         items: (value) => {
-            if (typeof value === 'boolean') {
-                return { type: 'boolean' };
-            }
-            else {
-                return 'Schema';
-            }
+            return Array.isArray(value) ? (0, _1.listOf)('Schema') : 'Schema';
         },
         additionalProperties: (value) => {
             return typeof value === 'boolean' ? { type: 'boolean' } : 'Schema';
@@ -395,22 +363,21 @@ const Schema = {
         default: null,
         readOnly: { type: 'boolean' },
         writeOnly: { type: 'boolean' },
-        // xml: 'Xml',
         examples: { type: 'array' },
         example: { isExample: true },
         deprecated: { type: 'boolean' },
         const: null,
         $comment: { type: 'string' },
-        dependencies: { type: 'object' }, // TODO
+        additionalItems: (value) => {
+            return typeof value === 'boolean' ? { type: 'boolean' } : 'Schema';
+        },
+        dependencies: 'Dependencies',
     },
 };
 const SchemaProperties = {
     properties: {},
     additionalProperties: (value) => {
-        if (typeof value === 'boolean') {
-            return { type: 'boolean' };
-        }
-        return 'Schema';
+        return typeof value === 'boolean' ? { type: 'boolean' } : 'Schema';
     },
 };
 const DiscriminatorMapping = {
@@ -552,6 +519,12 @@ const SecurityScheme = {
     },
     extensionsPrefix: 'x-',
 };
+const Dependencies = {
+    properties: {},
+    additionalProperties: (value) => {
+        return Array.isArray(value) ? { type: 'array', items: { type: 'string' } } : 'Schema';
+    },
+};
 // --- Per-protocol node types
 // http
 const HttpChannelBinding = {
@@ -1025,4 +998,5 @@ exports.AsyncApi2Types = {
     MessageTrait,
     MessageTraitList: (0, _1.listOf)('MessageTrait'),
     CorrelationId,
+    Dependencies,
 };

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

@@ -128,13 +128,13 @@ const Schema = {
         if: 'Schema',
         then: 'Schema',
         else: 'Schema',
-        dependentSchemas: (0, _1.listOf)('Schema'),
+        dependentSchemas: (0, _1.mapOf)('Schema'),
         dependentRequired: 'DependentRequired',
         prefixItems: (0, _1.listOf)('Schema'),
         contains: 'Schema',
         minContains: { type: 'integer', minimum: 0 },
         maxContains: { type: 'integer', minimum: 0 },
-        patternProperties: { type: 'object' },
+        patternProperties: 'SchemaProperties',
         propertyNames: 'Schema',
         unevaluatedItems: (value) => {
             if (typeof value === 'boolean') {

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

@@ -1,16 +1,16 @@
 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"];

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',
@@ -209,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,30 @@
+import type { FromSchema } from 'json-schema-to-ts';
+import type { arazzoSchema, parameter, operationMethod, expectSchema, sourceDescriptionSchema, infoObject, requestBody, replacement, inherit, criteriaObject, step, workflow } from '../types/arazzo';
+export type ArazzoDefinition = FromSchema<typeof arazzoSchema>;
+export type OperationMethod = FromSchema<typeof operationMethod>;
+export type ResponseContext = {
+    statusCode: number;
+    body: any;
+    headers: Headers;
+    mimeType: string;
+} & Record<string, any>;
+export type Expect = FromSchema<typeof expectSchema>;
+export type SourceDescription = FromSchema<typeof sourceDescriptionSchema>;
+export type Parameter = FromSchema<typeof parameter>;
+export type InfoObject = FromSchema<typeof infoObject>;
+export type RequestBody = FromSchema<typeof requestBody>;
+export type Replacement = FromSchema<typeof replacement>;
+export type Inherit = FromSchema<typeof inherit>;
+export type CriteriaObject = FromSchema<typeof criteriaObject>;
+export type VerboseLog = {
+    method: OperationMethod;
+    path: string;
+    host: string;
+    body?: any;
+    headerParams?: Record<string, string>;
+    statusCode?: number;
+};
+export type Step = FromSchema<typeof step>;
+export type Workflow = FromSchema<typeof workflow> & {
+    steps: Step[];
+};

package/lib/typings/arazzo.js

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