@redocly/openapi-core 1.0.0-beta.126 → 1.0.0-beta.128

package/src/index.ts

@@ -1,71 +0,0 @@
-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

@@ -1,14 +0,0 @@
-// 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

@@ -1,130 +0,0 @@
-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);
-  const normalizedVisitors = normalizeVisitors([...preprocessors, ...regularRules] as any, types);
-  const resolvedRefMap = await resolveDocument({
-    rootDocument: document,
-    rootType: types.Root,
-    externalRefResolver,
-  });
-
-  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

@@ -1,34 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,146 +0,0 @@
-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

@@ -1,187 +0,0 @@
-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

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

package/src/redocly/registry-api-types.ts

@@ -1,32 +0,0 @@
-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';
-}