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

package/lib/lint.js

@@ -1,16 +1,22 @@
-import { rootRedoclyConfigSchema } from '@redocly/config';
-import { BaseResolver, resolveDocument, makeDocumentFromString } from './resolve.js';
-import { normalizeVisitors } from './visitors.js';
-import { walkDocument } from './walk.js';
-import { initRules } from './config/rules.js';
-import { normalizeTypes } from './types/index.js';
-import { releaseAjvInstance } from './rules/ajv.js';
-import { SpecVersion, getMajorSpecVersion, detectSpec, getTypes } from './oas-types.js';
-import { createConfigTypes } from './types/redocly-yaml.js';
-import { Struct } from './rules/common/struct.js';
-import { NoUnresolvedRefs } from './rules/no-unresolved-refs.js';
-export async function lint(opts) {
-    const { ref, externalRefResolver = new BaseResolver(opts.config.resolve) } = opts;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lint = lint;
+exports.lintFromString = lintFromString;
+exports.lintDocument = lintDocument;
+exports.lintConfig = lintConfig;
+const config_1 = require("@redocly/config");
+const resolve_1 = require("./resolve");
+const visitors_1 = require("./visitors");
+const walk_1 = require("./walk");
+const config_2 = require("./config");
+const types_1 = require("./types");
+const ajv_1 = require("./rules/ajv");
+const oas_types_1 = require("./oas-types");
+const redocly_yaml_1 = require("./types/redocly-yaml");
+const struct_1 = require("./rules/common/struct");
+const no_unresolved_refs_1 = require("./rules/no-unresolved-refs");
+async function lint(opts) {
+    const { ref, externalRefResolver = new resolve_1.BaseResolver(opts.config.resolve) } = opts;
     const document = (await externalRefResolver.resolveDocument(null, ref, true));
     opts.collectSpecData?.(document.parsed);
     return lintDocument({
@@ -20,9 +26,9 @@ export async function lint(opts) {
         config: opts.config.styleguide,
     });
 }
-export async function lintFromString(opts) {
-    const { source, absoluteRef, externalRefResolver = new BaseResolver(opts.config.resolve) } = opts;
-    const document = makeDocumentFromString(source, absoluteRef || '/');
+async function lintFromString(opts) {
+    const { source, absoluteRef, externalRefResolver = new resolve_1.BaseResolver(opts.config.resolve) } = opts;
+    const document = (0, resolve_1.makeDocumentFromString)(source, absoluteRef || '/');
     return lintDocument({
         document,
         ...opts,
@@ -30,42 +36,42 @@ export async function lintFromString(opts) {
         config: opts.config.styleguide,
     });
 }
-export async function lintDocument(opts) {
-    releaseAjvInstance(); // FIXME: preprocessors can modify nodes which are then cached to ajv-instance by absolute path
+async function lintDocument(opts) {
+    (0, ajv_1.releaseAjvInstance)(); // FIXME: preprocessors can modify nodes which are then cached to ajv-instance by absolute path
     const { document, customTypes, externalRefResolver, config } = opts;
-    const specVersion = detectSpec(document.parsed);
-    const specMajorVersion = getMajorSpecVersion(specVersion);
+    const specVersion = (0, oas_types_1.detectSpec)(document.parsed);
+    const specMajorVersion = (0, oas_types_1.getMajorSpecVersion)(specVersion);
     const rules = config.getRulesForSpecVersion(specMajorVersion);
-    const types = normalizeTypes(config.extendTypes(customTypes ?? getTypes(specVersion), specVersion), config);
+    const types = (0, types_1.normalizeTypes)(config.extendTypes(customTypes ?? (0, oas_types_1.getTypes)(specVersion), specVersion), config);
     const ctx = {
         problems: [],
         oasVersion: specVersion,
         visitorsData: {},
     };
-    const preprocessors = initRules(rules, config, 'preprocessors', specVersion);
-    const regularRules = initRules(rules, config, 'rules', specVersion);
-    let resolvedRefMap = await resolveDocument({
+    const preprocessors = (0, config_2.initRules)(rules, config, 'preprocessors', specVersion);
+    const regularRules = (0, config_2.initRules)(rules, config, 'rules', specVersion);
+    let resolvedRefMap = await (0, resolve_1.resolveDocument)({
         rootDocument: document,
         rootType: types.Root,
         externalRefResolver,
     });
     if (preprocessors.length > 0) {
         // Make additional pass to resolve refs defined in preprocessors.
-        walkDocument({
+        (0, walk_1.walkDocument)({
             document,
             rootType: types.Root,
-            normalizedVisitors: normalizeVisitors(preprocessors, types),
+            normalizedVisitors: (0, visitors_1.normalizeVisitors)(preprocessors, types),
             resolvedRefMap,
             ctx,
         });
-        resolvedRefMap = await resolveDocument({
+        resolvedRefMap = await (0, resolve_1.resolveDocument)({
             rootDocument: document,
             rootType: types.Root,
             externalRefResolver,
         });
     }
-    const normalizedVisitors = normalizeVisitors(regularRules, types);
-    walkDocument({
+    const normalizedVisitors = (0, visitors_1.normalizeVisitors)(regularRules, types);
+    (0, walk_1.walkDocument)({
         document,
         rootType: types.Root,
         normalizedVisitors,
@@ -74,34 +80,34 @@ export async function lintDocument(opts) {
     });
     return ctx.problems.map((problem) => config.addProblemToIgnore(problem));
 }
-export async function lintConfig(opts) {
-    const { document, severity, externalRefResolver = new BaseResolver(), config } = opts;
+async function lintConfig(opts) {
+    const { document, severity, externalRefResolver = new resolve_1.BaseResolver(), config } = opts;
     const ctx = {
         problems: [],
-        oasVersion: SpecVersion.OAS3_0,
+        oasVersion: oas_types_1.SpecVersion.OAS3_0,
         visitorsData: {},
     };
-    const types = normalizeTypes(opts.externalConfigTypes || createConfigTypes(rootRedoclyConfigSchema, config), { doNotResolveExamples: config.styleguide.doNotResolveExamples });
+    const types = (0, types_1.normalizeTypes)(opts.externalConfigTypes || (0, redocly_yaml_1.createConfigTypes)(config_1.rootRedoclyConfigSchema, config), { doNotResolveExamples: config.styleguide.doNotResolveExamples });
     const rules = [
         {
             severity: severity || 'error',
             ruleId: 'configuration spec',
-            visitor: Struct({ severity: 'error' }),
+            visitor: (0, struct_1.Struct)({ severity: 'error' }),
         },
         {
             severity: severity || 'error',
             ruleId: 'configuration no-unresolved-refs',
-            visitor: NoUnresolvedRefs({ severity: 'error' }),
+            visitor: (0, no_unresolved_refs_1.NoUnresolvedRefs)({ severity: 'error' }),
         },
     ];
-    const normalizedVisitors = normalizeVisitors(rules, types);
+    const normalizedVisitors = (0, visitors_1.normalizeVisitors)(rules, types);
     const resolvedRefMap = opts.resolvedRefMap ||
-        (await resolveDocument({
+        (await (0, resolve_1.resolveDocument)({
             rootDocument: document,
             rootType: types.ConfigRoot,
             externalRefResolver,
         }));
-    walkDocument({
+    (0, walk_1.walkDocument)({
         document,
         rootType: types.ConfigRoot,
         normalizedVisitors,
@@ -110,4 +116,3 @@ export async function lintConfig(opts) {
     });
     return ctx.problems;
 }
-//# sourceMappingURL=lint.js.map

package/lib/logger.d.ts

@@ -4,11 +4,10 @@ export declare const colorOptions: {
 };
 export declare const colorize: typeof colorette;
 declare class Logger {
+    protected stderr(str: string): boolean;
     info(str: string): boolean | void;
     warn(str: string): boolean | void;
     error(str: string): boolean | void;
-    output(str: string): boolean | void;
 }
 export declare const logger: Logger;
 export {};
-//# sourceMappingURL=logger.d.ts.map

package/lib/logger.js

@@ -1,30 +1,32 @@
-import * as colorette from 'colorette';
-import { isBrowser } from './env.js';
-import { identity } from './utils.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.colorize = exports.colorOptions = void 0;
+const colorette = require("colorette");
+const env_1 = require("./env");
+const utils_1 = require("./utils");
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore this works but some types are not working
-export const colorOptions = colorette.options;
-export const colorize = new Proxy(colorette, {
+exports.colorOptions = colorette.options;
+exports.colorize = new Proxy(colorette, {
     get(target, prop) {
-        if (isBrowser) {
-            return identity;
+        if (env_1.isBrowser) {
+            return utils_1.identity;
         }
         return target[prop];
     },
 });
 class Logger {
+    stderr(str) {
+        return process.stderr.write(str);
+    }
     info(str) {
-        return isBrowser ? console.info(str) : process.stderr.write(str);
+        return env_1.isBrowser ? console.log(str) : this.stderr(str);
     }
     warn(str) {
-        return isBrowser ? console.warn(str) : process.stderr.write(colorize.yellow(str));
+        return env_1.isBrowser ? console.warn(str) : this.stderr(exports.colorize.yellow(str));
     }
     error(str) {
-        return isBrowser ? console.error(str) : process.stderr.write(colorize.red(str));
-    }
-    output(str) {
-        return isBrowser ? console.info(str) : process.stdout.write(str);
+        return env_1.isBrowser ? console.error(str) : this.stderr(exports.colorize.red(str));
     }
 }
-export const logger = new Logger();
-//# sourceMappingURL=logger.js.map
+exports.logger = new Logger();

package/lib/oas-types.d.ts

@@ -1,5 +1,5 @@
-import type { BuiltInAsync2RuleId, BuiltInAsync3RuleId, BuiltInArazzo1RuleId, BuiltInOAS2RuleId, BuiltInOAS3RuleId, BuiltInOverlay1RuleId } from './types/redocly-yaml.js';
-import type { Oas3Rule, Oas3Preprocessor, Oas2Rule, Oas2Preprocessor, Async2Preprocessor, Async2Rule, Async3Preprocessor, Async3Rule, Arazzo1Preprocessor, Arazzo1Rule, Overlay1Preprocessor, Overlay1Rule } from './visitors.js';
+import type { BuiltInAsync2RuleId, BuiltInAsync3RuleId, BuiltInArazzo1RuleId, BuiltInOAS2RuleId, BuiltInOAS3RuleId, BuiltInOverlay1RuleId } from './types/redocly-yaml';
+import type { Oas3Rule, Oas3Preprocessor, Oas2Rule, Oas2Preprocessor, Async2Preprocessor, Async2Rule, Async3Preprocessor, Async3Rule, Arazzo1Preprocessor, Arazzo1Rule, Overlay1Preprocessor, Overlay1Rule } from './visitors';
 export declare enum SpecVersion {
     OAS2 = "oas2",
     OAS3_0 = "oas3_0",
@@ -38,5 +38,4 @@ export type Arazzo1DecoratorsSet = Record<string, Arazzo1Preprocessor>;
 export type Overlay1DecoratorsSet = Record<string, Overlay1Preprocessor>;
 export declare function detectSpec(root: unknown): SpecVersion;
 export declare function getMajorSpecVersion(version: SpecVersion): SpecMajorVersion;
-export declare function getTypes(spec: SpecVersion): Record<string, import("./index.js").NodeType> | Record<"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", import("./index.js").NodeType> | Record<"Root" | "Tag" | "TagList" | "ExternalDocs" | "SecurityRequirement" | "SecurityRequirementList" | "Info" | "Contact" | "License" | "Paths" | "PathItem" | "Parameter" | "ParameterList" | "Operation" | "Example" | "ExamplesMap" | "Header" | "Responses" | "Response" | "Schema" | "Xml" | "SchemaProperties" | "NamedSchemas" | "NamedResponses" | "NamedParameters" | "NamedSecuritySchemes" | "SecurityScheme" | "TagGroup" | "TagGroups" | "EnumDescriptions" | "Logo" | "XCodeSample" | "XCodeSampleList" | "Server" | "ServerList" | "ServerVariable" | "ServerVariablesMap" | "Callback" | "CallbacksMap" | "RequestBody" | "MediaTypesMap" | "MediaType" | "Encoding" | "EncodingMap" | "HeadersMap" | "Link" | "LinksMap" | "DiscriminatorMapping" | "Discriminator" | "Components" | "NamedExamples" | "NamedRequestBodies" | "NamedHeaders" | "NamedLinks" | "NamedCallbacks" | "ImplicitFlow" | "PasswordFlow" | "ClientCredentials" | "AuthorizationCode" | "OAuth2Flows" | "XUsePkce" | "WebhooksMap", import("./index.js").NodeType> | Record<"Root" | "Info" | "License" | "Operation" | "Schema" | "SchemaProperties" | "SecurityScheme" | "Components" | "PatternProperties" | "NamedPathItems" | "DependentRequired", import("./index.js").NodeType>;
-//# sourceMappingURL=oas-types.d.ts.map
+export declare function getTypes(spec: SpecVersion): Record<string, import("./types").NodeType> | Record<"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", import("./types").NodeType> | Record<"Root" | "Tag" | "TagList" | "ExternalDocs" | "SecurityRequirement" | "SecurityRequirementList" | "Info" | "Contact" | "License" | "Paths" | "PathItem" | "Parameter" | "ParameterList" | "Operation" | "Example" | "ExamplesMap" | "Header" | "Responses" | "Response" | "Schema" | "Xml" | "SchemaProperties" | "NamedSchemas" | "NamedResponses" | "NamedParameters" | "NamedSecuritySchemes" | "SecurityScheme" | "TagGroup" | "TagGroups" | "EnumDescriptions" | "Logo" | "XCodeSample" | "XCodeSampleList" | "Server" | "ServerList" | "ServerVariable" | "ServerVariablesMap" | "Callback" | "CallbacksMap" | "RequestBody" | "MediaTypesMap" | "MediaType" | "Encoding" | "EncodingMap" | "HeadersMap" | "Link" | "LinksMap" | "DiscriminatorMapping" | "Discriminator" | "Components" | "NamedExamples" | "NamedRequestBodies" | "NamedHeaders" | "NamedLinks" | "NamedCallbacks" | "ImplicitFlow" | "PasswordFlow" | "ClientCredentials" | "AuthorizationCode" | "OAuth2Flows" | "XUsePkce" | "WebhooksMap", import("./types").NodeType> | Record<"Root" | "Info" | "License" | "Operation" | "Schema" | "SchemaProperties" | "SecurityScheme" | "Components" | "PatternProperties" | "NamedPathItems" | "DependentRequired", import("./types").NodeType>;

package/lib/oas-types.js

@@ -1,13 +1,19 @@
-import { Oas2Types } from './types/oas2.js';
-import { Oas3Types } from './types/oas3.js';
-import { Oas3_1Types } from './types/oas3_1.js';
-import { AsyncApi2Types } from './types/asyncapi2.js';
-import { AsyncApi3Types } from './types/asyncapi3.js';
-import { Arazzo1Types } from './types/arazzo.js';
-import { Overlay1Types } from './types/overlay.js';
-import { isPlainObject } from './utils.js';
-import { VERSION_PATTERN } from './typings/arazzo.js';
-export var SpecVersion;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpecMajorVersion = exports.SpecVersion = void 0;
+exports.detectSpec = detectSpec;
+exports.getMajorSpecVersion = getMajorSpecVersion;
+exports.getTypes = getTypes;
+const oas2_1 = require("./types/oas2");
+const oas3_1 = require("./types/oas3");
+const oas3_1_1 = require("./types/oas3_1");
+const asyncapi2_1 = require("./types/asyncapi2");
+const asyncapi3_1 = require("./types/asyncapi3");
+const arazzo_1 = require("./types/arazzo");
+const overlay_1 = require("./types/overlay");
+const utils_1 = require("./utils");
+const arazzo_2 = require("./typings/arazzo");
+var SpecVersion;
 (function (SpecVersion) {
     SpecVersion["OAS2"] = "oas2";
     SpecVersion["OAS3_0"] = "oas3_0";
@@ -16,8 +22,8 @@ export var SpecVersion;
     SpecVersion["Async3"] = "async3";
     SpecVersion["Arazzo1"] = "arazzo1";
     SpecVersion["Overlay1"] = "overlay1";
-})(SpecVersion || (SpecVersion = {}));
-export var SpecMajorVersion;
+})(SpecVersion || (exports.SpecVersion = SpecVersion = {}));
+var SpecMajorVersion;
 (function (SpecMajorVersion) {
     SpecMajorVersion["OAS2"] = "oas2";
     SpecMajorVersion["OAS3"] = "oas3";
@@ -25,18 +31,18 @@ export var SpecMajorVersion;
     SpecMajorVersion["Async3"] = "async3";
     SpecMajorVersion["Arazzo1"] = "arazzo1";
     SpecMajorVersion["Overlay1"] = "overlay1";
-})(SpecMajorVersion || (SpecMajorVersion = {}));
+})(SpecMajorVersion || (exports.SpecMajorVersion = SpecMajorVersion = {}));
 const typesMap = {
-    [SpecVersion.OAS2]: Oas2Types,
-    [SpecVersion.OAS3_0]: Oas3Types,
-    [SpecVersion.OAS3_1]: Oas3_1Types,
-    [SpecVersion.Async2]: AsyncApi2Types,
-    [SpecVersion.Async3]: AsyncApi3Types,
-    [SpecVersion.Arazzo1]: Arazzo1Types,
-    [SpecVersion.Overlay1]: Overlay1Types,
+    [SpecVersion.OAS2]: oas2_1.Oas2Types,
+    [SpecVersion.OAS3_0]: oas3_1.Oas3Types,
+    [SpecVersion.OAS3_1]: oas3_1_1.Oas3_1Types,
+    [SpecVersion.Async2]: asyncapi2_1.AsyncApi2Types,
+    [SpecVersion.Async3]: asyncapi3_1.AsyncApi3Types,
+    [SpecVersion.Arazzo1]: arazzo_1.Arazzo1Types,
+    [SpecVersion.Overlay1]: overlay_1.Overlay1Types,
 };
-export function detectSpec(root) {
-    if (!isPlainObject(root)) {
+function detectSpec(root) {
+    if (!(0, utils_1.isPlainObject)(root)) {
         throw new Error(`Document must be JSON object, got ${typeof root}`);
     }
     if (root.openapi && typeof root.openapi !== 'string') {
@@ -63,15 +69,15 @@ export function detectSpec(root) {
     if (root.asyncapi) {
         throw new Error(`Unsupported AsyncAPI version: ${root.asyncapi}`);
     }
-    if (typeof root.arazzo === 'string' && VERSION_PATTERN.test(root.arazzo)) {
+    if (typeof root.arazzo === 'string' && arazzo_2.VERSION_PATTERN.test(root.arazzo)) {
         return SpecVersion.Arazzo1;
     }
-    if (typeof root.overlay === 'string' && VERSION_PATTERN.test(root.overlay)) {
+    if (typeof root.overlay === 'string' && arazzo_2.VERSION_PATTERN.test(root.overlay)) {
         return SpecVersion.Overlay1;
     }
     throw new Error(`Unsupported specification`);
 }
-export function getMajorSpecVersion(version) {
+function getMajorSpecVersion(version) {
     if (version === SpecVersion.OAS2) {
         return SpecMajorVersion.OAS2;
     }
@@ -91,7 +97,6 @@ export function getMajorSpecVersion(version) {
         return SpecMajorVersion.OAS3;
     }
 }
-export function getTypes(spec) {
+function getTypes(spec) {
     return typesMap[spec];
 }
-//# sourceMappingURL=oas-types.js.map

package/lib/output.d.ts

@@ -0,0 +1,3 @@
+export declare const output: {
+    write(str: string): boolean | undefined;
+};

package/lib/output.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.output = void 0;
+const env_1 = require("./env");
+exports.output = {
+    write(str) {
+        return env_1.isBrowser ? undefined : process.stdout.write(str);
+    },
+};

package/lib/redocly/domains.d.ts

@@ -0,0 +1,14 @@
+import type { Region } from '../config/types';
+export declare const DEFAULT_REGION = "us";
+export declare const DOMAINS: {
+    us: string;
+    eu: string;
+};
+export declare const AVAILABLE_REGIONS: Region[];
+export declare function getDomains(): {
+    us: string;
+    eu: string;
+};
+export declare function setRedoclyDomain(domain: string): void;
+export declare function getRedoclyDomain(): string;
+export declare function isRedoclyRegistryURL(link: string): boolean;

package/lib/redocly/domains.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AVAILABLE_REGIONS = exports.DOMAINS = exports.DEFAULT_REGION = void 0;
+exports.getDomains = getDomains;
+exports.setRedoclyDomain = setRedoclyDomain;
+exports.getRedoclyDomain = getRedoclyDomain;
+exports.isRedoclyRegistryURL = isRedoclyRegistryURL;
+let redoclyDomain = 'redocly.com';
+exports.DEFAULT_REGION = 'us';
+exports.DOMAINS = getDomains();
+exports.AVAILABLE_REGIONS = Object.keys(exports.DOMAINS);
+function getDomains() {
+    const domains = {
+        us: 'redocly.com',
+        eu: 'eu.redocly.com',
+    };
+    // FIXME: temporary fix for our lab environments
+    const domain = redoclyDomain;
+    if (domain?.endsWith('.redocly.host')) {
+        domains[domain.split('.')[0]] = domain;
+    }
+    if (domain === 'redoc.online') {
+        domains[domain] = domain;
+    }
+    return domains;
+}
+function setRedoclyDomain(domain) {
+    redoclyDomain = domain;
+}
+function getRedoclyDomain() {
+    return redoclyDomain;
+}
+function isRedoclyRegistryURL(link) {
+    const domain = getRedoclyDomain() || exports.DOMAINS[exports.DEFAULT_REGION];
+    const legacyDomain = domain === 'redocly.com' ? 'redoc.ly' : domain;
+    if (!link.startsWith(`https://api.${domain}/registry/`) &&
+        !link.startsWith(`https://api.${legacyDomain}/registry/`)) {
+        return false;
+    }
+    return true;
+}

package/lib/redocly/index.d.ts

@@ -0,0 +1,30 @@
+import { RegistryApi } from './registry-api';
+import type { RegionalToken, RegionalTokenWithValidity } from './redocly-client-types';
+import type { AccessTokens, Region } from '../config/types';
+export declare const TOKEN_FILENAME = ".redocly-config.json";
+export declare class RedoclyClient {
+    private accessTokens;
+    private region;
+    domain: string;
+    registryApi: RegistryApi;
+    constructor(region?: Region);
+    loadRegion(region?: Region): Region;
+    getRegion(): Region;
+    hasTokens(): boolean;
+    hasToken(): boolean;
+    getAuthorizationHeader(): Promise<string | undefined>;
+    setAccessTokens(accessTokens: AccessTokens): void;
+    loadTokens(): void;
+    getAllTokens(): RegionalToken[];
+    getValidTokens(): Promise<RegionalTokenWithValidity[]>;
+    getTokens(): Promise<RegionalTokenWithValidity[]>;
+    isAuthorizedWithRedoclyByRegion(): Promise<boolean>;
+    isAuthorizedWithRedocly(): Promise<boolean>;
+    readCredentialsFile(credentialsPath: string): any;
+    verifyToken(accessToken: string, verbose?: boolean): Promise<{
+        viewerId: string;
+        organizations: string[];
+    }>;
+    login(accessToken: string, verbose?: boolean): Promise<void>;
+    logout(): void;
+}

package/lib/redocly/index.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedoclyClient = exports.TOKEN_FILENAME = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const registry_api_1 = require("./registry-api");
+const env_1 = require("../env");
+const utils_1 = require("../utils");
+const logger_1 = require("../logger");
+const domains_1 = require("./domains");
+exports.TOKEN_FILENAME = '.redocly-config.json';
+class RedoclyClient {
+    constructor(region) {
+        this.accessTokens = {};
+        this.region = this.loadRegion(region);
+        this.loadTokens();
+        this.domain = region ? domains_1.DOMAINS[region] : env_1.env.REDOCLY_DOMAIN || domains_1.DOMAINS[domains_1.DEFAULT_REGION];
+        (0, domains_1.setRedoclyDomain)(this.domain);
+        this.registryApi = new registry_api_1.RegistryApi(this.accessTokens, this.region);
+    }
+    loadRegion(region) {
+        if (region && !domains_1.DOMAINS[region]) {
+            throw new Error(`Invalid argument: region in config file.\nGiven: ${logger_1.colorize.green(region)}, choices: "us", "eu".`);
+        }
+        if ((0, domains_1.getRedoclyDomain)()) {
+            return (domains_1.AVAILABLE_REGIONS.find((region) => domains_1.DOMAINS[region] === (0, domains_1.getRedoclyDomain)()) || domains_1.DEFAULT_REGION);
+        }
+        return region || domains_1.DEFAULT_REGION;
+    }
+    getRegion() {
+        return this.region;
+    }
+    hasTokens() {
+        return (0, utils_1.isNotEmptyObject)(this.accessTokens);
+    }
+    // <backward compatibility: old versions of portal>
+    hasToken() {
+        return !!this.accessTokens[this.region];
+    }
+    async getAuthorizationHeader() {
+        return this.accessTokens[this.region];
+    }
+    // </backward compatibility: portal>
+    setAccessTokens(accessTokens) {
+        this.accessTokens = accessTokens;
+    }
+    loadTokens() {
+        const credentialsPath = (0, path_1.resolve)((0, os_1.homedir)(), exports.TOKEN_FILENAME);
+        const credentials = this.readCredentialsFile(credentialsPath);
+        if ((0, utils_1.isNotEmptyObject)(credentials)) {
+            this.setAccessTokens({
+                ...credentials,
+                ...(credentials.token &&
+                    !credentials[this.region] && {
+                    [this.region]: credentials.token,
+                }),
+            });
+        }
+        if (env_1.env.REDOCLY_AUTHORIZATION) {
+            this.setAccessTokens({
+                ...this.accessTokens,
+                [this.region]: env_1.env.REDOCLY_AUTHORIZATION,
+            });
+        }
+    }
+    getAllTokens() {
+        return Object.entries(this.accessTokens)
+            .filter(([region]) => domains_1.AVAILABLE_REGIONS.includes(region))
+            .map(([region, token]) => ({ region, token }));
+    }
+    async getValidTokens() {
+        const allTokens = this.getAllTokens();
+        const verifiedTokens = await Promise.allSettled(allTokens.map(({ token }) => this.verifyToken(token)));
+        return allTokens
+            .filter((_, index) => verifiedTokens[index].status === 'fulfilled')
+            .map(({ token, region }) => ({ token, region, valid: true }));
+    }
+    async getTokens() {
+        return this.hasTokens() ? await this.getValidTokens() : [];
+    }
+    async isAuthorizedWithRedoclyByRegion() {
+        if (!this.hasTokens()) {
+            return false;
+        }
+        const accessToken = this.accessTokens[this.region];
+        if (!accessToken) {
+            return false;
+        }
+        try {
+            await this.verifyToken(accessToken);
+            return true;
+        }
+        catch (err) {
+            return false;
+        }
+    }
+    async isAuthorizedWithRedocly() {
+        return this.hasTokens() && (0, utils_1.isNotEmptyArray)(await this.getValidTokens());
+    }
+    readCredentialsFile(credentialsPath) {
+        return (0, fs_1.existsSync)(credentialsPath) ? JSON.parse((0, fs_1.readFileSync)(credentialsPath, 'utf-8')) : {};
+    }
+    async verifyToken(accessToken, verbose = false) {
+        return this.registryApi.authStatus(accessToken, verbose);
+    }
+    async login(accessToken, verbose = false) {
+        const credentialsPath = (0, path_1.resolve)((0, os_1.homedir)(), exports.TOKEN_FILENAME);
+        try {
+            await this.verifyToken(accessToken, verbose);
+        }
+        catch (err) {
+            throw new Error('Authorization failed. Please check if you entered a valid API key.');
+        }
+        const credentials = {
+            ...this.readCredentialsFile(credentialsPath),
+            [this.region]: accessToken,
+            token: accessToken, // FIXME: backward compatibility, remove on 1.0.0
+        };
+        this.accessTokens = credentials;
+        this.registryApi.setAccessTokens(credentials);
+        (0, fs_1.writeFileSync)(credentialsPath, JSON.stringify(credentials, null, 2));
+    }
+    logout() {
+        const credentialsPath = (0, path_1.resolve)((0, os_1.homedir)(), exports.TOKEN_FILENAME);
+        if ((0, fs_1.existsSync)(credentialsPath)) {
+            (0, fs_1.unlinkSync)(credentialsPath);
+        }
+    }
+}
+exports.RedoclyClient = RedoclyClient;

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

@@ -0,0 +1,8 @@
+import type { Region } from '../config/types';
+export interface RegionalToken {
+    region: Region;
+    token: string;
+}
+export interface RegionalTokenWithValidity extends RegionalToken {
+    valid: boolean;
+}

package/lib/redocly/redocly-client-types.js

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

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

@@ -0,0 +1,29 @@
+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;
+    isPublic?: boolean;
+    batchId?: string;
+    batchSize?: number;
+}
+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,17 @@
+import type { PrepareFileuploadOKResponse, PrepareFileuploadParams, PushApiParams } from './registry-api-types';
+import type { AccessTokens, Region } from '../config/types';
+export declare class RegistryApi {
+    private accessTokens;
+    private region;
+    constructor(accessTokens: AccessTokens, region: Region);
+    get accessToken(): string | false | undefined;
+    getBaseUrl(): string;
+    setAccessTokens(accessTokens: AccessTokens): this;
+    private request;
+    authStatus(accessToken: string, verbose?: boolean): Promise<{
+        viewerId: string;
+        organizations: string[];
+    }>;
+    prepareFileUpload({ organizationId, name, version, filesHash, filename, isUpsert, }: PrepareFileuploadParams): Promise<PrepareFileuploadOKResponse>;
+    pushApi({ organizationId, name, version, rootFilePath, filePaths, branch, isUpsert, isPublic, batchId, batchSize, }: PushApiParams): Promise<void>;
+}