definition-generator-framework 1.12.4 → 1.12.6

package/dist/helpers/validator/joi-custom-validators.spec.js

@@ -0,0 +1,304 @@
+'use strict';
+var __createBinding =
+  (this && this.__createBinding) ||
+  (Object.create
+    ? function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        var desc = Object.getOwnPropertyDescriptor(m, k);
+        if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+          desc = {
+            enumerable: true,
+            get: function () {
+              return m[k];
+            }
+          };
+        }
+        Object.defineProperty(o, k2, desc);
+      }
+    : function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+      });
+var __setModuleDefault =
+  (this && this.__setModuleDefault) ||
+  (Object.create
+    ? function (o, v) {
+        Object.defineProperty(o, 'default', { enumerable: true, value: v });
+      }
+    : function (o, v) {
+        o['default'] = v;
+      });
+var __importStar =
+  (this && this.__importStar) ||
+  function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null)
+      for (var k in mod) if (k !== 'default' && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
+const Joi = __importStar(require('joi'));
+const joi_custom_validators_1 = require('./joi-custom-validators');
+const mocks_1 = require('../../_mocks/mocks');
+const raw_definition_helper_1 = require('../raw-definition-helper/raw-definition.helper');
+joi_custom_validators_1.JoiCustomValidators.decorate({ existsSync: path => path !== 'D:/test/false/path.png' });
+const DefinitionType = 'ASSET';
+class Asset {
+  static {
+    this.$meta = {
+      definitionName: DefinitionType
+    };
+  }
+  async process() {}
+}
+class AssetGroup {
+  static {
+    this.$meta = {
+      definitionName: 'ASSET-GROUP'
+    };
+  }
+  async process() {}
+}
+function getSimpleRawDefinition(value, offset = 1) {
+  return {
+    type: DefinitionType,
+    location: mocks_1.SampleLocation1,
+    parsedStructure: {
+      line: mocks_1.SampleLocation1.line + offset,
+      rawData: {
+        value: {
+          rawData: value,
+          line: mocks_1.SampleLocation1.line + offset
+        }
+      }
+    }
+  };
+}
+function getFlatRawDefinition(value, offset = 1) {
+  return {
+    type: DefinitionType,
+    location: mocks_1.SampleLocation1,
+    parsedStructure: {
+      line: mocks_1.SampleLocation1.line + offset,
+      rawData: value
+    }
+  };
+}
+describe('JOI CUSTOM VALIDATORS', () => {
+  beforeEach(() => {
+    let validators = joi_custom_validators_1.JoiCustomValidators;
+    validators.rootDirectory = 'D:/';
+    validators.definitionNames = new Map();
+    validators.duplicateHelpers = new Map();
+  });
+  describe('Variable Name', () => {
+    let schema = Joi.object().keys({
+      value: Joi.string().uniqueNameGroup(Asset).required()
+    });
+    test('valid data', () => {
+      let rawDefinition = getSimpleRawDefinition('test');
+      let { value, error } = schema.validate(raw_definition_helper_1.RawDefinitionHelper.flatten(rawDefinition), {
+        abortEarly: false,
+        context: rawDefinition
+      });
+      expect(value).toEqual({ value: 'assetTest' });
+      expect(error).toEqual(undefined);
+    });
+    test('invalid data', () => {
+      let rawDefinition = getSimpleRawDefinition('invalid data');
+      let { error } = schema.validate(raw_definition_helper_1.RawDefinitionHelper.flatten(rawDefinition), {
+        abortEarly: false,
+        context: rawDefinition
+      });
+      expect(error?.details).toStrictEqual([
+        {
+          message: '"value" with value "invalid data" fails to match the required pattern: /^[a-z]+([a-zA-Z0-9]+)*$/',
+          path: [],
+          type: 'string.pattern.base',
+          context: {
+            name: undefined,
+            regex: /^[a-z]+([a-zA-Z0-9]+)*$/,
+            value: 'invalid data',
+            label: 'value',
+            key: 'value'
+          }
+        }
+      ]);
+    });
+    test('should detect duplicate variable names', () => {
+      let rawDefinition1 = getSimpleRawDefinition('test', 1);
+      let rawDefinition2 = getSimpleRawDefinition('test', 2);
+      schema.validate(raw_definition_helper_1.RawDefinitionHelper.flatten(rawDefinition1), {
+        abortEarly: false,
+        context: rawDefinition1
+      });
+      schema.validate(raw_definition_helper_1.RawDefinitionHelper.flatten(rawDefinition2), {
+        abortEarly: false,
+        context: rawDefinition2
+      });
+      let context = (0, mocks_1.getMockContext)();
+      joi_custom_validators_1.JoiCustomValidators.logDuplicates(context);
+      expect(context.errorLogs).toStrictEqual([
+        {
+          description: 'Value should be singular! Group: "ASSET", Value: "test"',
+          location: { line: mocks_1.SampleLocation1.line + 1, path: 'D:/test/file-1.md' }
+        },
+        {
+          description: 'Value should be singular! Group: "ASSET", Value: "test"',
+          location: { line: mocks_1.SampleLocation1.line + 2, path: 'D:/test/file-1.md' }
+        }
+      ]);
+    });
+    test('different groups should not create duplicates', () => {
+      let schema2 = Joi.object().keys({
+        value: Joi.string().uniqueNameGroup(AssetGroup).required()
+      });
+      let rawDefinition1 = getSimpleRawDefinition('test', 1);
+      let rawDefinition2 = getSimpleRawDefinition('test', 2);
+      schema.validate(raw_definition_helper_1.RawDefinitionHelper.flatten(rawDefinition1), {
+        abortEarly: false,
+        context: rawDefinition1
+      });
+      schema2.validate(raw_definition_helper_1.RawDefinitionHelper.flatten(rawDefinition2), {
+        abortEarly: false,
+        context: rawDefinition2
+      });
+      let context = (0, mocks_1.getMockContext)();
+      joi_custom_validators_1.JoiCustomValidators.logDuplicates(context);
+      expect(context.errorLogs).toStrictEqual([]);
+    });
+  });
+  describe('Reference', () => {
+    let schema = Joi.object().keys({
+      value: Joi.string().reference(Asset).required()
+    });
+    let multipleSchema = Joi.object().keys({
+      value: Joi.string().reference([AssetGroup, Asset]).required()
+    });
+    test('valid data', () => {
+      let rawDefinition = getSimpleRawDefinition('test');
+      let validators = joi_custom_validators_1.JoiCustomValidators;
+      validators.getDefinitionNames(DefinitionType).add('test');
+      let { value, error } = schema.validate(raw_definition_helper_1.RawDefinitionHelper.flatten(rawDefinition), {
+        abortEarly: false,
+        context: rawDefinition
+      });
+      expect(value).toEqual({ value: 'assetTest' });
+      expect(error).toEqual(undefined);
+    });
+    test('multiple reference', () => {
+      let rawDefinition = getSimpleRawDefinition('test');
+      let validators = joi_custom_validators_1.JoiCustomValidators;
+      validators.getDefinitionNames(DefinitionType).add('test');
+      let { value, error } = multipleSchema.validate(raw_definition_helper_1.RawDefinitionHelper.flatten(rawDefinition), {
+        abortEarly: false,
+        context: rawDefinition
+      });
+      expect(value).toEqual({ value: 'assetTest' });
+      expect(error).toEqual(undefined);
+    });
+    test('primitive valid data', () => {
+      let rawDefinition = getFlatRawDefinition('test');
+      let primitiveSchema = Joi.string().reference(Asset).required();
+      let validators = joi_custom_validators_1.JoiCustomValidators;
+      validators.getDefinitionNames(DefinitionType).add('test');
+      let { value, error } = primitiveSchema.validate(raw_definition_helper_1.RawDefinitionHelper.flatten(rawDefinition), {
+        abortEarly: false,
+        context: rawDefinition
+      });
+      expect(value).toEqual('assetTest');
+      expect(error).toEqual(undefined);
+    });
+    test('should detect non existing references', () => {
+      let rawDefinition = getSimpleRawDefinition('test');
+      let { error } = schema.validate(raw_definition_helper_1.RawDefinitionHelper.flatten(rawDefinition), {
+        abortEarly: false,
+        context: rawDefinition
+      });
+      expect(error?.details).toEqual([
+        {
+          context: {
+            key: 'value',
+            label: 'value',
+            value: 'test'
+          },
+          message: 'There is no definition found for "test" in name field: "ASSET"',
+          path: ['value'],
+          type: 'any.custom'
+        }
+      ]);
+    });
+    test('should detect non existing multiple references', () => {
+      let rawDefinition = getSimpleRawDefinition('test');
+      let { error } = multipleSchema.validate(raw_definition_helper_1.RawDefinitionHelper.flatten(rawDefinition), {
+        abortEarly: false,
+        context: rawDefinition
+      });
+      expect(error?.details).toEqual([
+        {
+          context: {
+            key: 'value',
+            label: 'value',
+            value: 'test'
+          },
+          message: 'There is no definition found for "test" in name field: "ASSET-GROUP, ASSET"',
+          path: ['value'],
+          type: 'any.custom'
+        }
+      ]);
+    });
+  });
+  describe('Path', () => {
+    let schema = Joi.object().keys({
+      value: Joi.string().path().required()
+    });
+    test('valid data', () => {
+      let rawDefinition = getSimpleRawDefinition('images/test.png');
+      let { value, error } = schema.validate(raw_definition_helper_1.RawDefinitionHelper.flatten(rawDefinition), {
+        abortEarly: false,
+        context: rawDefinition
+      });
+      expect(value).toEqual({ value: '.test/images/test.png' });
+      expect(error).toEqual(undefined);
+    });
+    test('should detect files not existing', () => {
+      let rawDefinition = getSimpleRawDefinition('invalid data');
+      let { error } = schema.validate(raw_definition_helper_1.RawDefinitionHelper.flatten(rawDefinition), {
+        abortEarly: false,
+        context: rawDefinition
+      });
+      expect(error?.details).toStrictEqual([
+        {
+          message: '"value" with value "invalid data" fails to match the required pattern: /^[\\S]+$/',
+          path: ['value'],
+          type: 'string.pattern.base',
+          context: {
+            name: undefined,
+            regex: /^[\S]+$/,
+            value: 'invalid data',
+            label: 'value',
+            key: 'value'
+          }
+        }
+      ]);
+    });
+    test('should detect files not existing', () => {
+      let rawDefinition = getSimpleRawDefinition('false/path.png');
+      let { error } = schema.validate(raw_definition_helper_1.RawDefinitionHelper.flatten(rawDefinition), {
+        abortEarly: false,
+        context: rawDefinition
+      });
+      expect(error?.details).toStrictEqual([
+        {
+          message: 'No file is found in the path: "false/path.png"',
+          path: ['value'],
+          type: 'any.custom',
+          context: { label: 'value', value: 'false/path.png', key: 'value' }
+        }
+      ]);
+    });
+  });
+});
+//# sourceMappingURL=joi-custom-validators.spec.js.map

package/dist/helpers/validator/validator.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helpers/validator/validator.spec.js

@@ -0,0 +1,332 @@
+'use strict';
+var __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
+const joi_1 = __importDefault(require('joi'));
+const validator_1 = require('./validator');
+const joi_custom_validators_1 = require('./joi-custom-validators');
+const mocks_1 = require('../../_mocks/mocks');
+const custom_validator_helper_1 = require('./custom-validator-helper/custom-validator.helper');
+const context_1 = require('../../framework/context');
+const definition_store_1 = require('../../framework/definition-store');
+joi_custom_validators_1.JoiCustomValidators.decorate(joi_1.default, { existsSync: path => path !== 'D:/test/false/path.png' });
+const ComponentType = 'ASSET';
+class Asset {
+  static {
+    this.$meta = {
+      componentName: ComponentType
+    };
+  }
+  async process() {}
+}
+const TestSchema = joi_1.default.object().keys({
+  str1: joi_1.default.string().required(),
+  str2: joi_1.default.string().path().optional()
+});
+function getSampleRawDefinition(str, pathString) {
+  let rawDefinition = {
+    componentName: ComponentType,
+    location: mocks_1.SampleLocation1,
+    parsedStructure: {
+      line: mocks_1.SampleLocation1.line + 1,
+      rawData: {
+        str1: {
+          rawData: str,
+          line: mocks_1.SampleLocation1.line + 1
+        },
+        str2: {
+          rawData: pathString,
+          line: mocks_1.SampleLocation1.line + 2
+        }
+      }
+    }
+  };
+  return rawDefinition;
+}
+const SampleNestedRawDefinition = {
+  componentName: ComponentType,
+  location: mocks_1.SampleLocation1,
+  parsedStructure: {
+    line: mocks_1.SampleLocation1.line + 1,
+    rawData: {
+      obj1: {
+        line: mocks_1.SampleLocation1.line + 1,
+        rawData: [
+          {
+            line: mocks_1.SampleLocation1.line + 2,
+            rawData: {
+              obj2: {
+                line: mocks_1.SampleLocation1.line + 2,
+                rawData: 'test data'
+              }
+            }
+          }
+        ]
+      }
+    }
+  }
+};
+describe('VALIDATOR', () => {
+  beforeEach(() => {
+    (0, mocks_1.resetContext)();
+    custom_validator_helper_1.CustomValidatorHelper['duplicateHelpers'] = new Map();
+  });
+  describe('Convert', () => {
+    test('valid definition', () => {
+      context_1.Context.rawDefinitions.push(getSampleRawDefinition('str1', 'images/test.png'));
+      let definitions = validator_1.Validator.validateAndConvert(ComponentType, TestSchema);
+      custom_validator_helper_1.CustomValidatorHelper.logDuplicates();
+      expect(context_1.Context.errorLogs).toStrictEqual([]);
+      expect(definitions).toStrictEqual([{ str1: 'str1', str2: '.test/images/test.png' }]);
+    });
+    test('singular definition', () => {
+      context_1.Context.rawDefinitions.push(getSampleRawDefinition('str1', 'images/test.png'));
+      let definitions = validator_1.Validator.validateAndConvert(ComponentType, TestSchema);
+      custom_validator_helper_1.CustomValidatorHelper.logDuplicates();
+      expect(context_1.Context.errorLogs).toStrictEqual([]);
+      expect(definitions).toStrictEqual([{ str1: 'str1', str2: '.test/images/test.png' }]);
+    });
+    test('should allow references in the same namespace', () => {
+      let rawDefinition1 = {
+        componentName: ComponentType,
+        location: mocks_1.SampleLocation1,
+        parsedStructure: {
+          line: mocks_1.SampleLocation1.line + 1,
+          rawData: {
+            name: {
+              rawData: 'asset2',
+              line: mocks_1.SampleLocation1.line + 1
+            },
+            ref: {
+              rawData: 'asset1',
+              line: mocks_1.SampleLocation1.line + 2
+            }
+          }
+        }
+      };
+      let rawDefinition2 = {
+        componentName: ComponentType,
+        location: mocks_1.SampleLocation1,
+        parsedStructure: {
+          line: mocks_1.SampleLocation1.line + 1,
+          rawData: {
+            name: {
+              rawData: 'asset1',
+              line: mocks_1.SampleLocation1.line + 1
+            }
+          }
+        }
+      };
+      context_1.Context.rawDefinitions.push(rawDefinition1);
+      context_1.Context.rawDefinitions.push(rawDefinition2);
+      let schema = joi_1.default.object().keys({
+        name: joi_1.default.string().required(),
+        ref: joi_1.default.string().reference(Asset).optional()
+      });
+      definition_store_1.DefinitionStore['setRawDefinition'](Asset, 'asset1', rawDefinition2);
+      let definitions = validator_1.Validator.validateAndConvert(ComponentType, schema);
+      custom_validator_helper_1.CustomValidatorHelper.logDuplicates();
+      expect(context_1.Context.errorLogs).toStrictEqual([]);
+      expect(definitions).toStrictEqual([
+        {
+          name: 'asset2',
+          ref: 'asset1'
+        },
+        {
+          name: 'asset1'
+        }
+      ]);
+    });
+  });
+  describe('Convert Singular', () => {
+    test('valid definition', () => {
+      context_1.Context.rawDefinitions.push(getSampleRawDefinition('str1', 'images/test.png'));
+      let definition = validator_1.Validator.validateAndConvertSingular(ComponentType, TestSchema);
+      custom_validator_helper_1.CustomValidatorHelper.logDuplicates();
+      expect(context_1.Context.errorLogs).toStrictEqual([]);
+      expect(definition).toStrictEqual({ str1: 'str1', str2: '.test/images/test.png' });
+    });
+    test('should log error for no definition', () => {
+      let definition = validator_1.Validator.validateAndConvertSingular(ComponentType, TestSchema);
+      custom_validator_helper_1.CustomValidatorHelper.logDuplicates();
+      expect(definition).toStrictEqual(undefined);
+      expect(context_1.Context.errorLogs).toStrictEqual([
+        {
+          description: 'Singleton definition has no declared entry "ASSET"',
+          location: {
+            line: 0,
+            path: '*'
+          }
+        }
+      ]);
+    });
+    test('should log error for multiple definitions', () => {
+      context_1.Context.rawDefinitions.push(getSampleRawDefinition('str1', 'images/test.png'));
+      context_1.Context.rawDefinitions.push(getSampleRawDefinition('str2', 'images/test.png'));
+      let definition = validator_1.Validator.validateAndConvertSingular(ComponentType, TestSchema);
+      custom_validator_helper_1.CustomValidatorHelper.logDuplicates();
+      expect(definition).toStrictEqual(undefined);
+      expect(context_1.Context.errorLogs).toStrictEqual([
+        {
+          description: 'Only one definition can be defined for "ASSET"',
+          location: {
+            line: 2,
+            path: 'D:/test/file-1.md'
+          }
+        },
+        {
+          description: 'Only one definition can be defined for "ASSET"',
+          location: {
+            line: 2,
+            path: 'D:/test/file-1.md'
+          }
+        }
+      ]);
+    });
+  });
+  describe('Validate', () => {
+    test('should handle valid raw definition', () => {
+      let rawDefinition = getSampleRawDefinition('a', 'images/test.png');
+      let value = validator_1.Validator['validate'](rawDefinition, TestSchema);
+      custom_validator_helper_1.CustomValidatorHelper.logDuplicates();
+      expect(value).toStrictEqual({ str1: 'a', str2: '.test/images/test.png' });
+      expect(context_1.Context.errorLogs).toStrictEqual([]);
+    });
+    test('should log error for required fields', () => {
+      let rawDefinition = getSampleRawDefinition(undefined, 'images/test.png');
+      let value = validator_1.Validator['validate'](rawDefinition, TestSchema);
+      custom_validator_helper_1.CustomValidatorHelper.logDuplicates();
+      expect(value).toStrictEqual(undefined);
+      expect(context_1.Context.errorLogs).toStrictEqual([
+        {
+          description: '"str1" is required',
+          location: {
+            line: mocks_1.SampleLocation1.line + 1,
+            path: mocks_1.SampleLocation1.path
+          }
+        }
+      ]);
+    });
+    test('should log error for invalid flag attribute value', () => {
+      let rawDefinition = getSampleRawDefinition('a', 'wrong text');
+      let value = validator_1.Validator['validate'](rawDefinition, TestSchema);
+      custom_validator_helper_1.CustomValidatorHelper.logDuplicates();
+      expect(value).toStrictEqual(undefined);
+      expect(context_1.Context.errorLogs).toStrictEqual([
+        {
+          description: `"str2" with value "wrong text" fails to match the required pattern: /^[\\S]+$/`,
+          location: {
+            line: mocks_1.SampleLocation1.line + 2,
+            path: mocks_1.SampleLocation1.path
+          }
+        }
+      ]);
+    });
+    test('should log error for non matching pattern', () => {
+      let schema = joi_1.default.object().keys({
+        str1: joi_1.default
+          .string()
+          .regex(/^[a-z]+([a-zA-Z0-9]+)*$/)
+          .required(),
+        str2: joi_1.default
+          .string()
+          .regex(/^[a-z]+([a-zA-Z0-9]+)*$/)
+          .required()
+      });
+      let rawDefinition = getSampleRawDefinition('1a', 'wrong string');
+      let value = validator_1.Validator['validate'](rawDefinition, schema);
+      custom_validator_helper_1.CustomValidatorHelper.logDuplicates();
+      expect(value).toStrictEqual(undefined);
+      expect(context_1.Context.errorLogs).toStrictEqual([
+        {
+          description: `"str1" with value "1a" fails to match the required pattern: /^[a-z]+([a-zA-Z0-9]+)*$/`,
+          location: {
+            line: mocks_1.SampleLocation1.line + 1,
+            path: mocks_1.SampleLocation1.path
+          }
+        },
+        {
+          description: `"str2" with value "wrong string" fails to match the required pattern: /^[a-z]+([a-zA-Z0-9]+)*$/`,
+          location: {
+            line: mocks_1.SampleLocation1.line + 2,
+            path: mocks_1.SampleLocation1.path
+          }
+        }
+      ]);
+    });
+    test('should validate primitive definition', () => {
+      let rawDefinition = {
+        componentName: ComponentType,
+        location: mocks_1.SampleLocation1,
+        parsedStructure: {
+          line: mocks_1.SampleLocation1.line + 1,
+          rawData: 'test'
+        }
+      };
+      let value = validator_1.Validator['validate'](rawDefinition, joi_1.default.string());
+      custom_validator_helper_1.CustomValidatorHelper.logDuplicates();
+      expect(value).toStrictEqual('test');
+      expect(context_1.Context.errorLogs).toStrictEqual([]);
+    });
+    test('should log error for primitive definition', () => {
+      let rawDefinition = {
+        componentName: ComponentType,
+        location: mocks_1.SampleLocation1,
+        parsedStructure: {
+          line: mocks_1.SampleLocation1.line + 1,
+          rawData: 'test'
+        }
+      };
+      let value = validator_1.Validator['validate'](rawDefinition, joi_1.default.string().valid('only'));
+      custom_validator_helper_1.CustomValidatorHelper.logDuplicates();
+      expect(value).toStrictEqual(undefined);
+      expect(context_1.Context.errorLogs).toStrictEqual([
+        {
+          description: '"value" must be [only]',
+          location: {
+            line: mocks_1.SampleLocation1.line + 1,
+            path: mocks_1.SampleLocation1.path
+          }
+        }
+      ]);
+    });
+    test('should validate nested object', () => {
+      let schema = joi_1.default.object().keys({
+        obj1: joi_1.default.array().items(
+          joi_1.default.object().keys({
+            obj2: joi_1.default.string()
+          })
+        )
+      });
+      let value = validator_1.Validator['validate'](SampleNestedRawDefinition, schema);
+      custom_validator_helper_1.CustomValidatorHelper.logDuplicates();
+      expect(value).toStrictEqual({ obj1: [{ obj2: 'test data' }] });
+      expect(context_1.Context.errorLogs).toStrictEqual([]);
+    });
+    test('should log error for nested object', () => {
+      let schema = joi_1.default.object().keys({
+        obj1: joi_1.default.array().items(
+          joi_1.default.object().keys({
+            obj2: joi_1.default.string().valid('only')
+          })
+        )
+      });
+      let value = validator_1.Validator['validate'](SampleNestedRawDefinition, schema);
+      custom_validator_helper_1.CustomValidatorHelper.logDuplicates();
+      expect(value).toStrictEqual(undefined);
+      expect(context_1.Context.errorLogs).toStrictEqual([
+        {
+          description: '"obj1[0].obj2" must be [only]',
+          location: {
+            line: mocks_1.SampleLocation1.line + 2,
+            path: 'D:/test/file-1.md'
+          }
+        }
+      ]);
+    });
+  });
+});
+//# sourceMappingURL=validator.spec.js.map

package/dist/pipeline/1-select-definitions-helper.d.ts

@@ -1,20 +1,20 @@
 import { FileInfo, LocationInFile, ErrorLog } from '../framework/interfaces';
 export interface DefinitionPlaneText {
-    readonly type: string;
-    readonly content: string[];
-    readonly location: LocationInFile;
+  readonly type: string;
+  readonly content: string[];
+  readonly location: LocationInFile;
 }
 export interface SelectDefinitionsResult {
-    definitionPlaneTexts: DefinitionPlaneText[];
-    errorLogs: ErrorLog[];
+  definitionPlaneTexts: DefinitionPlaneText[];
+  errorLogs: ErrorLog[];
 }
 export declare class SelectDefinitionsHelper {
-    private definitionsStarted;
-    private currentItem;
-    private definitionPlaneTexts;
-    private errorLogs;
-    private currentFilePath;
-    process(file: FileInfo): SelectDefinitionsResult;
-    private flushCurrentItem;
-    private onDeclarationEncountered;
+  private definitionsStarted;
+  private currentItem;
+  private definitionPlaneTexts;
+  private errorLogs;
+  private currentFilePath;
+  process(file: FileInfo): SelectDefinitionsResult;
+  private flushCurrentItem;
+  private onDeclarationEncountered;
 }