@redocly/openapi-core 1.0.0-rc.3 → 1.0.1

package/src/index.ts

@@ -0,0 +1,71 @@
+export { BundleOutputFormat, readFileFromUrl, slash, doesYamlFileExist, isTruthy } from './utils';
+export { Oas3_1Types } from './types/oas3_1';
+export { Oas3Types } from './types/oas3';
+export { Oas2Types } from './types/oas2';
+export { ConfigTypes } from './types/redocly-yaml';
+export type {
+  Oas3Definition,
+  Oas3_1Definition,
+  Oas3Components,
+  Oas3PathItem,
+  Oas3Paths,
+  Oas3ComponentName,
+  Oas3Schema,
+  Oas3_1Schema,
+  Oas3Tag,
+  Oas3_1Webhooks,
+  Referenced,
+  OasRef,
+} from './typings/openapi';
+export type { Oas2Definition } from './typings/swagger';
+export type { StatsAccumulator, StatsName } from './typings/common';
+export { normalizeTypes } from './types';
+export { Stats } from './rules/other/stats';
+
+export {
+  Config,
+  StyleguideConfig,
+  RawConfig,
+  IGNORE_FILE,
+  Region,
+  getMergedConfig,
+  transformConfig,
+  loadConfig,
+  getConfig,
+  findConfig,
+  CONFIG_FILE_NAMES,
+  RuleSeverity,
+  createConfig,
+  ResolvedApi,
+} from './config';
+
+export { RedoclyClient, isRedoclyRegistryURL } from './redocly';
+
+export {
+  Source,
+  BaseResolver,
+  Document,
+  resolveDocument,
+  ResolveError,
+  YamlParseError,
+  makeDocumentFromString,
+} from './resolve';
+export { parseYaml, stringifyYaml } from './js-yaml';
+export { unescapePointer, isRef, isAbsoluteUrl } from './ref-utils';
+export { detectOpenAPI, OasMajorVersion, openAPIMajor, OasVersion } from './oas-types';
+export { normalizeVisitors } from './visitors';
+
+export {
+  WalkContext,
+  walkDocument,
+  NormalizedProblem,
+  ProblemSeverity,
+  LineColLocationObject,
+  LocationObject,
+  Loc,
+} from './walk';
+
+export { getAstNodeByPointer, getLineColLocation } from './format/codeframes';
+export { formatProblems, OutputFormat, getTotals, Totals } from './format/format';
+export { lint, lint as validate, lintDocument, lintFromString, lintConfig } from './lint';
+export { bundle, bundleDocument, mapTypeToComponent } from './bundle';

package/src/js-yaml/index.ts

@@ -0,0 +1,14 @@
+// TODO: add a type for "types" https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/js-yaml/index.d.ts
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+import { JSON_SCHEMA, types, LoadOptions, DumpOptions, load, dump } from 'js-yaml';
+
+const DEFAULT_SCHEMA_WITHOUT_TIMESTAMP = JSON_SCHEMA.extend({
+  implicit: [types.merge],
+  explicit: [types.binary, types.omap, types.pairs, types.set],
+});
+
+export const parseYaml = (str: string, opts?: LoadOptions): unknown =>
+  load(str, { schema: DEFAULT_SCHEMA_WITHOUT_TIMESTAMP, ...opts });
+
+export const stringifyYaml = (obj: any, opts?: DumpOptions): string => dump(obj, opts);

package/src/lint.ts

@@ -0,0 +1,148 @@
+import { BaseResolver, resolveDocument, Document, makeDocumentFromString } from './resolve';
+import { normalizeVisitors } from './visitors';
+import { Oas3_1Types } from './types/oas3_1';
+import { Oas3Types } from './types/oas3';
+import { Oas2Types } from './types/oas2';
+import { NodeType } from './types';
+import { ProblemSeverity, WalkContext, walkDocument } from './walk';
+import { StyleguideConfig, Config, initRules, defaultPlugin, resolvePlugins } from './config';
+import { normalizeTypes } from './types';
+import { releaseAjvInstance } from './rules/ajv';
+import { detectOpenAPI, Oas3RuleSet, OasMajorVersion, OasVersion, openAPIMajor } from './oas-types';
+import { ConfigTypes } from './types/redocly-yaml';
+import { OasSpec } from './rules/common/spec';
+
+export async function lint(opts: {
+  ref: string;
+  config: Config;
+  externalRefResolver?: BaseResolver;
+}) {
+  const { ref, externalRefResolver = new BaseResolver(opts.config.resolve) } = opts;
+  const document = (await externalRefResolver.resolveDocument(null, ref, true)) as Document;
+
+  return lintDocument({
+    document,
+    ...opts,
+    externalRefResolver,
+    config: opts.config.styleguide,
+  });
+}
+
+export async function lintFromString(opts: {
+  source: string;
+  absoluteRef?: string;
+  config: Config;
+  externalRefResolver?: BaseResolver;
+}) {
+  const { source, absoluteRef, externalRefResolver = new BaseResolver(opts.config.resolve) } = opts;
+  const document = makeDocumentFromString(source, absoluteRef || '/');
+
+  return lintDocument({
+    document,
+    ...opts,
+    externalRefResolver,
+    config: opts.config.styleguide,
+  });
+}
+
+export async function lintDocument(opts: {
+  document: Document;
+  config: StyleguideConfig;
+  customTypes?: Record<string, NodeType>;
+  externalRefResolver: BaseResolver;
+}) {
+  releaseAjvInstance(); // FIXME: preprocessors can modify nodes which are then cached to ajv-instance by absolute path
+
+  const { document, customTypes, externalRefResolver, config } = opts;
+  const oasVersion = detectOpenAPI(document.parsed);
+  const oasMajorVersion = openAPIMajor(oasVersion);
+  const rules = config.getRulesForOasVersion(oasMajorVersion);
+  const types = normalizeTypes(
+    config.extendTypes(
+      customTypes ?? oasMajorVersion === OasMajorVersion.Version3
+        ? oasVersion === OasVersion.Version3_1
+          ? Oas3_1Types
+          : Oas3Types
+        : Oas2Types,
+      oasVersion
+    ),
+    config
+  );
+
+  const ctx: WalkContext = {
+    problems: [],
+    oasVersion: oasVersion,
+    visitorsData: {},
+  };
+
+  const preprocessors = initRules(rules as any, config, 'preprocessors', oasVersion);
+  const regularRules = initRules(rules as Oas3RuleSet[], config, 'rules', oasVersion);
+
+  let resolvedRefMap = await resolveDocument({
+    rootDocument: document,
+    rootType: types.Root,
+    externalRefResolver,
+  });
+
+  if (preprocessors.length > 0) {
+    // Make additional pass to resolve refs defined in preprocessors.
+    walkDocument({
+      document,
+      rootType: types.Root,
+      normalizedVisitors: normalizeVisitors(preprocessors, types),
+      resolvedRefMap,
+      ctx,
+    });
+    resolvedRefMap = await resolveDocument({
+      rootDocument: document,
+      rootType: types.Root,
+      externalRefResolver,
+    });
+  }
+
+  const normalizedVisitors = normalizeVisitors(regularRules, types);
+
+  walkDocument({
+    document,
+    rootType: types.Root,
+    normalizedVisitors,
+    resolvedRefMap,
+    ctx,
+  });
+  return ctx.problems.map((problem) => config.addProblemToIgnore(problem));
+}
+
+export async function lintConfig(opts: { document: Document; severity?: ProblemSeverity }) {
+  const { document, severity } = opts;
+
+  const ctx: WalkContext = {
+    problems: [],
+    oasVersion: OasVersion.Version3_0,
+    visitorsData: {},
+  };
+  const plugins = resolvePlugins([defaultPlugin]);
+  const config = new StyleguideConfig({
+    plugins,
+    rules: { spec: 'error' },
+  });
+
+  const types = normalizeTypes(ConfigTypes, config);
+  const rules = [
+    {
+      severity: severity || 'error',
+      ruleId: 'configuration spec',
+      visitor: OasSpec({ severity: 'error' }),
+    },
+  ];
+  const normalizedVisitors = normalizeVisitors(rules, types);
+
+  walkDocument({
+    document,
+    rootType: types.ConfigRoot,
+    normalizedVisitors,
+    resolvedRefMap: new Map(),
+    ctx,
+  });
+
+  return ctx.problems;
+}

package/src/logger.ts

@@ -0,0 +1,34 @@
+import * as colorette from 'colorette';
+export { options as colorOptions } from 'colorette';
+
+import { isBrowser } from './env';
+import { identity } from './utils';
+
+export const colorize = new Proxy(colorette, {
+  get(target: typeof colorette, prop: string): typeof identity {
+    if (isBrowser) {
+      return identity;
+    }
+
+    return (target as any)[prop];
+  },
+});
+class Logger {
+  protected stderr(str: string) {
+    return process.stderr.write(str);
+  }
+
+  info(str: string) {
+    return isBrowser ? console.log(str) : this.stderr(str);
+  }
+
+  warn(str: string) {
+    return isBrowser ? console.warn(str) : this.stderr(colorize.yellow(str));
+  }
+
+  error(str: string) {
+    return isBrowser ? console.error(str) : this.stderr(colorize.red(str));
+  }
+}
+
+export const logger = new Logger();

package/src/oas-types.ts

@@ -0,0 +1,57 @@
+import { Oas3Rule, Oas3Preprocessor, Oas2Rule, Oas2Preprocessor } from './visitors';
+
+export type RuleSet<T> = Record<string, T>;
+
+export enum OasVersion {
+  Version2 = 'oas2',
+  Version3_0 = 'oas3_0',
+  Version3_1 = 'oas3_1',
+}
+
+export enum OasMajorVersion {
+  Version2 = 'oas2',
+  Version3 = 'oas3',
+}
+
+export type Oas3RuleSet = Record<string, Oas3Rule>;
+export type Oas2RuleSet = Record<string, Oas2Rule>;
+export type Oas3PreprocessorsSet = Record<string, Oas3Preprocessor>;
+export type Oas2PreprocessorsSet = Record<string, Oas2Preprocessor>;
+export type Oas3DecoratorsSet = Record<string, Oas3Preprocessor>;
+export type Oas2DecoratorsSet = Record<string, Oas2Preprocessor>;
+
+export function detectOpenAPI(root: any): OasVersion {
+  if (typeof root !== 'object') {
+    throw new Error(`Document must be JSON object, got ${typeof root}`);
+  }
+
+  if (!(root.openapi || root.swagger)) {
+    throw new Error('This doesn’t look like an OpenAPI document.\n');
+  }
+
+  if (root.openapi && typeof root.openapi !== 'string') {
+    throw new Error(`Invalid OpenAPI version: should be a string but got "${typeof root.openapi}"`);
+  }
+
+  if (root.openapi && root.openapi.startsWith('3.0')) {
+    return OasVersion.Version3_0;
+  }
+
+  if (root.openapi && root.openapi.startsWith('3.1')) {
+    return OasVersion.Version3_1;
+  }
+
+  if (root.swagger && root.swagger === '2.0') {
+    return OasVersion.Version2;
+  }
+
+  throw new Error(`Unsupported OpenAPI Version: ${root.openapi || root.swagger}`);
+}
+
+export function openAPIMajor(version: OasVersion): OasMajorVersion {
+  if (version === OasVersion.Version2) {
+    return OasMajorVersion.Version2;
+  } else {
+    return OasMajorVersion.Version3;
+  }
+}

package/src/output.ts

@@ -0,0 +1,7 @@
+import { isBrowser } from './env';
+
+export const output = {
+  write(str: string) {
+    return isBrowser ? undefined : process.stdout.write(str);
+  },
+};

package/src/redocly/__tests__/redocly-client.test.ts

@@ -0,0 +1,146 @@
+import { RedoclyClient } from '../index';
+
+jest.mock('node-fetch', () => ({
+  default: jest.fn(() => ({
+    ok: true,
+    json: jest.fn().mockResolvedValue({}),
+  })),
+}));
+
+describe('RedoclyClient', () => {
+  const REDOCLY_DOMAIN_US = 'redocly.com';
+  const REDOCLY_DOMAIN_EU = 'eu.redocly.com';
+  const REDOCLY_AUTHORIZATION_TOKEN = 'redocly-auth-token';
+  const testRedoclyDomain = 'redoclyDomain.com';
+  const testToken = 'test-token';
+
+  afterEach(() => {
+    delete process.env.REDOCLY_DOMAIN;
+  });
+
+  it('should resolve the US domain by default', () => {
+    const client = new RedoclyClient();
+    expect(client.domain).toBe(REDOCLY_DOMAIN_US);
+  });
+
+  it('should resolve domain from RedoclyDomain env', () => {
+    process.env.REDOCLY_DOMAIN = testRedoclyDomain;
+    const client = new RedoclyClient();
+    expect(client.domain).toBe(testRedoclyDomain);
+  });
+
+  it('should resolve a domain by US region', () => {
+    const client = new RedoclyClient('us');
+    expect(client.domain).toBe(REDOCLY_DOMAIN_US);
+  });
+
+  it('should resolve a domain by EU region', () => {
+    const client = new RedoclyClient('eu');
+    expect(client.domain).toBe(REDOCLY_DOMAIN_EU);
+  });
+
+  it('should resolve domain by EU region prioritizing flag over env variable', () => {
+    process.env.REDOCLY_DOMAIN = testRedoclyDomain;
+    const client = new RedoclyClient('eu');
+    expect(client.domain).toBe(REDOCLY_DOMAIN_EU);
+  });
+
+  it('should resolve domain by US region prioritizing flag over env variable', () => {
+    process.env.REDOCLY_DOMAIN = testRedoclyDomain;
+    const client = new RedoclyClient('us');
+    expect(client.domain).toBe(REDOCLY_DOMAIN_US);
+  });
+
+  it('should resolve domain by US region when REDOCLY_DOMAIN consists EU domain', () => {
+    process.env.REDOCLY_DOMAIN = REDOCLY_DOMAIN_EU;
+    const client = new RedoclyClient();
+    expect(client.getRegion()).toBe('eu');
+  });
+
+  it('should resolve all tokens', async () => {
+    let spy = jest.spyOn(RedoclyClient.prototype, 'readCredentialsFile').mockImplementation(() => {
+      return { token: 'accessToken', us: 'accessToken', eu: 'eu-accessToken' };
+    });
+    const client = new RedoclyClient();
+    const tokens = client.getAllTokens();
+    expect(tokens).toStrictEqual([
+      { region: 'us', token: 'accessToken' },
+      { region: 'eu', token: 'eu-accessToken' },
+    ]);
+    spy.mockRestore();
+  });
+
+  it('should resolve valid tokens data', async () => {
+    let spy = jest.spyOn(RedoclyClient.prototype, 'readCredentialsFile').mockImplementation(() => {
+      return { us: 'accessToken', eu: 'eu-accessToken' };
+    });
+    const client = new RedoclyClient();
+    const tokens = await client.getValidTokens();
+    expect(tokens).toStrictEqual([
+      { region: 'us', token: 'accessToken', valid: true },
+      { region: 'eu', token: 'eu-accessToken', valid: true },
+    ]);
+    spy.mockRestore();
+  });
+
+  it('should not call setAccessTokens by default', () => {
+    let spy = jest
+      .spyOn(RedoclyClient.prototype, 'readCredentialsFile')
+      .mockImplementation(() => ({}));
+    jest.spyOn(RedoclyClient.prototype, 'setAccessTokens').mockImplementation();
+    const client = new RedoclyClient();
+    expect(client.setAccessTokens).not.toHaveBeenCalled();
+    spy.mockRestore();
+  });
+
+  it('should set correct accessTokens - backward compatibility: default US region', () => {
+    let spy = jest
+      .spyOn(RedoclyClient.prototype, 'readCredentialsFile')
+      .mockImplementation(() => ({ token: testToken }));
+    jest.spyOn(RedoclyClient.prototype, 'setAccessTokens').mockImplementation();
+    const client = new RedoclyClient();
+    expect(client.setAccessTokens).toBeCalledWith(expect.objectContaining({ us: testToken }));
+    spy.mockRestore();
+  });
+
+  it('should set correct accessTokens - backward compatibility: EU region', () => {
+    let spy = jest
+      .spyOn(RedoclyClient.prototype, 'readCredentialsFile')
+      .mockImplementation(() => ({ token: testToken }));
+    jest.spyOn(RedoclyClient.prototype, 'setAccessTokens').mockImplementation();
+    const client = new RedoclyClient('eu');
+    expect(client.setAccessTokens).toBeCalledWith(expect.objectContaining({ eu: testToken }));
+    spy.mockRestore();
+  });
+
+  it('should set correct accessTokens - REDOCLY_AUTHORIZATION env', () => {
+    process.env.REDOCLY_AUTHORIZATION = REDOCLY_AUTHORIZATION_TOKEN;
+    let spy = jest.spyOn(RedoclyClient.prototype, 'readCredentialsFile').mockImplementation();
+    jest.spyOn(RedoclyClient.prototype, 'setAccessTokens').mockImplementation();
+    const client = new RedoclyClient();
+    expect(client.setAccessTokens).toHaveBeenNthCalledWith(1, { us: REDOCLY_AUTHORIZATION_TOKEN });
+    spy.mockRestore();
+  });
+
+  it('should set correct accessTokens prioritizing REDOCLY_AUTHORIZATION env over token in file', () => {
+    process.env.REDOCLY_AUTHORIZATION = REDOCLY_AUTHORIZATION_TOKEN;
+    let spy = jest
+      .spyOn(RedoclyClient.prototype, 'readCredentialsFile')
+      .mockImplementation(() => ({ token: testToken }));
+    jest.spyOn(RedoclyClient.prototype, 'setAccessTokens').mockImplementation();
+    const client = new RedoclyClient();
+    expect(client.setAccessTokens).toHaveBeenNthCalledWith(2, { us: REDOCLY_AUTHORIZATION_TOKEN });
+    spy.mockRestore();
+  });
+
+  it('should set correct accessTokens prioritizing REDOCLY_AUTHORIZATION env over EU token', () => {
+    process.env.REDOCLY_AUTHORIZATION = REDOCLY_AUTHORIZATION_TOKEN;
+    let spy = jest
+      .spyOn(RedoclyClient.prototype, 'readCredentialsFile')
+      .mockImplementation(() => ({ us: testToken }));
+    jest.spyOn(RedoclyClient.prototype, 'setAccessTokens').mockImplementation();
+    const client = new RedoclyClient('eu');
+    expect(client.setAccessTokens).toHaveBeenNthCalledWith(2, { eu: REDOCLY_AUTHORIZATION_TOKEN });
+    spy.mockRestore();
+  });
+});

package/src/redocly/index.ts

@@ -0,0 +1,187 @@
+import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
+import { resolve } from 'path';
+import { homedir } from 'os';
+import { RegistryApi } from './registry-api';
+import { DEFAULT_REGION, DOMAINS, AVAILABLE_REGIONS } from '../config/config';
+import { env } from '../env';
+import { RegionalToken, RegionalTokenWithValidity } from './redocly-client-types';
+import { isNotEmptyObject } from '../utils';
+import { colorize } from '../logger';
+
+import type { AccessTokens, Region } from '../config/types';
+
+const TOKEN_FILENAME = '.redocly-config.json';
+
+export class RedoclyClient {
+  private accessTokens: AccessTokens = {};
+  private region: Region;
+  domain: string;
+  registryApi: RegistryApi;
+
+  constructor(region?: Region) {
+    this.region = this.loadRegion(region);
+    this.loadTokens();
+    this.domain = region ? DOMAINS[region] : env.REDOCLY_DOMAIN || DOMAINS[DEFAULT_REGION];
+
+    env.REDOCLY_DOMAIN = this.domain; // isRedoclyRegistryURL depends on the value to be set
+    this.registryApi = new RegistryApi(this.accessTokens, this.region);
+  }
+
+  loadRegion(region?: Region) {
+    if (region && !DOMAINS[region]) {
+      throw new Error(
+        `Invalid argument: region in config file.\nGiven: ${colorize.green(
+          region
+        )}, choices: "us", "eu".`
+      );
+    }
+
+    if (env.REDOCLY_DOMAIN) {
+      return (AVAILABLE_REGIONS.find(
+        (region) => DOMAINS[region as Region] === env.REDOCLY_DOMAIN
+      ) || DEFAULT_REGION) as Region;
+    }
+    return region || DEFAULT_REGION;
+  }
+
+  getRegion(): Region {
+    return this.region;
+  }
+
+  hasTokens(): boolean {
+    return isNotEmptyObject(this.accessTokens);
+  }
+
+  // <backward compatibility: old versions of portal>
+  hasToken() {
+    return !!this.accessTokens[this.region];
+  }
+
+  async getAuthorizationHeader(): Promise<string | undefined> {
+    return this.accessTokens[this.region];
+  }
+  // </backward compatibility: portal>
+
+  setAccessTokens(accessTokens: AccessTokens) {
+    this.accessTokens = accessTokens;
+  }
+
+  loadTokens(): void {
+    const credentialsPath = resolve(homedir(), TOKEN_FILENAME);
+    const credentials = this.readCredentialsFile(credentialsPath);
+    if (isNotEmptyObject(credentials)) {
+      this.setAccessTokens({
+        ...credentials,
+        ...(credentials.token &&
+          !credentials[this.region] && {
+            [this.region]: credentials.token,
+          }),
+      });
+    }
+    if (env.REDOCLY_AUTHORIZATION) {
+      this.setAccessTokens({
+        ...this.accessTokens,
+        [this.region]: env.REDOCLY_AUTHORIZATION,
+      });
+    }
+  }
+
+  getAllTokens(): RegionalToken[] {
+    return (<[Region, string][]>Object.entries(this.accessTokens))
+      .filter(([region]) => AVAILABLE_REGIONS.includes(region))
+      .map(([region, token]) => ({ region, token }));
+  }
+
+  async getValidTokens(): Promise<RegionalTokenWithValidity[]> {
+    const allTokens = this.getAllTokens();
+
+    const verifiedTokens = await Promise.allSettled(
+      allTokens.map(({ token, region }) => this.verifyToken(token, region))
+    );
+
+    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(): Promise<boolean> {
+    if (!this.hasTokens()) {
+      return false;
+    }
+
+    const accessToken = this.accessTokens[this.region];
+
+    if (!accessToken) {
+      return false;
+    }
+
+    try {
+      await this.verifyToken(accessToken, this.region);
+
+      return true;
+    } catch (err) {
+      return false;
+    }
+  }
+
+  async isAuthorizedWithRedocly(): Promise<boolean> {
+    return this.hasTokens() && isNotEmptyObject(await this.getValidTokens());
+  }
+
+  readCredentialsFile(credentialsPath: string) {
+    return existsSync(credentialsPath) ? JSON.parse(readFileSync(credentialsPath, 'utf-8')) : {};
+  }
+
+  async verifyToken(
+    accessToken: string,
+    region: Region,
+    verbose: boolean = false
+  ): Promise<{ viewerId: string; organizations: string[] }> {
+    return this.registryApi.authStatus(accessToken, region, verbose);
+  }
+
+  async login(accessToken: string, verbose: boolean = false) {
+    const credentialsPath = resolve(homedir(), TOKEN_FILENAME);
+
+    try {
+      await this.verifyToken(accessToken, this.region, 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);
+    writeFileSync(credentialsPath, JSON.stringify(credentials, null, 2));
+  }
+
+  logout(): void {
+    const credentialsPath = resolve(homedir(), TOKEN_FILENAME);
+    if (existsSync(credentialsPath)) {
+      unlinkSync(credentialsPath);
+    }
+  }
+}
+
+export function isRedoclyRegistryURL(link: string): boolean {
+  const domain = env.REDOCLY_DOMAIN || DOMAINS[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/src/redocly/redocly-client-types.ts

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