@redocly/openapi-core 1.0.0-beta.67 → 1.0.0-beta.71

package/lib/redocly/index.js

@@ -9,69 +9,103 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedoclyClient = void 0;
+exports.isRedoclyRegistryURL = exports.RedoclyClient = void 0;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const os_1 = require("os");
 const colorette_1 = require("colorette");
-const query_1 = require("./query");
+const registry_api_1 = require("./registry-api");
+const config_1 = require("../config/config");
+const utils_1 = require("../utils");
 const TOKEN_FILENAME = '.redocly-config.json';
 class RedoclyClient {
-    constructor() {
-        this.loadToken();
+    constructor(region) {
+        this.accessTokens = {};
+        this.region = this.loadRegion(region);
+        this.loadTokens();
+        this.domain = region
+            ? config_1.DOMAINS[region]
+            : process.env.REDOCLY_DOMAIN || config_1.DOMAINS[config_1.DEFAULT_REGION];
+        this.registryApi = new registry_api_1.RegistryApi(this.accessTokens, this.region);
+    }
+    loadRegion(region) {
+        if (region && !config_1.DOMAINS[region]) {
+            process.stdout.write(colorette_1.red(`Invalid argument: region in config file.\nGiven: ${colorette_1.green(region)}, choices: "us", "eu".\n`));
+            process.exit(1);
+        }
+        if (process.env.REDOCLY_DOMAIN) {
+            return (Object.keys(config_1.DOMAINS).find((region) => config_1.DOMAINS[region] === process.env.REDOCLY_DOMAIN) || config_1.DEFAULT_REGION);
+        }
+        return region || config_1.DEFAULT_REGION;
     }
-    hasToken() {
-        return !!this.accessToken;
+    getRegion() {
+        return this.region;
     }
-    loadToken() {
-        if (process.env.REDOCLY_AUTHORIZATION) {
-            this.accessToken = process.env.REDOCLY_AUTHORIZATION;
-            return;
-        }
+    hasTokens() {
+        return utils_1.isNotEmptyObject(this.accessTokens);
+    }
+    setAccessTokens(accessTokens) {
+        this.accessTokens = accessTokens;
+    }
+    loadTokens() {
         const credentialsPath = path_1.resolve(os_1.homedir(), TOKEN_FILENAME);
-        if (fs_1.existsSync(credentialsPath)) {
-            const credentials = JSON.parse(fs_1.readFileSync(credentialsPath, 'utf-8'));
-            this.accessToken = credentials && credentials.token;
+        const credentials = this.readCredentialsFile(credentialsPath);
+        if (utils_1.isNotEmptyObject(credentials)) {
+            this.setAccessTokens(Object.assign(Object.assign({}, credentials), (credentials.token && !credentials[this.region] && {
+                [this.region]: credentials.token
+            })));
+        }
+        if (process.env.REDOCLY_AUTHORIZATION) {
+            this.setAccessTokens(Object.assign(Object.assign({}, this.accessTokens), { [this.region]: process.env.REDOCLY_AUTHORIZATION }));
         }
     }
-    isAuthorizedWithRedocly() {
+    getValidTokens() {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.hasToken() && !!(yield this.getAuthorizationHeader());
+            return (yield Promise.all(Object.entries(this.accessTokens).map(([key, value]) => __awaiter(this, void 0, void 0, function* () {
+                return { region: key, token: value, valid: yield this.verifyToken(value, key) };
+            })))).filter(item => Boolean(item.valid));
         });
     }
-    verifyToken(accessToken, verbose = false) {
+    getTokens() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!accessToken)
-                return false;
-            const authDetails = yield RedoclyClient.authorize(accessToken, { verbose });
-            if (!authDetails)
+            return this.hasTokens() ? yield this.getValidTokens() : [];
+        });
+    }
+    isAuthorizedWithRedoclyByRegion() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.hasTokens())
                 return false;
-            return true;
+            const accessToken = this.accessTokens[this.region];
+            return !!accessToken && (yield this.verifyToken(accessToken, this.region));
         });
     }
-    getAuthorizationHeader() {
+    isAuthorizedWithRedocly() {
         return __awaiter(this, void 0, void 0, function* () {
-            // print this only if there is token but invalid
-            if (this.accessToken && !(yield this.verifyToken(this.accessToken))) {
-                process.stderr.write(`${colorette_1.yellow('Warning:')} invalid Redocly API key. Use "npx @redocly/openapi-cli login" to provide your API key\n`);
-                return undefined;
-            }
-            return this.accessToken;
+            return this.hasTokens() && utils_1.isNotEmptyObject(yield this.getValidTokens());
+        });
+    }
+    readCredentialsFile(credentialsPath) {
+        return fs_1.existsSync(credentialsPath) ? JSON.parse(fs_1.readFileSync(credentialsPath, 'utf-8')) : {};
+    }
+    verifyToken(accessToken, region, verbose = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!accessToken)
+                return false;
+            return this.registryApi.authStatus(accessToken, region, verbose);
         });
     }
     login(accessToken, verbose = false) {
         return __awaiter(this, void 0, void 0, function* () {
             const credentialsPath = path_1.resolve(os_1.homedir(), TOKEN_FILENAME);
             process.stdout.write(colorette_1.gray('\n  Logging in...\n'));
-            const authorized = yield this.verifyToken(accessToken, verbose);
+            const authorized = yield this.verifyToken(accessToken, this.region, verbose);
             if (!authorized) {
                 process.stdout.write(colorette_1.red('Authorization failed. Please check if you entered a valid API key.\n'));
                 process.exit(1);
             }
-            this.accessToken = accessToken;
-            const credentials = {
-                token: accessToken,
-            };
+            const credentials = Object.assign(Object.assign({}, this.readCredentialsFile(credentialsPath)), { [this.region]: accessToken });
+            this.accessTokens = credentials;
+            this.registryApi.setAccessTokens(credentials);
             fs_1.writeFileSync(credentialsPath, JSON.stringify(credentials, null, 2));
             process.stdout.write(colorette_1.green('  Authorization confirmed. ✅\n\n'));
         });
@@ -83,185 +117,20 @@ class RedoclyClient {
         }
         process.stdout.write('Logged out from the Redocly account. ✋\n');
     }
-    query(queryString, parameters = {}, headers = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return query_1.query(queryString, parameters, Object.assign({ Authorization: this.accessToken }, headers));
-        });
-    }
-    static authorize(accessToken, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { queryName = '', verbose = false } = options;
-            try {
-                const queryStr = `query ${queryName}{ viewer { id } }`;
-                return yield query_1.query(queryStr, {}, { Authorization: accessToken });
-            }
-            catch (e) {
-                if (verbose)
-                    console.log(e);
-                return null;
-            }
-        });
-    }
-    updateDependencies(dependencies) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const definitionId = process.env.DEFINITION;
-            const versionId = process.env.DEFINITION;
-            const branchId = process.env.BRANCH;
-            if (!definitionId || !versionId || !branchId)
-                return;
-            yield this.query(`
-    mutation UpdateBranchDependenciesFromURLs(
-      $urls: [String!]!
-      $definitionId: Int!
-      $versionId: Int!
-      $branchId: Int!
-    ) {
-      updateBranchDependenciesFromURLs(
-        definitionId: $definitionId
-        versionId: $versionId
-        branchId: $branchId
-        urls: $urls
-      ) {
-        branchName
-      }
-    }
-    `, {
-                urls: dependencies || [],
-                definitionId: parseInt(definitionId, 10),
-                versionId: parseInt(versionId, 10),
-                branchId: parseInt(branchId, 10),
-            });
-        });
-    }
-    updateDefinitionVersion(definitionId, versionId, updatePatch) {
-        return this.query(`
-      mutation UpdateDefinitionVersion($definitionId: Int!, $versionId: Int!, $updatePatch: DefinitionVersionPatch!) {
-        updateDefinitionVersionByDefinitionIdAndId(input: {definitionId: $definitionId, id: $versionId, patch: $updatePatch}) {
-          definitionVersion {
-            ...VersionDetails
-            __typename
-          }
-          __typename
-        }
-      }
-
-      fragment VersionDetails on DefinitionVersion {
-        id
-        nodeId
-        uuid
-        definitionId
-        name
-        description
-        sourceType
-        source
-        registryAccess
-        __typename
-      }
-    `, {
-            definitionId,
-            versionId,
-            updatePatch,
-        });
-    }
-    getOrganizationId(organizationId) {
-        return this.query(`
-      query ($organizationId: String!) {
-        organizationById(id: $organizationId) {
-          id
-        }
-      }
-    `, {
-            organizationId
-        });
-    }
-    getDefinitionByName(name, organizationId) {
-        return this.query(`
-      query ($name: String!, $organizationId: String!) {
-        definition: definitionByOrganizationIdAndName(name: $name, organizationId: $organizationId) {
-          id
-        }
-      }
-    `, {
-            name,
-            organizationId
-        });
-    }
-    createDefinition(organizationId, name) {
-        return this.query(`
-      mutation CreateDefinition($organizationId: String!, $name: String!) {
-        def: createDefinition(input: {organizationId: $organizationId, name: $name }) {
-          definition {
-            id
-            nodeId
-            name
-          }
-        }
-      }
-    `, {
-            organizationId,
-            name
-        });
-    }
-    createDefinitionVersion(definitionId, name, sourceType, source) {
-        return this.query(`
-      mutation CreateVersion($definitionId: Int!, $name: String!, $sourceType: DvSourceType!, $source: JSON) {
-        createDefinitionVersion(input: {definitionId: $definitionId, name: $name, sourceType: $sourceType, source: $source }) {
-          definitionVersion {
-            id
-          }
-        }
-      }
-    `, {
-            definitionId,
-            name,
-            sourceType,
-            source
-        });
-    }
-    getSignedUrl(organizationId, filesHash, fileName) {
-        return this.query(`
-      query ($organizationId: String!, $filesHash: String!, $fileName: String!) {
-        signFileUploadCLI(organizationId: $organizationId, filesHash: $filesHash, fileName: $fileName) {
-          signedFileUrl
-          uploadedFilePath
-        }
-      }
-    `, {
-            organizationId,
-            filesHash,
-            fileName
-        });
-    }
-    getDefinitionVersion(organizationId, definitionName, versionName) {
-        return this.query(`
-      query ($organizationId: String!, $definitionName: String!, $versionName: String!) {
-        version: definitionVersionByOrganizationDefinitionAndName(organizationId: $organizationId, definitionName: $definitionName, versionName: $versionName) {
-          id
-          definitionId
-          defaultBranch {
-            name
-          }
-        }
-      }
-    `, {
-            organizationId,
-            definitionName,
-            versionName
-        });
-    }
-    static isRegistryURL(link) {
-        const domain = process.env.REDOCLY_DOMAIN || 'redoc.ly';
-        if (!link.startsWith(`https://api.${domain}/registry/`))
-            return false;
-        const registryPath = link.replace(`https://api.${domain}/registry/`, '');
-        const pathParts = registryPath.split('/');
-        // we can be sure, that there is job UUID present
-        // (org, definition, version, bundle, branch, job, "openapi.yaml" 🤦‍♂️)
-        // so skip this link.
-        // FIXME
-        if (pathParts.length === 7)
-            return false;
-        return true;
-    }
 }
 exports.RedoclyClient = RedoclyClient;
+function isRedoclyRegistryURL(link) {
+    const domain = process.env.REDOCLY_DOMAIN || config_1.DOMAINS[config_1.DEFAULT_REGION];
+    if (!link.startsWith(`https://api.${domain}/registry/`))
+        return false;
+    const registryPath = link.replace(`https://api.${domain}/registry/`, '');
+    const pathParts = registryPath.split('/');
+    // we can be sure, that there is job UUID present
+    // (org, definition, version, bundle, branch, job, "openapi.yaml" 🤦‍♂️)
+    // so skip this link.
+    // FIXME
+    if (pathParts.length === 7)
+        return false;
+    return true;
+}
+exports.isRedoclyRegistryURL = isRedoclyRegistryURL;

package/lib/redocly/registry-api-types.d.ts

@@ -0,0 +1,28 @@
+export declare namespace RegistryApiTypes {
+    interface VersionParams {
+        organizationId: string;
+        name: string;
+        version: string;
+    }
+    export interface PrepareFileuploadParams extends VersionParams {
+        filesHash: string;
+        filename: string;
+        isUpsert?: boolean;
+    }
+    export interface PushApiParams extends VersionParams {
+        rootFilePath: string;
+        filePaths: string[];
+        branch?: string;
+        isUpsert?: boolean;
+    }
+    export interface PrepareFileuploadOKResponse {
+        filePath: string;
+        signedUploadUrl: string;
+    }
+    export interface NotFoundProblemResponse {
+        status: 404;
+        title: 'Not Found';
+        code: 'ORGANIZATION_NOT_FOUND' | 'API_VERSION_NOT_FOUND';
+    }
+    export {};
+}

package/lib/redocly/registry-api-types.js

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

package/lib/redocly/registry-api.d.ts

@@ -0,0 +1,14 @@
+import { RegistryApiTypes } from './registry-api-types';
+import { AccessTokens, Region } from '../config/config';
+export declare class RegistryApi {
+    private accessTokens;
+    private region;
+    constructor(accessTokens: AccessTokens, region: Region);
+    get accessToken(): string | false | undefined;
+    getBaseUrl(region?: Region): string;
+    setAccessTokens(accessTokens: AccessTokens): this;
+    private request;
+    authStatus(accessToken: string, region: Region, verbose?: boolean): Promise<boolean>;
+    prepareFileUpload({ organizationId, name, version, filesHash, filename, isUpsert, }: RegistryApiTypes.PrepareFileuploadParams): Promise<RegistryApiTypes.PrepareFileuploadOKResponse>;
+    pushApi({ organizationId, name, version, rootFilePath, filePaths, branch, isUpsert, }: RegistryApiTypes.PushApiParams): Promise<void>;
+}

package/lib/redocly/registry-api.js

@@ -0,0 +1,105 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegistryApi = void 0;
+const node_fetch_1 = require("node-fetch");
+const config_1 = require("../config/config");
+const utils_1 = require("../utils");
+const version = require('../../package.json').version;
+class RegistryApi {
+    constructor(accessTokens, region) {
+        this.accessTokens = accessTokens;
+        this.region = region;
+    }
+    get accessToken() {
+        return utils_1.isNotEmptyObject(this.accessTokens) && this.accessTokens[this.region];
+    }
+    getBaseUrl(region = config_1.DEFAULT_REGION) {
+        return `https://api.${config_1.DOMAINS[region]}/registry`;
+    }
+    setAccessTokens(accessTokens) {
+        this.accessTokens = accessTokens;
+        return this;
+    }
+    request(path = '', options = {}, region) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const headers = Object.assign({}, options.headers || {}, { 'x-redocly-cli-version': version });
+            if (!headers.hasOwnProperty('authorization')) {
+                throw new Error('Unauthorized');
+            }
+            const response = yield node_fetch_1.default(`${this.getBaseUrl(region)}${path}`, Object.assign({}, options, { headers }));
+            if (response.status === 401) {
+                throw new Error('Unauthorized');
+            }
+            if (response.status === 404) {
+                const body = yield response.json();
+                throw new Error(body.code);
+            }
+            return response;
+        });
+    }
+    authStatus(accessToken, region, verbose = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.request('', { headers: { authorization: accessToken } }, region);
+                return response.ok;
+            }
+            catch (error) {
+                if (verbose) {
+                    console.log(error);
+                }
+                return false;
+            }
+        });
+    }
+    prepareFileUpload({ organizationId, name, version, filesHash, filename, isUpsert, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.request(`/${organizationId}/${name}/${version}/prepare-file-upload`, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    authorization: this.accessToken,
+                },
+                body: JSON.stringify({
+                    filesHash,
+                    filename,
+                    isUpsert,
+                }),
+            }, this.region);
+            if (response.ok) {
+                return response.json();
+            }
+            throw new Error('Could not prepare file upload');
+        });
+    }
+    pushApi({ organizationId, name, version, rootFilePath, filePaths, branch, isUpsert, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.request(`/${organizationId}/${name}/${version}`, {
+                method: 'PUT',
+                headers: {
+                    'content-type': 'application/json',
+                    authorization: this.accessToken
+                },
+                body: JSON.stringify({
+                    rootFilePath,
+                    filePaths,
+                    branch,
+                    isUpsert,
+                }),
+            }, this.region);
+            if (response.ok) {
+                return;
+            }
+            throw new Error('Could not push api');
+        });
+    }
+}
+exports.RegistryApi = RegistryApi;

package/lib/ref-utils.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isMappingRef = exports.isAbsoluteUrl = exports.refBaseName = exports.pointerBaseName = exports.parsePointer = exports.parseRef = exports.escapePointer = exports.unescapePointer = exports.Location = exports.isRef = exports.joinPointer = void 0;
-const path_1 = require("path");
 function joinPointer(base, key) {
     if (base === '')
         base = '#/';
@@ -56,7 +55,7 @@ function pointerBaseName(pointer) {
 }
 exports.pointerBaseName = pointerBaseName;
 function refBaseName(ref) {
-    const parts = ref.split(path_1.sep);
+    const parts = ref.split(/[\/\\]/); // split by '\' and '/'
     return parts[parts.length - 1].split('.')[0];
 }
 exports.refBaseName = refBaseName;

package/lib/rules/common/no-invalid-parameter-examples.d.ts

@@ -0,0 +1 @@
+export declare const NoInvalidParameterExamples: any;

package/lib/rules/common/no-invalid-parameter-examples.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoInvalidParameterExamples = void 0;
+const utils_1 = require("../utils");
+const NoInvalidParameterExamples = (opts) => {
+    var _a;
+    const disallowAdditionalProperties = (_a = opts.disallowAdditionalProperties) !== null && _a !== void 0 ? _a : true;
+    return {
+        Parameter: {
+            leave(parameter, ctx) {
+                if (parameter.example) {
+                    utils_1.validateExample(parameter.example, parameter.schema, ctx.location.child('example'), ctx, disallowAdditionalProperties);
+                }
+                if (parameter.examples) {
+                    for (const [key, example] of Object.entries(parameter.examples)) {
+                        if ('value' in example) {
+                            utils_1.validateExample(example.value, parameter.schema, ctx.location.child(['examples', key]), ctx, false);
+                        }
+                    }
+                }
+            },
+        },
+    };
+};
+exports.NoInvalidParameterExamples = NoInvalidParameterExamples;

package/lib/rules/common/no-invalid-schema-examples.d.ts

@@ -0,0 +1 @@
+export declare const NoInvalidSchemaExamples: any;

package/lib/rules/common/no-invalid-schema-examples.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoInvalidSchemaExamples = void 0;
+const utils_1 = require("../utils");
+const NoInvalidSchemaExamples = (opts) => {
+    var _a;
+    const disallowAdditionalProperties = (_a = opts.disallowAdditionalProperties) !== null && _a !== void 0 ? _a : true;
+    return {
+        Schema: {
+            leave(schema, ctx) {
+                if (schema.examples) {
+                    for (const example of schema.examples) {
+                        utils_1.validateExample(example, schema, ctx.location.child(['examples', schema.examples.indexOf(example)]), ctx, disallowAdditionalProperties);
+                    }
+                }
+                if (schema.example) {
+                    utils_1.validateExample(schema.example, schema, ctx.location.child('example'), ctx, false);
+                }
+            },
+        },
+    };
+};
+exports.NoInvalidSchemaExamples = NoInvalidSchemaExamples;

package/lib/rules/common/paths-kebab-case.js

@@ -4,7 +4,7 @@ exports.PathsKebabCase = void 0;
 const PathsKebabCase = () => {
     return {
         PathItem(_path, { report, key }) {
-            const segments = key.substr(1).split('/');
+            const segments = key.substr(1).split('/').filter(s => s !== ''); // filter out empty segments
             if (!segments.every((segment) => /^{.+}$/.test(segment) || /^[a-z0-9-.]+$/.test(segment))) {
                 report({
                     message: `\`${key}\` does not use kebab-case.`,

package/lib/rules/common/registry-dependencies.js

@@ -3,21 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RegistryDependencies = void 0;
 const redocly_1 = require("../../redocly");
 const RegistryDependencies = () => {
-    let redoclyClient;
     let registryDependencies = new Set();
     return {
         DefinitionRoot: {
-            leave() {
-                redoclyClient = new redocly_1.RedoclyClient();
-                if (process.env.UPDATE_REGISTRY && redoclyClient.hasToken()) {
-                    redoclyClient.updateDependencies(Array.from(registryDependencies.keys()));
-                }
+            leave(_, ctx) {
+                const data = ctx.getVisitorData();
+                data.links = Array.from(registryDependencies);
             },
         },
         ref(node) {
             if (node.$ref) {
                 const link = node.$ref.split('#/')[0];
-                if (redocly_1.RedoclyClient.isRegistryURL(link)) {
+                if (redocly_1.isRedoclyRegistryURL(link)) {
                     registryDependencies.add(link);
                 }
             }

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

@@ -1,6 +1,8 @@
 import { Oas2Decorator, Oas2Rule } from '../../visitors';
 export declare const rules: {
     spec: Oas2Rule;
+    'no-invalid-schema-examples': any;
+    'no-invalid-parameter-examples': any;
     'info-description': Oas2Rule;
     'info-contact': Oas2Rule;
     'info-license': Oas2Rule;

package/lib/rules/oas2/index.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.decorators = exports.preprocessors = exports.rules = void 0;
 const spec_1 = require("../common/spec");
+const no_invalid_schema_examples_1 = require("../common/no-invalid-schema-examples");
+const no_invalid_parameter_examples_1 = require("../common/no-invalid-parameter-examples");
 const info_description_1 = require("../common/info-description");
 const info_contact_1 = require("../common/info-contact");
 const info_license_url_1 = require("../common/info-license-url");
@@ -42,6 +44,8 @@ const tag_description_override_1 = require("../common/tag-description-override")
 const info_description_override_1 = require("../common/info-description-override");
 exports.rules = {
     spec: spec_1.OasSpec,
+    'no-invalid-schema-examples': no_invalid_schema_examples_1.NoInvalidSchemaExamples,
+    'no-invalid-parameter-examples': no_invalid_parameter_examples_1.NoInvalidParameterExamples,
     'info-description': info_description_1.InfoDescription,
     'info-contact': info_contact_1.InfoContact,
     'info-license': info_license_url_1.InfoLicense,

package/lib/rules/oas3/index.js

@@ -48,6 +48,8 @@ const operation_description_override_1 = require("../common/operation-descriptio
 const tag_description_override_1 = require("../common/tag-description-override");
 const info_description_override_1 = require("../common/info-description-override");
 const path_excludes_patterns_1 = require("../common/path-excludes-patterns");
+const no_invalid_schema_examples_1 = require("../common/no-invalid-schema-examples");
+const no_invalid_parameter_examples_1 = require("../common/no-invalid-parameter-examples");
 exports.rules = {
     spec: spec_1.OasSpec,
     'info-description': info_description_1.InfoDescription,
@@ -93,6 +95,8 @@ exports.rules = {
     'request-mime-type': request_mime_type_1.RequestMimeType,
     'response-mime-type': response_mime_type_1.ResponseMimeType,
     'path-segment-plural': path_segment_plural_1.PathSegmentPlural,
+    'no-invalid-schema-examples': no_invalid_schema_examples_1.NoInvalidSchemaExamples,
+    'no-invalid-parameter-examples': no_invalid_parameter_examples_1.NoInvalidParameterExamples,
 };
 exports.preprocessors = {};
 exports.decorators = {