@redocly/openapi-core 1.0.0-beta.87 → 1.0.0-beta.90

package/src/__tests__/lint.test.ts

@@ -46,7 +46,7 @@ describe('lint', () => {
   it('lintConfig should work', async () => {
     const document = parseYamlToDocument(
       outdent`
-      apiDefinitions: error string
+      apis: error string
       lint:
         plugins:
           - './local-plugin.js'
@@ -58,7 +58,7 @@ describe('lint', () => {
           no-invalid-media-type-examples: error
           path-http-verbs-order: error
           boolean-parameter-prefixes: off
-      referenceDocs:
+      features.openapi:
         showConsole: true
         layout:
           scope: section
@@ -78,12 +78,12 @@ describe('lint', () => {
         Object {
           "location": Array [
             Object {
-              "pointer": "#/apiDefinitions",
+              "pointer": "#/apis",
               "reportOnKey": false,
               "source": "",
             },
           ],
-          "message": "Expected type \`object\` but got \`string\`.",
+          "message": "Expected type \`ConfigApis\` (object) but got \`string\`",
           "ruleId": "spec",
           "severity": "error",
           "suggest": Array [],
@@ -91,7 +91,7 @@ describe('lint', () => {
         Object {
           "location": Array [
             Object {
-              "pointer": "#/referenceDocs/layout",
+              "pointer": "#/features.openapi/layout",
               "reportOnKey": false,
               "source": "",
             },
@@ -105,6 +105,40 @@ describe('lint', () => {
     `);
   });
 
+  it("'plugins' shouldn't be allowed in 'apis' -> 'lint' field", async () => {
+    const document = parseYamlToDocument(
+      outdent`
+      apis: 
+        lint: 
+          plugins: 
+            - './local-plugin.js'
+      lint:
+        plugins:
+          - './local-plugin.js'
+      `,
+      '',
+    );
+    const results = await lintConfig({ document });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/apis/lint/plugins",
+              "reportOnKey": true,
+              "source": "",
+            },
+          ],
+          "message": "Property \`plugins\` is not expected here.",
+          "ruleId": "spec",
+          "severity": "error",
+          "suggest": Array [],
+        },
+      ]
+    `);
+  });
+
   it("'const' can have any type", async () => {
     const document = parseYamlToDocument(
       outdent`
@@ -140,7 +174,7 @@ describe('lint', () => {
     const results = await lintDocument({
       externalRefResolver: new BaseResolver(),
       document,
-      config: makeConfig({ spec: 'error', }),
+      config: makeConfig({ spec: 'error' }),
     });
 
     expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`Array []`);

package/src/config/__tests__/load.test.ts

@@ -2,6 +2,7 @@ import { loadConfig, findConfig } from '../load';
 import { RedoclyClient } from '../../redocly';
 
 const fs = require('fs');
+const path = require('path');
 
 describe('loadConfig', () => {
   it('should resolve config http header by US region', async () => {
@@ -66,4 +67,10 @@ describe('findConfig', () => {
       Please use 'redocly.yaml' instead.
     `);
   });
+  it('should find a nested config ', async () => {
+    jest.spyOn(fs, 'existsSync').mockImplementation((name) => name === 'dir/redocly.yaml');
+    jest.spyOn(path, 'resolve').mockImplementationOnce((dir, name) => `${dir}/${name}`);
+    const configName = findConfig('dir');
+    expect(configName).toStrictEqual('dir/redocly.yaml');
+  });
 });

package/src/config/config.ts

@@ -2,10 +2,8 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { dirname } from 'path';
 import { red, blue } from 'colorette';
-
 import { parseYaml, stringifyYaml } from '../js-yaml';
 import { notUndefined, slash } from '../utils';
-
 import {
   OasVersion,
   Oas3PreprocessorsSet,
@@ -14,11 +12,9 @@ import {
   Oas2RuleSet,
   Oas2PreprocessorsSet,
   Oas2DecoratorsSet,
-  Oas3RuleSet
+  Oas3RuleSet,
 } from '../oas-types';
-
 import { ProblemSeverity, NormalizedProblem } from '../walk';
-
 import recommended from './recommended';
 import { NodeType } from '../types';
 
@@ -124,13 +120,12 @@ export type ResolveConfig = {
 
 export const DEFAULT_REGION = 'us';
 export type Region = 'us' | 'eu';
-export type AccessTokens = {[region in Region]?: string };
+export type AccessTokens = { [region in Region]?: string };
 const REDOCLY_DOMAIN = process.env.REDOCLY_DOMAIN;
 export const DOMAINS: { [region in Region]: string } = {
   us: 'redocly.com',
   eu: 'eu.redocly.com',
 };
-export const AVAILABLE_REGIONS = Object.keys(DOMAINS) as Region[];
 
 // FIXME: temporary fix for our lab environments
 if (REDOCLY_DOMAIN?.endsWith('.redocly.host')) {
@@ -139,13 +134,31 @@ if (REDOCLY_DOMAIN?.endsWith('.redocly.host')) {
 if (REDOCLY_DOMAIN === 'redoc.online') {
   DOMAINS[REDOCLY_DOMAIN as Region] = REDOCLY_DOMAIN;
 }
+export const AVAILABLE_REGIONS = Object.keys(DOMAINS) as Region[];
 
-export type RawConfig = {
-  referenceDocs?: any;
+export type DeprecatedRawConfig = {
   apiDefinitions?: Record<string, string>;
   lint?: LintRawConfig;
   resolve?: RawResolveConfig;
   region?: Region;
+  referenceDocs?: Record<string, any>;
+};
+
+export type Api = {
+  root: string;
+  lint?: Omit<LintRawConfig, 'plugins'>;
+  'features.openapi'?: Record<string, any>;
+  'features.mockServer'?: Record<string, any>;
+};
+
+export type RawConfig = {
+  apis?: Record<string, Api>;
+  lint?: LintRawConfig;
+  resolve?: RawResolveConfig;
+  region?: Region;
+  'features.openapi'?: Record<string, any>;
+  'features.mockServer'?: Record<string, any>;
+  organization?: string;
 };
 
 export class LintConfig {
@@ -201,7 +214,9 @@ export class LintConfig {
       [OasVersion.Version3_1]: { ...merged.decorators, ...merged.oas3_1Decorators },
     };
 
-    const dir = this.configFile ? path.dirname(this.configFile) : (typeof process !== 'undefined' && process.cwd() || '');
+    const dir = this.configFile
+      ? path.dirname(this.configFile)
+      : (typeof process !== 'undefined' && process.cwd()) || '';
     const ignoreFile = path.join(dir, IGNORE_FILE);
 
     /* no crash when using it on the client */
@@ -229,7 +244,8 @@ export class LintConfig {
     const ignoreFile = path.join(dir, IGNORE_FILE);
     const mapped: Record<string, any> = {};
     for (const absFileName of Object.keys(this.ignore)) {
-      const ignoredRules = (mapped[slash(path.relative(dir, absFileName))] = this.ignore[absFileName]);
+      const ignoredRules = (mapped[slash(path.relative(dir, absFileName))] =
+        this.ignore[absFileName]);
       for (const ruleId of Object.keys(ignoredRules)) {
         ignoredRules[ruleId] = Array.from(ignoredRules[ruleId]) as any;
       }
@@ -398,16 +414,19 @@ export class LintConfig {
 }
 
 export class Config {
-  referenceDocs: any;
-  apiDefinitions: Record<string, string>;
+  apis: Record<string, Api>;
   lint: LintConfig;
   resolve: ResolveConfig;
   licenseKey?: string;
   region?: Region;
+  'features.openapi': Record<string, any>;
+  'features.mockServer'?: Record<string, any>;
+  organization?: string;
   constructor(public rawConfig: RawConfig, public configFile?: string) {
-    this.apiDefinitions = rawConfig.apiDefinitions || {};
+    this.apis = rawConfig.apis || {};
     this.lint = new LintConfig(rawConfig.lint || {}, configFile);
-    this.referenceDocs = rawConfig.referenceDocs || {};
+    this['features.openapi'] = rawConfig['features.openapi'] || {};
+    this['features.mockServer'] = rawConfig['features.mockServer'] || {};
     this.resolve = {
       http: {
         headers: rawConfig?.resolve?.http?.headers ?? [],
@@ -415,13 +434,13 @@ export class Config {
       },
     };
     this.region = rawConfig.region;
+    this.organization = rawConfig.organization;
   }
 }
 
 function resolvePresets(presets: string[], plugins: Plugin[]) {
   return presets.map((presetName) => {
     const { pluginId, configName } = parsePresetName(presetName);
-
     const plugin = plugins.find((p) => p.id === pluginId);
     if (!plugin) {
       throw new Error(`Invalid config ${red(presetName)}: plugin ${pluginId} is not included.`);
@@ -624,3 +643,72 @@ function assignExisting<T>(target: Record<string, T>, obj: Record<string, T>) {
     }
   }
 }
+
+export function getMergedConfig(config: Config, entrypointAlias?: string): Config {
+  return entrypointAlias
+    ? new Config({
+        ...config.rawConfig,
+        lint: getMergedLintConfig(config, entrypointAlias),
+        'features.openapi': {
+          ...config['features.openapi'],
+          ...config.apis[entrypointAlias]?.['features.openapi'],
+        },
+        'features.mockServer': {
+          ...config['features.mockServer'],
+          ...config.apis[entrypointAlias]?.['features.mockServer'],
+        },
+        // TODO: merge everything else here
+      })
+    : config;
+}
+
+export function getMergedLintConfig(config: Config, entrypointAlias?: string) {
+  const apiLint = entrypointAlias ? config.apis[entrypointAlias]?.lint : {};
+  const mergedLint = {
+    ...config.rawConfig.lint,
+    ...apiLint,
+    rules: { ...config.rawConfig.lint?.rules, ...apiLint?.rules },
+    preprocessors: { ...config.rawConfig.lint?.preprocessors, ...apiLint?.preprocessors },
+    decorators: { ...config.rawConfig.lint?.decorators, ...apiLint?.decorators },
+  };
+  return mergedLint;
+}
+
+function transformApiDefinitionsToApis(
+  apiDefinitions: Record<string, string> = {},
+): Record<string, Api> {
+  let apis: Record<string, Api> = {};
+  for (const [apiName, apiPath] of Object.entries(apiDefinitions)) {
+    apis[apiName] = { root: apiPath };
+  }
+  return apis;
+}
+
+export function transformConfig(rawConfig: DeprecatedRawConfig | RawConfig): RawConfig {
+  if ((rawConfig as RawConfig).apis && (rawConfig as DeprecatedRawConfig).apiDefinitions) {
+    throw new Error("Do not use 'apiDefinitions' field. Use 'apis' instead.\n");
+  }
+  if (
+    (rawConfig as RawConfig)['features.openapi'] &&
+    (rawConfig as DeprecatedRawConfig).referenceDocs
+  ) {
+    throw new Error("Do not use 'referenceDocs' field. Use 'features.openapi' instead.\n");
+  }
+  const { apiDefinitions, referenceDocs, ...rest } = rawConfig as DeprecatedRawConfig & RawConfig;
+  // TODO: put links to the changelog and uncomment this after successful release of ReferenceDocs/Redoc, Portal and Workflows
+  // if (apiDefinitions) {
+  //   process.stderr.write(
+  //     `The ${yellow('apiDefinitions')} field is deprecated. Use ${green('apis')} instead, see changelog: <link>\n`
+  //   );
+  // }
+  // if (referenceDocs) {
+  //   process.stderr.write(
+  //     `The ${yellow('referenceDocs')} field is deprecated. Use ${green('features.openapi')} instead, see changelog: <link>\n`
+  //   );
+  // }
+  return {
+    'features.openapi': referenceDocs,
+    apis: transformApiDefinitionsToApis(apiDefinitions),
+    ...rest,
+  };
+}

package/src/config/load.ts

@@ -1,23 +1,13 @@
 import * as fs from 'fs';
+import * as path from 'path';
 import { RedoclyClient } from '../redocly';
 import { loadYaml } from '../utils';
-import { Config, DOMAINS, RawConfig, Region } from './config';
-
+import { Config, DOMAINS, RawConfig, Region, transformConfig } from './config';
 import { defaultPlugin } from './builtIn';
 
-export async function loadConfig(configPath?: string, customExtends?: string[]): Promise<Config> {
-  if (configPath === undefined) {
-    configPath = findConfig();
-  }
-  let rawConfig: RawConfig = {};
+export async function loadConfig(configPath: string | undefined = findConfig(), customExtends?: string[]): Promise<Config> {
+  const rawConfig = await getConfig(configPath);
 
-  if (configPath !== undefined) {
-    try {
-      rawConfig = (await loadYaml(configPath)) as RawConfig;
-    } catch (e) {
-      throw new Error(`Error parsing config file at \`${configPath}\`: ${e.message}`);
-    }
-  }
   if (customExtends !== undefined) {
     rawConfig.lint = rawConfig.lint || {};
     rawConfig.lint.extends = customExtends;
@@ -48,7 +38,6 @@ export async function loadConfig(configPath?: string, customExtends?: string[]):
       }] : []));
     }
   }
-
   return new Config(
     {
       ...rawConfig,
@@ -63,12 +52,11 @@ export async function loadConfig(configPath?: string, customExtends?: string[]):
 
 export const CONFIG_FILE_NAMES = ['redocly.yaml', 'redocly.yml', '.redocly.yaml', '.redocly.yml'];
 
-export function findConfig(): string | undefined {
+export function findConfig(dir?: string): string | undefined {
   if (!fs.hasOwnProperty('existsSync')) return;
-
-  const existingConfigFiles = CONFIG_FILE_NAMES.map((name) => fs.existsSync(name) && name).filter(
-    Boolean,
-  ) as Array<string | never>;
+  const existingConfigFiles = CONFIG_FILE_NAMES
+    .map(name => dir ? path.resolve(dir, name) : name)
+    .filter(fs.existsSync);
   if (existingConfigFiles.length > 1) {
     throw new Error(`
       Multiple configuration files are not allowed. 
@@ -78,3 +66,13 @@ export function findConfig(): string | undefined {
   }
   return existingConfigFiles[0];
 }
+
+export async function getConfig(configPath: string | undefined = findConfig()) {
+  if (!configPath) return {};
+  try {
+    const rawConfig = ((await loadYaml(configPath)) || {}) as RawConfig;
+    return transformConfig(rawConfig);
+  } catch (e) {
+    throw new Error(`Error parsing config file at '${configPath}': ${e.message}`);
+  }
+}

package/src/format/codeframes.ts

@@ -183,8 +183,10 @@ export function getAstNodeByPointer(root: YAMLNode, pointer: string, reportOnKey
   for (const key of pointerSegments) {
     if (currentNode.kind === yamlAst.Kind.MAP) {
       const mapping = currentNode.mappings.find((m) => m.key.value === key);
-      if (!mapping?.value) break;
-      currentNode = mapping?.value as YAMLNode;
+      if (!mapping) break;
+      currentNode = mapping as YAMLNode;
+      if (!mapping?.value) break; // If node has value - return value, if not - return node itself
+      currentNode = mapping.value as YAMLNode;
     } else if (currentNode.kind === yamlAst.Kind.SEQ) {
       const elem = currentNode.items[parseInt(key, 10)] as YAMLNode;
       if (!elem) break;

package/src/index.ts

@@ -14,16 +14,24 @@ export {
   Oas3_1Schema,
   Oas3Tag,
   Oas3_1Webhooks,
-  Referenced
+  Referenced,
 } from './typings/openapi';
 export { Oas2Definition } from './typings/swagger';
 export { StatsAccumulator, StatsName } from './typings/common';
 export { normalizeTypes } from './types';
 export { Stats } from './rules/other/stats';
 
-export { Config, LintConfig, RawConfig, IGNORE_FILE, Region } from './config/config';
+export {
+  Config,
+  LintConfig,
+  RawConfig,
+  IGNORE_FILE,
+  Region,
+  getMergedConfig,
+  transformConfig,
+} from './config/config';
 
-export { loadConfig, findConfig, CONFIG_FILE_NAMES } from './config/load';
+export { loadConfig, getConfig, findConfig, CONFIG_FILE_NAMES } from './config/load';
 export { RedoclyClient, isRedoclyRegistryURL } from './redocly';
 
 export {

package/src/redocly/index.ts

@@ -19,9 +19,7 @@ export class RedoclyClient {
   constructor(region?: Region) {
     this.region = this.loadRegion(region);
     this.loadTokens();
-    this.domain = region
-      ? DOMAINS[region]
-      : process.env.REDOCLY_DOMAIN || DOMAINS[DEFAULT_REGION];
+    this.domain = region ? DOMAINS[region] : process.env.REDOCLY_DOMAIN || DOMAINS[DEFAULT_REGION];
 
     /*
      * We can't use process.env here because it is replaced by a const in some client-side bundles,
@@ -34,7 +32,11 @@ export class RedoclyClient {
   loadRegion(region?: Region) {
     if (region && !DOMAINS[region]) {
       process.stdout.write(
-        red(`Invalid argument: region in config file.\nGiven: ${green(region)}, choices: "us", "eu".\n`),
+        red(
+          `Invalid argument: region in config file.\nGiven: ${green(
+            region,
+          )}, choices: "us", "eu".\n`,
+        ),
       );
       process.exit(1);
     }
@@ -86,37 +88,36 @@ export class RedoclyClient {
     if (isNotEmptyObject(credentials)) {
       this.setAccessTokens({
         ...credentials,
-        ...(credentials.token && !credentials[this.region] && {
-          [this.region]: credentials.token
-        })
-      })
+        ...(credentials.token &&
+          !credentials[this.region] && {
+            [this.region]: credentials.token,
+          }),
+      });
     }
     if (process.env.REDOCLY_AUTHORIZATION) {
       this.setAccessTokens({
         ...this.accessTokens,
-        [this.region]: process.env.REDOCLY_AUTHORIZATION
-      })
+        [this.region]: process.env.REDOCLY_AUTHORIZATION,
+      });
     }
   }
 
-  getAllTokens (): RegionalToken[] {
-    return (<[Region, string][]>Object.entries(this.accessTokens)).filter(
-      ([region]) => AVAILABLE_REGIONS.includes(region)
-    ).map(
-      ([region, token]) => ({ region, token })
-    );
+  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 validTokens = <RegionalTokenWithValidity[]>[];
+    const allTokens = this.getAllTokens();
 
-    for (const { token, region } of this.getAllTokens()) {
-      if (await this.verifyToken(token, region)) {
-        validTokens.push({ token, region, valid: true });
-      }
-    }
-    
-    return validTokens;
+    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() {
@@ -124,9 +125,23 @@ export class RedoclyClient {
   }
 
   async isAuthorizedWithRedoclyByRegion(): Promise<boolean> {
-    if (!this.hasTokens()) return false;
+    if (!this.hasTokens()) {
+      return false;
+    }
+
     const accessToken = this.accessTokens[this.region];
-    return !!accessToken && await this.verifyToken(accessToken, this.region);
+
+    if (!accessToken) {
+      return false;
+    }
+
+    try {
+      await this.verifyToken(accessToken, this.region);
+
+      return true;
+    } catch (err) {
+      return false;
+    }
   }
 
   async isAuthorizedWithRedocly(): Promise<boolean> {
@@ -137,8 +152,11 @@ export class RedoclyClient {
     return existsSync(credentialsPath) ? JSON.parse(readFileSync(credentialsPath, 'utf-8')) : {};
   }
 
-  async verifyToken(accessToken: string, region: Region, verbose: boolean = false): Promise<boolean> {
-    if (!accessToken) return false;
+  async verifyToken(
+    accessToken: string,
+    region: Region,
+    verbose: boolean = false,
+  ): Promise<{ viewerId: string; organizations: string[] }> {
     return this.registryApi.authStatus(accessToken, region, verbose);
   }
 
@@ -146,8 +164,9 @@ export class RedoclyClient {
     const credentialsPath = resolve(homedir(), TOKEN_FILENAME);
     process.stdout.write(gray('\n  Logging in...\n'));
 
-    const authorized = await this.verifyToken(accessToken, this.region, verbose);
-    if (!authorized) {
+    try {
+      await this.verifyToken(accessToken, this.region, verbose);
+    } catch (err) {
       process.stdout.write(
         red('Authorization failed. Please check if you entered a valid API key.\n'),
       );

package/src/redocly/registry-api.ts

@@ -22,28 +22,43 @@ export class RegistryApi {
 
   private async request(path = '', options: RequestInit = {}, region?: Region) {
     const headers = Object.assign({}, options.headers || {}, { 'x-redocly-cli-version': version });
-    if (!headers.hasOwnProperty('authorization')) { throw new Error('Unauthorized'); }
+
+    if (!headers.hasOwnProperty('authorization')) {
+      throw new Error('Unauthorized');
+    }
+
     const response = await fetch(
       `${this.getBaseUrl(region)}${path}`,
       Object.assign({}, options, { headers }),
     );
-    if (response.status === 401) { throw new Error('Unauthorized'); }
+
+    if (response.status === 401) {
+      throw new Error('Unauthorized');
+    }
+
     if (response.status === 404) {
       const body: RegistryApiTypes.NotFoundProblemResponse = await response.json();
       throw new Error(body.code);
     }
+
     return response;
   }
 
-  async authStatus(accessToken: string, region: Region, verbose = false) {
+  async authStatus(
+    accessToken: string,
+    region: Region,
+    verbose = false,
+  ): Promise<{ viewerId: string; organizations: string[] }> {
     try {
-      const response = await this.request('', { headers: { authorization: accessToken }}, region);
-      return response.ok;
+      const response = await this.request('', { headers: { authorization: accessToken } }, region);
+
+      return await response.json();
     } catch (error) {
       if (verbose) {
         console.log(error);
       }
-      return false;
+
+      throw error;
     }
   }
 
@@ -69,7 +84,7 @@ export class RegistryApi {
           isUpsert,
         }),
       },
-      this.region
+      this.region,
     );
 
     if (response.ok) {
@@ -88,20 +103,22 @@ export class RegistryApi {
     branch,
     isUpsert,
   }: RegistryApiTypes.PushApiParams) {
-    const response = await this.request(`/${organizationId}/${name}/${version}`, {
-      method: 'PUT',
-      headers: {
-        'content-type': 'application/json',
-        authorization: this.accessToken
-      } as HeadersInit,
-      body: JSON.stringify({
-        rootFilePath,
-        filePaths,
-        branch,
-        isUpsert,
-      }),
-    },
-      this.region
+    const response = await this.request(
+      `/${organizationId}/${name}/${version}`,
+      {
+        method: 'PUT',
+        headers: {
+          'content-type': 'application/json',
+          authorization: this.accessToken,
+        } as HeadersInit,
+        body: JSON.stringify({
+          rootFilePath,
+          filePaths,
+          branch,
+          isUpsert,
+        }),
+      },
+      this.region,
     );
 
     if (response.ok) {

package/src/rules/oas3/__tests__/spec/spec.test.ts

@@ -192,8 +192,8 @@ describe('Oas3 Structural visitor basic', () => {
         Object {
           "location": Array [
             Object {
-              "pointer": "#/",
-              "reportOnKey": false,
+              "pointer": "#/openapi",
+              "reportOnKey": true,
               "source": "foobar.yaml",
             },
           ],
@@ -259,8 +259,8 @@ describe('Oas3 Structural visitor basic', () => {
         Object {
           "location": Array [
             Object {
-              "pointer": "#/",
-              "reportOnKey": false,
+              "pointer": "#/openapi",
+              "reportOnKey": true,
               "source": "foobar.yaml",
             },
           ],

package/src/rules/oas3/no-empty-servers.ts

@@ -3,9 +3,10 @@ import { Oas3Rule } from '../../visitors';
 export const NoEmptyServers: Oas3Rule = () => {
   return {
     DefinitionRoot(root, { report, location }) {
-      if (!root.servers) {
+      if (!root.hasOwnProperty('servers')) {
         report({
           message: 'Servers must be present.',
+          location: location.child(['openapi']).key()
         });
         return;
       }