@api-client/core 0.10.13 → 0.11.0

package/src/models/HttpProject.ts

@@ -1,43 +1,42 @@
-/* eslint-disable @typescript-eslint/no-empty-interface */
+/* eslint-disable @typescript-eslint/no-empty-object-type */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-this-alias */
-import { ProjectParent } from './ProjectParent.js';
-import { IProjectDefinitionProperty } from './ProjectDefinitionProperty.js';
-import { Environment, IEnvironment, Kind as EnvironmentKind } from './Environment.js';
-import { License, ILicense } from './License.js';
-import { Provider, IProvider } from './Provider.js';
-import { IThing, Thing } from './Thing.js';
-import { ProjectItem, IProjectItem } from './ProjectItem.js';
-import { IProjectFolder, ProjectFolder } from './ProjectFolder.js';
-import { IProjectRequest, ProjectRequest, Kind as ProjectRequestKind } from './ProjectRequest.js';
-import { ProjectSchema, IProjectSchema } from './ProjectSchema.js';
-import { Request } from './Request.js';
-import v4 from '../lib/uuid.js';
-import { ARCSavedRequest, ARCHistoryRequest } from './legacy/request/ArcRequest.js';
-import { ArcLegacyProject, ARCProject } from './legacy/models/ArcLegacyProject.js';
-import { PostmanDataTransformer } from './transformers/PostmanDataTransformer.js';
-import { Certificate, HttpCertificate } from './ClientCertificate.js';
-import { ICCAuthorization } from './Authorization.js';
-import { ProjectFolderKind } from './kinds.js';
-
-export const Kind = 'Core#HttpProject';
+import { ProjectParent } from './ProjectParent.js'
+import { IProjectDefinitionProperty } from './ProjectDefinitionProperty.js'
+import { Environment, IEnvironment, Kind as EnvironmentKind } from './Environment.js'
+import { License, ILicense } from './License.js'
+import { Provider, IProvider } from './Provider.js'
+import { IThing, Thing } from './Thing.js'
+import { ProjectItem, IProjectItem } from './ProjectItem.js'
+import { IProjectFolder, ProjectFolder } from './ProjectFolder.js'
+import { IProjectRequest, ProjectRequest, Kind as ProjectRequestKind } from './ProjectRequest.js'
+import { ProjectSchema, IProjectSchema } from './ProjectSchema.js'
+import { Request } from './Request.js'
+import v4 from '../lib/uuid.js'
+import { ARCSavedRequest, ARCHistoryRequest } from './legacy/request/ArcRequest.js'
+import { ArcLegacyProject, ARCProject } from './legacy/models/ArcLegacyProject.js'
+import { PostmanDataTransformer } from './transformers/PostmanDataTransformer.js'
+import { Certificate, HttpCertificate } from './ClientCertificate.js'
+import { ICCAuthorization } from './Authorization.js'
+import { ProjectFolderKind } from './kinds.js'
+
+export const Kind = 'Core#HttpProject'
 
 export interface IItemOptions {
   /**
    * The parent folder of the item to.
    */
-  parent?: string;
+  parent?: string
 }
 
-export interface IItemCreateOptions extends IItemOptions{
+export interface IItemCreateOptions extends IItemOptions {
   /**
    * The position at which to add the item.
    */
-  index?: number;
+  index?: number
 }
 
-export interface IEnvironmentCreateOptions extends IItemCreateOptions {
-}
+export interface IEnvironmentCreateOptions extends IItemCreateOptions {}
 
 /**
  * A list of options to initialize a project in various situations.
@@ -46,88 +45,88 @@ export interface IProjectInitOptions {
   /**
    * The name of the project.
    */
-  name: string;
+  name: string
 }
 
 export interface IFolderCreateOptions {
   /**
-   * Ignores the operation when the folder with the same name already exists. 
+   * Ignores the operation when the folder with the same name already exists.
    * This command can be used used to ensure that the folder exists.
    */
-  skipExisting?: boolean;
+  skipExisting?: boolean
   /**
    * The id of the parent folder. When not set it adds the folder to the project root.
    */
-  parent?: string;
+  parent?: string
   /**
    * Optionally the position at which to add the folder into the list of items.
    */
-  index?: number;
+  index?: number
 }
 
 export interface IFolderSearchOptions {
   /**
-   * When set it searches for a folder using keys only. 
+   * When set it searches for a folder using keys only.
    * By default it searches for a key and the name.
    */
-  keyOnly?: boolean;
+  keyOnly?: boolean
 }
 
 export interface IFolderDeleteOptions {
   /**
    * When set it won't throw an error when the folder is not found in the project.
    */
-  safe?: boolean;
+  safe?: boolean
 }
 
 export interface IRequestAddOptions {
   /**
    * The id of the parent folder. When not set it adds the request to the project root.
    */
-  parent?: string;
+  parent?: string
   /**
    * Optionally the position at which to add the request into the list of items.
    */
-  index?: number;
+  index?: number
 }
 
 export interface IRequestSearchOptions {
   /**
-   * When set it searches for a request using keys only. 
+   * When set it searches for a request using keys only.
    * By default it searches for a key and the name.
    */
-  keyOnly?: boolean;
+  keyOnly?: boolean
 }
 
 export interface IRequestDeleteOptions {
   /**
    * When set it won't throw an error when the request is not found in the project.
    */
-  safe?: boolean;
+  safe?: boolean
 }
 
 export interface IProjectMoveOptions {
   /**
    * The position at which to insert the object in the destination. BY default it adds the object at the end.
    */
-  index?: number;
+  index?: number
   /**
-   * The name or the key of the parent folder to move the item into. 
+   * The name or the key of the parent folder to move the item into.
    * When not set it moves the item to the project's root.
    */
-  parent?: string;
+  parent?: string
 }
 
 export interface IReadEnvironmentOptions extends IItemOptions {
   /**
    * The name or the key of the environment to select.
-   * 
-   * When the name is not specified it selects: 
+   *
+   * When the name is not specified it selects:
    * - the first environment from the project, if any
    * - any parent folder's first environment to the requested folder, if any (if parent is set)
    * - the requested folder's first environment, if any (if parent is set)
    */
-  nameOrKey?: string;
+  nameOrKey?: string
 }
 
 /**
@@ -135,9 +134,9 @@ export interface IReadEnvironmentOptions extends IItemOptions {
  * This is used to list projects in the store and in the UI.
  */
 export interface IHttpProjectIndex {
-  key: string;
-  name: string;
-  version?: string;
+  key: string
+  name: string
+  version?: string
 }
 
 export interface IProjectCloneOptions {
@@ -145,21 +144,21 @@ export interface IProjectCloneOptions {
    * By default it revalidates (re-creates) keys in the request.
    * Set this to true to not make any changes to the keys.
    */
-  withoutRevalidate?: boolean;
+  withoutRevalidate?: boolean
 }
 
 export interface IFolderListOptions {
   /**
    * Folder name or key to list folders for.
    */
-  folder?: string;
+  folder?: string
 }
 
 export interface ISchemaAddOptions {
   /**
    * Optionally the position at which to add the schema into the list of schemas.
    */
-  index?: number;
+  index?: number
 }
 
 export interface IProjectRequestIterator {
@@ -171,17 +170,17 @@ export interface IProjectRequestIterator {
    * When set it includes requests in the current folder and sub-folder according to the order
    * defined in the folder.
    */
-  recursive?: boolean;
+  recursive?: boolean
   /**
    * Limits the number of requests to include in the iterator.
    * It is an array of request keys or names.
    */
-  requests?: string[];
+  requests?: string[]
   /**
    * The opposite of the `requests`. The list of names or keys of requests or folders to ignore.
    * Note, ignore is tested before the `requests`.
    */
-  ignore?: string[];
+  ignore?: string[]
 }
 
 export interface IProjectFolderIterator {
@@ -193,27 +192,27 @@ export interface IProjectFolderIterator {
    * When set it includes folders in the current folder and sub-folder according to the order
    * defined in the folder.
    */
-  recursive?: boolean;
+  recursive?: boolean
   /**
    * The list of names or keys to ignore.
    */
-  ignore?: string[];
+  ignore?: string[]
 }
 
 export interface IProjectFolderIteratorResult {
   /**
    * The folder.
    */
-  folder: ProjectFolder;
+  folder: ProjectFolder
   /**
    * Optional parent key.
    */
-  parent?: string;
+  parent?: string
   /**
    * How deep in the structure the folder is located.
    * The indent is relative to the `parent`.
    */
-  indent: number;
+  indent: number
 }
 
 /**
@@ -222,71 +221,71 @@ export interface IProjectFolderIteratorResult {
  * using RAML or OAS.
  */
 export interface IHttpProject extends IProjectDefinitionProperty {
-  kind: typeof Kind;
+  kind: typeof Kind
   /**
    * The license information for this HTTP project.
    */
-  license?: ILicense;
+  license?: ILicense
   /**
    * The basic information about the project.
    */
-  info: IThing;
+  info: IThing
   /**
    * Information about project provider.
    */
-  provider?: IProvider;
+  provider?: IProvider
   /**
    * The ordered list of HTTP requests / folders in the projects.
    * The UI uses this to manipulate the view without changing the definitions.
    */
-  items: IProjectItem[];
+  items: IProjectItem[]
   /**
    * The project definitions.
    * This is where all the data are stored.
    */
-  definitions: IHttpProjectDefinitions;
+  definitions: IHttpProjectDefinitions
 }
 
 export interface IHttpProjectDefinitions {
-  requests?: IProjectRequest[];
-  folders?: IProjectFolder[];
-  schemas?: IProjectSchema[];
-  environments?: IEnvironment[];
-  certificates?: HttpCertificate[];
+  requests?: IProjectRequest[]
+  folders?: IProjectFolder[]
+  schemas?: IProjectSchema[]
+  environments?: IEnvironment[]
+  certificates?: HttpCertificate[]
 }
 
 interface HttpProjectDefinitions {
-  requests: ProjectRequest[];
-  folders: ProjectFolder[];
-  schemas: ProjectSchema[];
-  environments: Environment[];
-  certificates: Certificate[];
+  requests: ProjectRequest[]
+  folders: ProjectFolder[]
+  schemas: ProjectSchema[]
+  environments: Environment[]
+  certificates: Certificate[]
 }
 
 /**
  * An instance of an HttpProject.
  */
 export class HttpProject extends ProjectParent {
-  override kind = Kind;
-  private initEnvironments?: Environment[];
+  override kind = Kind
+  private initEnvironments?: Environment[]
   /**
    * The license information for this HTTP project.
    */
-  license?: License;
+  license?: License
   /**
    * Information about project provider.
    */
-  provider?: Provider;
+  provider?: Provider
   /**
    * The list of all requests stored in this project.
    * Note, this is not used to visualized the request in the UI.
    * This is just the source of data.
    * The `items` property is used to build the view.
    */
-  definitions: HttpProjectDefinitions = HttpProject.defaultDefinitions();
+  definitions: HttpProjectDefinitions = HttpProject.defaultDefinitions()
 
   static defaultDefinitions(): HttpProjectDefinitions {
-    return { environments: [], folders: [], requests: [], schemas: [], certificates: [] };
+    return { environments: [], folders: [], requests: [], schemas: [], certificates: [] }
   }
 
   /**
@@ -294,80 +293,81 @@ export class HttpProject extends ProjectParent {
    * @param {string} name The name to set.
    */
   static fromName(name: string): HttpProject {
-    const project = new HttpProject();
-    const info = Thing.fromName(name);
-    project.info = info;
-    return project;
+    const project = new HttpProject()
+    const info = Thing.fromName(name)
+    project.info = info
+    return project
   }
 
   /**
    * Creates an HTTP project instance from ARC's legacy project definition.
    */
   static async fromLegacy(project: ArcLegacyProject, requests: ARCSavedRequest[]): Promise<HttpProject> {
-    const { name = 'Unnamed project', description, requests: ids } = project;
-    const typedLegacyDb = project as ARCProject;
-    const result = HttpProject.fromName(name);
+    const { name = 'Unnamed project', description, requests: ids } = project
+    const typedLegacyDb = project as ARCProject
+    const result = HttpProject.fromName(name)
     if (typedLegacyDb._id) {
-      result.key = typedLegacyDb._id;
+      result.key = typedLegacyDb._id
     }
     if (description) {
-      result.info.description = description;
+      result.info.description = description
     }
     if (Array.isArray(ids) && ids.length) {
       const promises = ids.map(async (id) => {
-        const old = requests.find((item) => item._id === id);
+        const old = requests.find((item) => item._id === id)
         if (!old) {
-          return;
+          return
         }
-        const request = await Request.fromLegacy(old);
-        const projectRequest = ProjectRequest.fromRequest(request.toJSON(), result);
+        const request = await Request.fromLegacy(old)
+        const projectRequest = ProjectRequest.fromRequest(request.toJSON(), result)
         if (old._id) {
-          projectRequest.key = old._id;
+          projectRequest.key = old._id
         }
-        result.addRequest(projectRequest);
-      });
-      await Promise.allSettled(promises);
+        result.addRequest(projectRequest)
+      })
+      await Promise.allSettled(promises)
     }
-    return result;
+    return result
   }
 
   /**
    * Creates an HTTP project from a Postman collection
    * @param init The postman collection object or a string that can be parsed to one.
    */
-  static async fromPostman(init: any): Promise<HttpProject> { 
-    const result = await PostmanDataTransformer.transform(init);
+  static async fromPostman(init: any): Promise<HttpProject> {
+    const result = await PostmanDataTransformer.transform(init)
     if (Array.isArray(result) && result.length > 1) {
-      throw new Error(`Unable to process postman data. It contains multiple collections.`);
+      throw new Error(`Unable to process postman data. It contains multiple collections.`)
     }
-    const project = Array.isArray(result) ? result[0] : result;
-    return project;
+    const project = Array.isArray(result) ? result[0] : result
+    return project
   }
 
   /**
    * Creates a new project from a set of options.
    */
   static fromInitOptions(init: IProjectInitOptions): HttpProject {
-    const { name = 'Unnamed project' } = init;
-    return HttpProject.fromName(name);
+    const { name = 'Unnamed project' } = init
+    return HttpProject.fromName(name)
   }
 
   /**
    * @param input The project definition used to restore the state.
-   * @param environments Optional list of environments to use with this project. It overrides environments stored in the project definition.
+   * @param environments Optional list of environments to use with this project. It overrides
+   *                     environments stored in the project definition.
    */
   constructor(input?: string | IHttpProject, environments?: IEnvironment[]) {
-    super();
+    super()
     if (Array.isArray(environments)) {
-      this.initEnvironments = environments.map(i => new Environment(i));
+      this.initEnvironments = environments.map((i) => new Environment(i))
     }
-    let init: IHttpProject;
+    let init: IHttpProject
     if (typeof input === 'string') {
-      init = JSON.parse(input);
+      init = JSON.parse(input)
     } else if (typeof input === 'object') {
-      init = input;
+      init = input
       if (!init.kind) {
-        init.kind = Kind;
+        init.kind = Kind
       }
     } else {
       init = {
@@ -378,62 +378,62 @@ export class HttpProject extends ProjectParent {
         info: Thing.fromName('').toJSON(),
       }
     }
-    this.new(init);
+    this.new(init)
   }
 
   /**
    * Creates a new project definition clearing anything that is so far defined.
-   * 
+   *
    * Note, this throws an error when the project is not an API Client project.
    */
   new(init: IHttpProject): void {
     if (!init || !init.definitions || !init.items) {
-      throw new Error(`Not a project.`);
+      throw new Error(`Not a project.`)
     }
-    const { key = v4(), definitions = {}, items, info, license, provider } = init;
-    this.key = key;
+    const { key = v4(), definitions = {}, items, info, license, provider } = init
+    this.key = key
     if (license) {
-      this.license = new License(license);
+      this.license = new License(license)
     } else {
-      this.license = undefined;
+      this.license = undefined
     }
     if (provider) {
-      this.provider = new Provider(provider);
+      this.provider = new Provider(provider)
     } else {
-      this.provider = undefined;
+      this.provider = undefined
     }
     if (info) {
-      this.info = new Thing(info);
+      this.info = new Thing(info)
     } else {
-      this.info = Thing.fromName('');
+      this.info = Thing.fromName('')
     }
-    this.items = [];
+    this.items = []
     if (Array.isArray(items)) {
-      this.items = items.map(i => new ProjectItem(this, i));
+      this.items = items.map((i) => new ProjectItem(this, i))
     }
-    this.definitions = HttpProject.defaultDefinitions();
+    this.definitions = HttpProject.defaultDefinitions()
     if (Array.isArray(definitions.environments)) {
-      this.definitions.environments = definitions.environments.map(i => new Environment(i));
+      this.definitions.environments = definitions.environments.map((i) => new Environment(i))
     }
     if (Array.isArray(definitions.requests)) {
-      this.definitions.requests = definitions.requests.map(i => {
-        const instance = new ProjectRequest(this, i);
-        instance.attachedCallback();
-        return instance;
-      });
+      this.definitions.requests = definitions.requests.map((i) => {
+        const instance = new ProjectRequest(this, i)
+        instance.attachedCallback()
+        return instance
+      })
     }
     if (Array.isArray(definitions.folders)) {
-      this.definitions.folders = definitions.folders.map(i => {
-        const instance = new ProjectFolder(this, i);
-        instance.attachedCallback();
-        return instance;
-      });
+      this.definitions.folders = definitions.folders.map((i) => {
+        const instance = new ProjectFolder(this, i)
+        instance.attachedCallback()
+        return instance
+      })
     }
     if (Array.isArray(definitions.schemas)) {
-      this.definitions.schemas = definitions.schemas.map(i => new ProjectSchema(i));
+      this.definitions.schemas = definitions.schemas.map((i) => new ProjectSchema(i))
     }
     if (Array.isArray(definitions.certificates)) {
-      this.definitions.certificates = definitions.certificates.map(i => new Certificate(i));
+      this.definitions.certificates = definitions.certificates.map((i) => new Certificate(i))
     }
   }
 
@@ -444,173 +444,147 @@ export class HttpProject extends ProjectParent {
       definitions: {},
       items: [],
       info: this.info.toJSON(),
-    };
+    }
     if (Array.isArray(this.definitions.environments) && this.definitions.environments.length) {
-      result.definitions.environments = this.definitions.environments.map(i => i.toJSON());
+      result.definitions.environments = this.definitions.environments.map((i) => i.toJSON())
     }
     if (Array.isArray(this.definitions.requests) && this.definitions.requests.length) {
-      result.definitions.requests = this.definitions.requests.map(i => i.toJSON());
+      result.definitions.requests = this.definitions.requests.map((i) => i.toJSON())
     }
     if (Array.isArray(this.definitions.folders) && this.definitions.folders.length) {
-      result.definitions.folders = this.definitions.folders.map(i => i.toJSON());
+      result.definitions.folders = this.definitions.folders.map((i) => i.toJSON())
     }
     if (Array.isArray(this.definitions.schemas) && this.definitions.schemas.length) {
-      result.definitions.schemas = this.definitions.schemas.map(i => i.toJSON());
+      result.definitions.schemas = this.definitions.schemas.map((i) => i.toJSON())
     }
     if (Array.isArray(this.definitions.certificates) && this.definitions.certificates.length) {
-      result.definitions.certificates = this.definitions.certificates.map(i => i.toJSON());
+      result.definitions.certificates = this.definitions.certificates.map((i) => i.toJSON())
     }
     if (Array.isArray(this.items) && this.items.length) {
-      result.items = this.items.map(i => i.toJSON());
+      result.items = this.items.map((i) => i.toJSON())
     }
     if (this.provider) {
-      result.provider = this.provider.toJSON();
+      result.provider = this.provider.toJSON()
     }
     if (this.license) {
-      result.license = this.license.toJSON();
+      result.license = this.license.toJSON()
     }
-    return result;
+    return result
   }
 
   /**
    * @returns JSON representation of the project
    */
   override toString(): string {
-    return JSON.stringify(this);
+    return JSON.stringify(this)
   }
 
   /**
    * Finds a parent of a definition.
-   * 
+   *
    * @param  key The key of the definition.
    * @returns The parent or undefine when not found.
    */
   findParent(key: string): ProjectFolder | HttpProject | undefined {
-    const { definitions, items = [] } = this;
-    const projectItemsIndex = items.findIndex(i => i.key === key);
+    const { definitions, items = [] } = this
+    const projectItemsIndex = items.findIndex((i) => i.key === key)
     if (projectItemsIndex > -1) {
-      return this;
+      return this
     }
-    const definition = definitions.folders.find(i => i.items.some(item => item.key === key));
+    const definition = definitions.folders.find((i) => i.items.some((item) => item.key === key))
     if (definition) {
-      return definition;
+      return definition
     }
-    return undefined;
+    return undefined
   }
 
-  /**
-   * Appends an instance of a folder to a project.
-   * 
-   * @param folder The folder to add to this project.
-   * @param opts Optional folder add options.
-   * @returns The added folder.
-   */
-  addFolder(folder: ProjectFolder, opts?: IFolderCreateOptions): ProjectFolder;
-
-  /**
-   * Appends new folder to a project from a full folder schema.
-   * This is primarily used to insert a folder on the client side
-   * after a folder was created in the store.
-   * 
-   * @param folder The folder schema to add to this project.
-   * @param opts Optional folder add options.
-   * @returns The added folder.
-   */
-  addFolder(folder: IProjectFolder, opts?: IFolderCreateOptions): ProjectFolder;
-
-  /**
-   * Appends a new folder to the project or a sub-folder.
-   * 
-   * @param name The name to set. Optional.
-   * @param opts Folder create options.
-   * @returns The newly inserted folder. If the folder already existed it returns its instance.
-   */
-  addFolder(name?: string, opts?: IFolderCreateOptions): ProjectFolder;
-
   /**
    * Appends a new folder to the project or a sub-folder.
-   * 
+   *
    * Passing the folder schema as the fist argument is primarily used to insert a folder on the client side
    * after a folder was created in the store.
-   * 
+   *
    * @param init The name or a folder schema. When not set a default name is assumed.
    * @param opts Folder create options.
    * @returns The newly inserted folder. If the folder already existed it returns its instance.
    */
-  addFolder(init: string | IProjectFolder | ProjectFolder = ProjectFolder.defaultName, opts: IFolderCreateOptions = {}): ProjectFolder {
+  addFolder(
+    init: string | IProjectFolder | ProjectFolder = ProjectFolder.defaultName,
+    opts: IFolderCreateOptions = {}
+  ): ProjectFolder {
     if (!Array.isArray(this.items)) {
-      this.items = [];
+      this.items = []
     }
     if (!Array.isArray(this.definitions.folders)) {
-      this.definitions.folders = [];
+      this.definitions.folders = []
     }
-    const { skipExisting, parent } = opts;
-    let root: ProjectFolder | HttpProject;
+    const { skipExisting, parent } = opts
+    let root: ProjectFolder | HttpProject
     if (parent) {
-      const rootCandidate = this.findFolder(parent);
+      const rootCandidate = this.findFolder(parent)
       if (!rootCandidate) {
-        throw new Error(`Unable to find the parent folder ${parent}`);
+        throw new Error(`Unable to find the parent folder ${parent}`)
       }
-      root = rootCandidate;
+      root = rootCandidate
     } else {
-      root = this;
+      root = this
     }
-    let definition: ProjectFolder;
+    let definition: ProjectFolder
     if (typeof init === 'string') {
-      definition = ProjectFolder.fromName(this, init);
+      definition = ProjectFolder.fromName(this, init)
     } else if (init instanceof ProjectFolder) {
-      definition = init;
+      definition = init
     } else {
-      definition = new ProjectFolder(this, init);
+      definition = new ProjectFolder(this, init)
     }
     if (skipExisting) {
-      const folders = root.listFolderItems();
+      const folders = root.listFolderItems()
       for (const item of folders) {
-        const existing = this.findFolder(item.key, { keyOnly: true });
+        const existing = this.findFolder(item.key, { keyOnly: true })
         if (existing && existing.info.name === definition.info.name) {
-          return existing;
+          return existing
         }
       }
     }
 
-    this.definitions.folders.push(definition);
-    const item = ProjectItem.projectFolder(this, definition.key);
+    this.definitions.folders.push(definition)
+    const item = ProjectItem.projectFolder(this, definition.key)
     if (!Array.isArray(root.items)) {
-      root.items = [];
+      root.items = []
     }
     if (typeof opts.index === 'number') {
-      root.items.splice(opts.index, 0, item);
+      root.items.splice(opts.index, 0, item)
     } else {
-      root.items.push(item);
+      root.items.push(item)
     }
-    definition.attachedCallback();
-    return definition;
+    definition.attachedCallback()
+    return definition
   }
 
   /**
    * Searches for a folder in the structure.
-   * 
+   *
    * @param nameOrKey The name or the key of the folder.
    * @param opts Optional search options.
    * @returns Found project folder or undefined.
    */
   findFolder(nameOrKey: string, opts: IFolderSearchOptions = {}): ProjectFolder | undefined {
-    const { definitions } = this;
+    const { definitions } = this
     const item = definitions.folders.find((i) => {
       if (i.kind !== ProjectFolderKind) {
-        return false;
+        return false
       }
-      const folder = (i as ProjectFolder);
+      const folder = i as ProjectFolder
       if (folder.key === nameOrKey) {
-        return true;
+        return true
       }
       if (opts.keyOnly) {
-        return false;
+        return false
       }
-      return !!folder.info && folder.info.name === nameOrKey;
-    });
+      return !!folder.info && folder.info.name === nameOrKey
+    })
     if (item) {
-      return item as ProjectFolder;
+      return item as ProjectFolder
     }
   }
 
@@ -621,131 +595,113 @@ export class HttpProject extends ProjectParent {
    * @returns The removed folder definition or undefined when not removed.
    */
   removeFolder(key: string, opts: IFolderDeleteOptions = {}): ProjectFolder | undefined {
-    const { definitions } = this;
-    const folder = this.findFolder(key, { keyOnly: true });
+    const { definitions } = this
+    const folder = this.findFolder(key, { keyOnly: true })
     if (!folder) {
       if (opts.safe) {
-        return undefined;
+        return undefined
       }
-      throw new Error(`Unable to find the folder ${key}`);
+      throw new Error(`Unable to find the folder ${key}`)
     }
-    const parent = this.findParent(key);
+    const parent = this.findParent(key)
     if (!parent) {
       if (opts.safe) {
-        return undefined;
+        return undefined
       }
-      throw new Error(`Unable to find a parent of the folder ${key}`);
+      throw new Error(`Unable to find a parent of the folder ${key}`)
     }
 
-    const requests = folder.listRequests();
-    requests.forEach(r => r.remove());
-    const folders = folder.listFolders();
-    folders.forEach(f => f.remove());
+    const requests = folder.listRequests()
+    requests.forEach((r) => r.remove())
+    const folders = folder.listFolders()
+    folders.forEach((f) => f.remove())
 
-    const itemIndex = parent.items.findIndex(i => i.key === key);
-    const definitionIndex = definitions.folders.findIndex(i => i.key === key);
-    definitions.folders.splice(definitionIndex, 1);
-    folder.detachedCallback();
+    const itemIndex = parent.items.findIndex((i) => i.key === key)
+    const definitionIndex = definitions.folders.findIndex((i) => i.key === key)
+    definitions.folders.splice(definitionIndex, 1)
+    folder.detachedCallback()
     if (itemIndex >= 0) {
-      parent.items.splice(itemIndex, 1);
+      parent.items.splice(itemIndex, 1)
     }
-    return folder;
+    return folder
   }
 
   /**
    * Moves a folder between folders and the project or between items inside a folder or a project
-   * 
+   *
    * Note, when the `parent` option is not specified it moved the folder to the project's root.
-   * 
+   *
    * @param key The key of the request to move.
    * @param opts The moving options.
    */
   moveFolder(key: string, opts: IProjectMoveOptions = {}): void {
-    const { index, parent } = opts;
-    const movedFolder = this.findFolder(key);
+    const { index, parent } = opts
+    const movedFolder = this.findFolder(key)
     if (!movedFolder) {
-      throw new Error(`Unable to locate the folder ${key}`);
+      throw new Error(`Unable to locate the folder ${key}`)
     }
-    const parentFolder = this.findParent(key);
+    const parentFolder = this.findParent(key)
     if (!parentFolder) {
-      throw new Error(`Unable to locate a parent of the folder ${key}`);
+      throw new Error(`Unable to locate a parent of the folder ${key}`)
     }
     if (parent) {
       // check if moving a folder into another folder that is a child of the moved folder.
       if (this.hasChild(parent, key)) {
-        throw new RangeError(`Unable to move a folder to its child.`);
+        throw new RangeError(`Unable to move a folder to its child.`)
       }
     }
-    const target = parent ? this.findFolder(parent) : this;
+    const target = parent ? this.findFolder(parent) : this
     if (!target) {
-      throw new Error(`Unable to locate the new parent folder ${parent}`);
+      throw new Error(`Unable to locate the new parent folder ${parent}`)
     }
-    const hasIndex = typeof index === 'number';
+    const hasIndex = typeof index === 'number'
     if (hasIndex) {
       // comparing to the `.length` and not `.length - 1` in case we are adding at the end.
-      const maxIndex = Math.max(target.items.length, 0);
+      const maxIndex = Math.max(target.items.length, 0)
       if (index > maxIndex) {
-        throw new RangeError(`Index out of bounds. Maximum index is ${maxIndex}.`);
+        throw new RangeError(`Index out of bounds. Maximum index is ${maxIndex}.`)
       }
     }
 
-    const itemIndex = parentFolder.items.findIndex(i => i.key === key);
-    const item = parentFolder.items.splice(itemIndex, 1)[0];
-    movedFolder.detachedCallback();
+    const itemIndex = parentFolder.items.findIndex((i) => i.key === key)
+    const item = parentFolder.items.splice(itemIndex, 1)[0]
+    movedFolder.detachedCallback()
 
     if (hasIndex && target.items.length > index) {
-      target.items.splice(index, 0, item);
+      target.items.splice(index, 0, item)
     } else {
-      target.items.push(item);
+      target.items.push(item)
     }
-    movedFolder.attachedCallback();
+    movedFolder.attachedCallback()
   }
 
   /**
    * Checks whether a folder has a child (anywhere down the structure).
-   * 
+   *
    * @param child The **key** of the child.
    * @param folder The **key** of the folder. When not set it searches from the project root.
    * @returns True when the child is located somewhere down the structure.
    */
   hasChild(child: string, folder?: string): boolean {
-    const target = folder ? this.findFolder(folder) : this;
+    const target = folder ? this.findFolder(folder) : this
     if (!target) {
-      throw new Error(`Unable to locate the folder ${folder}`);
+      throw new Error(`Unable to locate the folder ${folder}`)
     }
-    const { items = [] } = target;
+    const { items = [] } = target
     for (const item of items) {
       if (item.key === child) {
-        return true;
+        return true
       }
       if (item.kind === ProjectFolderKind) {
-        const hasChild = this.hasChild(child, item.key);
+        const hasChild = this.hasChild(child, item.key)
         if (hasChild) {
-          return true;
+          return true
         }
       }
     }
-    return false;
+    return false
   }
 
-  /**
-   * Adds a request to the project or a sub-folder.
-   * 
-   * @param url The URL of the request.
-   * @param opts The request add options.
-   * @returns The inserted into the definitions request.
-   */
-  addRequest(url: string, opts?: IRequestAddOptions): ProjectRequest;
-
-  /**
-   * Adds a request to the project or a sub-folder.
-   * 
-   * @param request The request to add.
-   * @param opts The request add options.
-   * @returns The inserted into the definitions request.
-   */
-  addRequest(request: IProjectRequest | ProjectRequest, opts?: IRequestAddOptions): ProjectRequest;
-
   /**
    * Adds a request to the project or a sub-folder.
    * @param request The request to add.
@@ -754,198 +710,198 @@ export class HttpProject extends ProjectParent {
    */
   addRequest(request: IProjectRequest | ProjectRequest | string, opts: IRequestAddOptions = {}): ProjectRequest {
     if (!Array.isArray(this.definitions.requests)) {
-      this.definitions.requests = [];
+      this.definitions.requests = []
     }
 
-    // the request can be already added to the project as the same method is used to refresh a request after 
+    // the request can be already added to the project as the same method is used to refresh a request after
     // a store update. From the system perspective it is the same event.
 
     if (typeof request === 'object' && request.key) {
-      const existing = this.definitions.requests.find(i => i.key === request.key);
+      const existing = this.definitions.requests.find((i) => i.key === request.key)
       if (existing) {
-        existing.new(request as IProjectRequest);
-        return existing;
+        existing.new(request as IProjectRequest)
+        return existing
       }
     }
 
     // if we got here, it means that we are adding a new request object to the project.
 
-    let finalRequest;
+    let finalRequest
     if (typeof request === 'string') {
-      finalRequest = ProjectRequest.fromUrl(request, this);
+      finalRequest = ProjectRequest.fromUrl(request, this)
     } else if (request instanceof ProjectRequest) {
-      finalRequest = request;
+      finalRequest = request
       if (finalRequest.project && finalRequest.project !== this) {
-        finalRequest.detachedCallback();
+        finalRequest.detachedCallback()
       }
-      finalRequest.project = this;
+      finalRequest.project = this
     } else {
-      finalRequest = new ProjectRequest(this, request);
+      finalRequest = new ProjectRequest(this, request)
     }
     if (!finalRequest.key) {
-      finalRequest.key = v4();
+      finalRequest.key = v4()
     }
 
-    let root: ProjectFolder | HttpProject;
+    let root: ProjectFolder | HttpProject
     if (opts.parent) {
-      const rootCandidate = this.findFolder(opts.parent);
+      const rootCandidate = this.findFolder(opts.parent)
       if (!rootCandidate) {
-        throw new Error(`Unable to find the parent folder ${opts.parent}.`);
+        throw new Error(`Unable to find the parent folder ${opts.parent}.`)
       }
-      root = rootCandidate;
+      root = rootCandidate
     } else {
-      root = this;
+      root = this
     }
 
     if (!Array.isArray(root.items)) {
-      root.items = [];
+      root.items = []
     }
 
     if (typeof opts.index === 'number') {
-      const maxIndex = Math.max(root.items.length - 1, 0);
+      const maxIndex = Math.max(root.items.length - 1, 0)
       if (opts.index > maxIndex) {
-        throw new RangeError(`Index out of bounds. Maximum index is ${maxIndex}.`);
+        throw new RangeError(`Index out of bounds. Maximum index is ${maxIndex}.`)
       }
     }
 
-    this.definitions.requests.push(finalRequest);
-    const item = ProjectItem.projectRequest(this, finalRequest.key);
+    this.definitions.requests.push(finalRequest)
+    const item = ProjectItem.projectRequest(this, finalRequest.key)
 
     if (typeof opts.index === 'number') {
-      root.items.splice(opts.index, 0, item);
+      root.items.splice(opts.index, 0, item)
     } else {
-      root.items.push(item);
+      root.items.push(item)
     }
-    finalRequest.attachedCallback();
-    return finalRequest;
+    finalRequest.attachedCallback()
+    return finalRequest
   }
 
   /**
    * Adds a request to the project that has been created for a previous version of ARC.
-   * 
+   *
    * @param legacy The legacy request definition.
    * @returns The created project request.
    */
   async addLegacyRequest(legacy: ARCSavedRequest | ARCHistoryRequest): Promise<ProjectRequest> {
-    const request = await Request.fromLegacy(legacy);
-    const projectRequest = ProjectRequest.fromRequest(request.toJSON(), this);
-    return this.addRequest(projectRequest);
+    const request = await Request.fromLegacy(legacy)
+    const projectRequest = ProjectRequest.fromRequest(request.toJSON(), this)
+    return this.addRequest(projectRequest)
   }
 
   /**
    * Searches for a request in the project.
-   * 
+   *
    * @param nameOrKey The name or the key of the request.
    * @param opts Optional search options.
    * @returns Found project request or undefined.
    */
   findRequest(nameOrKey: string, opts: IRequestSearchOptions = {}): ProjectRequest | undefined {
-    const { definitions } = this;
+    const { definitions } = this
     const item = definitions.requests.find((request) => {
       if (request.key === nameOrKey) {
-        return true;
+        return true
       }
       if (opts.keyOnly) {
-        return false;
+        return false
       }
-      return !!request.info && request.info.name === nameOrKey;
-    });
+      return !!request.info && request.info.name === nameOrKey
+    })
     if (item) {
-      return item as ProjectRequest;
+      return item as ProjectRequest
     }
-    return undefined;
+    return undefined
   }
 
   /**
    * Removes a request from the project.
-   * 
+   *
    * @param key The request key. It ignores the name when searching to the request to avoid ambiguity.
    * @param opts Request remove options.
    * @returns The removed request definition or undefined when not removed.
    */
   removeRequest(key: string, opts: IRequestDeleteOptions = {}): ProjectRequest | undefined {
-    const { definitions } = this;
-    const request = this.findRequest(key, { keyOnly: true });
+    const { definitions } = this
+    const request = this.findRequest(key, { keyOnly: true })
     if (!request) {
       if (opts.safe) {
-        return undefined;
+        return undefined
       }
-      throw new Error(`Unable to find the request ${key}`);
+      throw new Error(`Unable to find the request ${key}`)
     }
-    const parent = this.findParent(key);
+    const parent = this.findParent(key)
     if (!parent) {
       if (opts.safe) {
-        return undefined;
+        return undefined
       }
-      throw new Error(`Unable to find a parent of the request ${key}`);
+      throw new Error(`Unable to find a parent of the request ${key}`)
     }
-    const itemIndex = parent.items.findIndex(i => i.key === key);
-    const definitionIndex = definitions.requests.findIndex(i => i.key === key);
-    definitions.requests.splice(definitionIndex, 1);
-    request.detachedCallback();
+    const itemIndex = parent.items.findIndex((i) => i.key === key)
+    const definitionIndex = definitions.requests.findIndex((i) => i.key === key)
+    definitions.requests.splice(definitionIndex, 1)
+    request.detachedCallback()
     if (itemIndex >= 0) {
-      parent.items.splice(itemIndex, 1);
+      parent.items.splice(itemIndex, 1)
     }
-    return request;
+    return request
   }
 
   /**
    * Moves a request between folders and the project or between items inside a folder or a project.
-   * 
+   *
    * Note, when the `parent` option is not specified it moved the request to the project's root.
-   * 
+   *
    * @param key The key of the request to move.
    * @param opts The moving options.
    */
   moveRequest(key: string, opts: IProjectMoveOptions = {}): void {
-    const { index, parent } = opts;
-    const request = this.findRequest(key);
+    const { index, parent } = opts
+    const request = this.findRequest(key)
     if (!request) {
-      throw new Error(`Unable to locate the request ${key}`);
+      throw new Error(`Unable to locate the request ${key}`)
     }
-    const parentFolder = this.findParent(key);
+    const parentFolder = this.findParent(key)
     if (!parentFolder) {
-      throw new Error(`Unable to locate a parent of the request ${key}`);
+      throw new Error(`Unable to locate a parent of the request ${key}`)
     }
-    const target = parent ? this.findFolder(parent) : this;
+    const target = parent ? this.findFolder(parent) : this
     if (!target) {
-      throw new Error(`Unable to locate the new parent folder ${parent}`);
+      throw new Error(`Unable to locate the new parent folder ${parent}`)
     }
-    const hasIndex = typeof index === 'number';
+    const hasIndex = typeof index === 'number'
     if (hasIndex) {
       // comparing to the `.length` and not `.length - 1` in case we are adding at the end.
-      const maxIndex = Math.max(target.items.length, 0);
+      const maxIndex = Math.max(target.items.length, 0)
       if (index > maxIndex) {
-        throw new RangeError(`Index out of bounds. Maximum index is ${maxIndex}.`);
+        throw new RangeError(`Index out of bounds. Maximum index is ${maxIndex}.`)
       }
     }
 
-    const itemIndex = parentFolder.items.findIndex(i => i.key === key);
-    const item = parentFolder.items.splice(itemIndex, 1)[0];
-    request.detachedCallback();
+    const itemIndex = parentFolder.items.findIndex((i) => i.key === key)
+    const item = parentFolder.items.splice(itemIndex, 1)[0]
+    request.detachedCallback()
 
     if (hasIndex && target.items.length > index) {
-      target.items.splice(index, 0, item);
+      target.items.splice(index, 0, item)
     } else {
-      target.items.push(item);
+      target.items.push(item)
     }
-    request.attachedCallback();
+    request.attachedCallback()
   }
 
   /**
    * Lists items (not the actual definitions!) that are folders.
    */
   listFolderItems(): ProjectItem[] {
-    const { items = [] } = this;
-    return items.filter(i => i.kind === ProjectFolderKind);
+    const { items = [] } = this
+    return items.filter((i) => i.kind === ProjectFolderKind)
   }
 
   /**
    * Lists items (not the actual definitions!) that are requests.
    */
   listRequestItems(): ProjectItem[] {
-    const { items = [] } = this;
-    return items.filter(i => i.kind === ProjectRequestKind);
+    const { items = [] } = this
+    return items.filter((i) => i.kind === ProjectRequestKind)
   }
 
   /**
@@ -953,26 +909,26 @@ export class HttpProject extends ProjectParent {
    * @param opts Folder listing options.
    */
   listFolders(opts: IFolderListOptions = {}): ProjectFolder[] {
-    let root;
+    let root
     if (opts.folder) {
-      const parent = this.findFolder(opts.folder);
+      const parent = this.findFolder(opts.folder)
       if (!parent) {
-        throw new Error(`Unable to find the folder ${opts.folder}.`);
+        throw new Error(`Unable to find the folder ${opts.folder}.`)
       }
-      root = parent;
+      root = parent
     } else {
-      root = this;
+      root = this
     }
-    const items = root.listFolderItems();
-    const result: ProjectFolder[] = [];
-    const { definitions } = this;
+    const items = root.listFolderItems()
+    const result: ProjectFolder[] = []
+    const { definitions } = this
     items.forEach((i) => {
-      const definition = definitions.folders.find(d => i.key === d.key);
+      const definition = definitions.folders.find((d) => i.key === d.key)
       if (definition) {
-        result.push(definition);
+        result.push(definition)
       }
-    });
-    return result;
+    })
+    return result
   }
 
   /**
@@ -980,26 +936,26 @@ export class HttpProject extends ProjectParent {
    * @param folder The optional folder name or the key to list requests for.
    */
   listRequests(folder?: string): ProjectRequest[] {
-    let root;
+    let root
     if (folder) {
-      const parent = this.findFolder(folder);
+      const parent = this.findFolder(folder)
       if (!parent) {
-        throw new Error(`Unable to find the folder ${folder}.`);
+        throw new Error(`Unable to find the folder ${folder}.`)
       }
-      root = parent;
+      root = parent
     } else {
-      root = this;
+      root = this
     }
-    const items = root.listRequestItems();
-    const result: ProjectRequest[] = [];
-    const { definitions } = this;
+    const items = root.listRequestItems()
+    const result: ProjectRequest[] = []
+    const { definitions } = this
     items.forEach((i) => {
-      const definition = definitions.requests.find(d => i.key === d.key);
+      const definition = definitions.requests.find((d) => i.key === d.key)
       if (definition) {
-        result.push(definition);
+        result.push(definition)
       }
-    });
-    return result;
+    })
+    return result
   }
 
   /**
@@ -1007,33 +963,33 @@ export class HttpProject extends ProjectParent {
    * @param folder Optionally the folder name to list the definitions for.
    */
   listDefinitions(folder?: string): (ProjectFolder | ProjectRequest | Environment)[] {
-    let root;
+    let root
     if (folder) {
-      const parent = this.findFolder(folder);
+      const parent = this.findFolder(folder)
       if (!parent) {
-        throw new Error(`Unable to find the folder ${folder}`);
+        throw new Error(`Unable to find the folder ${folder}`)
       }
-      root = parent;
+      root = parent
     } else {
-      root = this;
+      root = this
     }
-    const result: (ProjectFolder | ProjectRequest | Environment)[] = [];
-    const { items = [] } = root;
-    const { definitions } = this;
+    const result: (ProjectFolder | ProjectRequest | Environment)[] = []
+    const { items = [] } = root
+    const { definitions } = this
     items.forEach((item) => {
-      let definition: ProjectFolder | ProjectRequest | Environment | undefined;
+      let definition: ProjectFolder | ProjectRequest | Environment | undefined
       if (item.kind === ProjectFolderKind) {
-        definition = definitions.folders.find(d => item.key === d.key);
+        definition = definitions.folders.find((d) => item.key === d.key)
       } else if (item.kind === ProjectRequestKind) {
-        definition = definitions.requests.find(d => item.key === d.key);
+        definition = definitions.requests.find((d) => item.key === d.key)
       } else if (item.kind === EnvironmentKind) {
-        definition = definitions.environments.find(d => item.key === d.key);
+        definition = definitions.environments.find((d) => item.key === d.key)
       }
       if (definition) {
-        result.push(definition);
+        result.push(definition)
       }
-    });
-    return result;
+    })
+    return result
   }
 
   /**
@@ -1042,9 +998,9 @@ export class HttpProject extends ProjectParent {
    */
   ensureLicense(): License {
     if (!this.license) {
-      this.license = new License();
+      this.license = new License()
     }
-    return this.license;
+    return this.license
   }
 
   /**
@@ -1053,16 +1009,16 @@ export class HttpProject extends ProjectParent {
    */
   ensureProvider(): Provider {
     if (!this.provider) {
-      this.provider = new Provider();
+      this.provider = new Provider()
     }
-    return this.provider;
+    return this.provider
   }
 
   /**
    * @returns On the project level this always returns undefined.
    */
   getParent(): ProjectFolder | HttpProject | undefined {
-    return undefined;
+    return undefined
   }
 
   attachedCallback(): void {
@@ -1074,142 +1030,124 @@ export class HttpProject extends ProjectParent {
   }
 
   getProject(): HttpProject {
-    return this;
+    return this
   }
 
   /**
    * Makes a copy of this project.
    */
   clone(opts: IProjectCloneOptions = {}): HttpProject {
-    const copy = new HttpProject(this.toJSON());
+    const copy = new HttpProject(this.toJSON())
     if (!opts.withoutRevalidate) {
-      copy.key = v4();
-      HttpProject.regenerateKeys(copy);
+      copy.key = v4()
+      HttpProject.regenerateKeys(copy)
     }
-    return copy;
+    return copy
   }
 
   static clone(project: IHttpProject, opts: IProjectCloneOptions = {}): HttpProject {
-    const obj = new HttpProject(project);
-    return obj.clone(opts);
+    const obj = new HttpProject(project)
+    return obj.clone(opts)
   }
 
   /**
    * Re-generates keys in the project, taking care of the references.
-   * 
+   *
    * Note, this changes the project properties. Make a copy of the project before calling this.
-   * 
+   *
    * @param src The project instance to re-generate keys for.
    */
   static regenerateKeys(src: HttpProject): void {
-    const { items = [], definitions } = src;
+    const { items = [], definitions } = src
     // create a flat list of all "items" in the project and all folders.
-    let flatItems = [...items];
-    (definitions.folders || []).forEach((folder) => {
+    let flatItems = [...items]
+    ;(definitions.folders || []).forEach((folder) => {
       if (Array.isArray(folder.items) && folder.items.length) {
-        flatItems = flatItems.concat(folder.items);
+        flatItems = flatItems.concat(folder.items)
       }
-    });
-    (definitions.folders || []).forEach((folder) => {
-      const oldKey = folder.key;
-      const indexObject = flatItems.find(i => i.key === oldKey);
+    })
+    ;(definitions.folders || []).forEach((folder) => {
+      const oldKey = folder.key
+      const indexObject = flatItems.find((i) => i.key === oldKey)
       if (!indexObject) {
-        return;
+        return
       }
-      const newKey = v4();
-      indexObject.key = newKey;
-      folder.key = newKey;
-    });
-    (definitions.requests || []).forEach((request) => {
-      const oldKey = request.key;
-      const indexObject = flatItems.find(i => i.key === oldKey);
+      const newKey = v4()
+      indexObject.key = newKey
+      folder.key = newKey
+    })
+    ;(definitions.requests || []).forEach((request) => {
+      const oldKey = request.key
+      const indexObject = flatItems.find((i) => i.key === oldKey)
       if (!indexObject) {
-        return;
+        return
       }
-      const newKey = v4();
-      indexObject.key = newKey;
-      request.key = newKey;
-    });
-    (definitions.schemas || []).forEach((schema) => {
-      schema.key = v4();
-    });
-    (definitions.certificates || []).forEach((cert) => {
-      cert.key = v4();
-    });
-    (definitions.environments || []).forEach((environment) => {
-      const oldKey = environment.key;
-      const indexObject = flatItems.find(i => i.key === oldKey);
+      const newKey = v4()
+      indexObject.key = newKey
+      request.key = newKey
+    })
+    ;(definitions.schemas || []).forEach((schema) => {
+      schema.key = v4()
+    })
+    ;(definitions.certificates || []).forEach((cert) => {
+      cert.key = v4()
+    })
+    ;(definitions.environments || []).forEach((environment) => {
+      const oldKey = environment.key
+      const indexObject = flatItems.find((i) => i.key === oldKey)
       if (!indexObject) {
-        return;
+        return
       }
-      const newKey = v4();
-      indexObject.key = newKey;
-      environment.key = newKey;
-    });
+      const newKey = v4()
+      indexObject.key = newKey
+      environment.key = newKey
+    })
   }
 
-  /**
-   * Adds an empty schema to the project.
-   * 
-   * @param name The name of the schema
-   * @param opts The schema add options.
-   * @returns The inserted into the schemas schema.
-   */
-  addSchema(name: string, opts?: ISchemaAddOptions): ProjectSchema;
-
-  /**
-   * Adds a schema to the project.
-   * 
-   * @param schema The schema to add.
-   * @param opts The schema add options.
-   * @returns The inserted into the schemas schema.
-   */
-  addSchema(schema: IProjectSchema | ProjectSchema, opts?: ISchemaAddOptions): ProjectSchema;
-
   /**
    * Adds a request to the project or a sub-folder.
-   * @param schema The schema to add.
+   * @param schema The schema to add or a name of the schema.
    * @param opts Thew schema add options.
    * @returns The inserted into the schemas schema.
    */
   addSchema(schema: IProjectSchema | ProjectSchema | string, opts: ISchemaAddOptions = {}): ProjectSchema {
     if (!Array.isArray(this.definitions.schemas)) {
-      this.definitions.schemas = [];
+      this.definitions.schemas = []
     }
 
     // this renews existing schema
     if (typeof schema === 'object' && schema.key) {
-      const existing = this.definitions.schemas.find(i => i.key === schema.key) as ProjectSchema | undefined;
+      const existing = this.definitions.schemas.find((i) => i.key === schema.key) as ProjectSchema | undefined
       if (existing) {
-        existing.new(schema as IProjectSchema);
-        return existing;
+        existing.new(schema as IProjectSchema)
+        return existing
       }
     }
 
-    let finalSchema: ProjectSchema;
+    let finalSchema: ProjectSchema
     if (typeof schema === 'string') {
-      finalSchema = ProjectSchema.fromName(schema);
+      finalSchema = ProjectSchema.fromName(schema)
     } else if (schema instanceof ProjectSchema) {
-      finalSchema = schema;
+      finalSchema = schema
     } else {
-      finalSchema = new ProjectSchema(schema);
+      finalSchema = new ProjectSchema(schema)
     }
     if (!finalSchema.key) {
-      finalSchema.key = v4();
+      finalSchema.key = v4()
     }
-    const { index } = opts;
-    const hasIndex = typeof index === 'number';
+    const { index } = opts
+    const hasIndex = typeof index === 'number'
     if (hasIndex && this.definitions.schemas.length > index) {
       // comparing to the `.length` and not `.length - 1` in case we are adding at the end.
-      const maxIndex = Math.max(this.definitions.schemas.length, 0);
+      const maxIndex = Math.max(this.definitions.schemas.length, 0)
       if (index > maxIndex) {
-        throw new RangeError(`Index out of bounds. Maximum index is ${maxIndex}.`);
+        throw new RangeError(`Index out of bounds. Maximum index is ${maxIndex}.`)
       }
-      this.definitions.schemas.splice(index, 0, finalSchema);
+      this.definitions.schemas.splice(index, 0, finalSchema)
     } else {
-      this.definitions.schemas.push(finalSchema);
+      this.definitions.schemas.push(finalSchema)
     }
-    return finalSchema;
+    return finalSchema
   }
 
   /**
@@ -1217,59 +1155,59 @@ export class HttpProject extends ProjectParent {
    */
   listSchemas(): ProjectSchema[] {
     if (!Array.isArray(this.definitions.schemas)) {
-      return [];
+      return []
     }
-    return this.definitions.schemas;
+    return this.definitions.schemas
   }
 
   /**
    * Iterates over requests in the project.
    */
-  * requestIterator(opts: IProjectRequestIterator = {}): Generator<ProjectRequest> {
-    const { definitions } = this;
-    const { ignore=[], parent, recursive, requests=[] } = opts;
-    const root = parent ? this.findFolder(parent) : this;
+  *requestIterator(opts: IProjectRequestIterator = {}): Generator<ProjectRequest> {
+    const { definitions } = this
+    const { ignore = [], parent, recursive, requests = [] } = opts
+    const root = parent ? this.findFolder(parent) : this
     if (!root) {
-      throw new Error(`The parent folder not found: ${parent}.`);
+      throw new Error(`The parent folder not found: ${parent}.`)
     }
-    const items = root.items;
+    const items = root.items
     if (!items || !items.length) {
-      return;
+      return
     }
     for (const item of items) {
       if (ignore.includes(item.key)) {
-        continue;
+        continue
       }
       if (item.kind === ProjectRequestKind) {
-        const request = definitions.requests.find(i => i.key === item.key);
+        const request = definitions.requests.find((i) => i.key === item.key)
         if (!request) {
-          continue;
+          continue
         }
-        const name = request.info.name || '';
+        const name = request.info.name || ''
         if (ignore.includes(name)) {
-          continue;
+          continue
         }
         if (requests.length && !requests.includes(item.key) && !requests.includes(name)) {
-          continue;
+          continue
         }
-        yield request;
+        yield request
       } else if (recursive && item.kind === ProjectFolderKind) {
-        const folder = definitions.folders.find(i => i.key === item.key);
+        const folder = definitions.folders.find((i) => i.key === item.key)
         if (!folder) {
-          continue;
+          continue
         }
-        const name = folder.info.name || '';
+        const name = folder.info.name || ''
         if (ignore.includes(name)) {
-          continue;
+          continue
         }
         const it = this.requestIterator({
           parent: item.key,
           recursive,
           ignore,
           requests,
-        });
+        })
         for (const request of it) {
-          yield request;
+          yield request
         }
       }
     }
@@ -1277,50 +1215,53 @@ export class HttpProject extends ProjectParent {
 
   /**
    * Iterates over folders in the project.
-   * 
+   *
    * @param opts Iterator configuration options
    * @param indent Used internally to add `indent` to the result
    * @returns Iterator that yields when a folder is found, including all sub-folders (if configured).
    */
-  * folderIterator(opts: IProjectFolderIterator={}, indent=0): Generator<IProjectFolderIteratorResult> {
-    const { definitions } = this;
-    const { ignore=[], parent, recursive } = opts;
-    const root = parent ? this.findFolder(parent) : this;
+  *folderIterator(opts: IProjectFolderIterator = {}, indent = 0): Generator<IProjectFolderIteratorResult> {
+    const { definitions } = this
+    const { ignore = [], parent, recursive } = opts
+    const root = parent ? this.findFolder(parent) : this
     if (!root) {
-      throw new Error(`The parent folder not found: ${parent}.`);
+      throw new Error(`The parent folder not found: ${parent}.`)
     }
-    const items = root.items;
+    const items = root.items
     if (!items || !items.length) {
-      return;
+      return
     }
     for (const item of items) {
       if (item.kind !== ProjectFolderKind) {
-        continue;
+        continue
       }
-      const folder = definitions.folders.find(i => i.key === item.key);
+      const folder = definitions.folders.find((i) => i.key === item.key)
       if (!folder) {
         // missing definition.
-        continue;
+        continue
       }
       if (ignore.includes(folder.key) || (folder.info.name && ignore.includes(folder.info.name))) {
-        continue;
+        continue
       }
       const result: IProjectFolderIteratorResult = {
         folder,
         indent,
       }
       if (parent) {
-        result.parent = parent;
+        result.parent = parent
       }
-      yield result;
+      yield result
       if (recursive) {
-        const it = this.folderIterator({
-          parent: folder.key,
-          recursive,
-          ignore,
-        }, indent + 1);
+        const it = this.folderIterator(
+          {
+            parent: folder.key,
+            recursive,
+            ignore,
+          },
+          indent + 1
+        )
         for (const f of it) {
-          yield f;
+          yield f
         }
       }
     }
@@ -1329,7 +1270,7 @@ export class HttpProject extends ProjectParent {
   [Symbol.iterator](): Generator<ProjectRequest> {
     return this.requestIterator({
       recursive: true,
-    });
+    })
   }
 
   /**
@@ -1337,152 +1278,129 @@ export class HttpProject extends ProjectParent {
    * It throws when parent folder cannot ber found.
    */
   protected _getRoot(opts: IItemOptions): ProjectFolder | HttpProject {
-    const project = this.getProject();
+    const project = this.getProject()
     if (opts.parent) {
-      const parent = project.findFolder(opts.parent);
+      const parent = project.findFolder(opts.parent)
       if (!parent) {
-        throw new Error(`Unable to find the parent folder ${opts.parent}.`);
+        throw new Error(`Unable to find the parent folder ${opts.parent}.`)
       }
-      return parent;
+      return parent
     }
-    return project;
+    return project
   }
 
   protected _insertItem(item: ProjectItem, root: ProjectFolder | HttpProject, opts: IItemCreateOptions): void {
     if (!Array.isArray(root.items)) {
-      root.items = [];
+      root.items = []
     }
     if (typeof opts.index === 'number') {
-      root.items.splice(opts.index, 0, item);
+      root.items.splice(opts.index, 0, item)
     } else {
-      root.items.push(item);
+      root.items.push(item)
     }
   }
 
   /**
    * Adds an environment to the project.
-   * 
-   * @param env The definition of the environment to use to create the environment
-   * @returns The same or created environment.
-   */
-  addEnvironment(env: IEnvironment, opts?: IEnvironmentCreateOptions): Environment;
-
-  /**
-   * Adds an environment to the project.
-   * 
-   * @param env The instance of the environment to add
-   * @returns The same or created environment.
-   */
-  addEnvironment(env: Environment, opts?: IEnvironmentCreateOptions): Environment;
-
-  /**
-   * Adds an environment to the project.
-   * 
-   * @param env The name of the environment to create
-   * @returns The same or created environment.
-   */
-  addEnvironment(env: string, opts?: IEnvironmentCreateOptions): Environment;
-
-  /**
-   * Adds an environment to the project.
+   * @param env The name of the environment to create or its schema
    * @returns The same or created environment.
    */
   addEnvironment(env: IEnvironment | Environment | string, opts: IEnvironmentCreateOptions = {}): Environment {
-    const environment = this._createEnv(env);
-    const root = this._getRoot(opts);
-    const project = this.getProject();
+    const environment = this._createEnv(env)
+    const root = this._getRoot(opts)
+    const project = this.getProject()
     if (!project.definitions.environments) {
-      project.definitions.environments = [];
+      project.definitions.environments = []
     }
-    project.definitions.environments.push(environment);
-    const item = ProjectItem.projectEnvironment(project, environment.key);
+    project.definitions.environments.push(environment)
+    const item = ProjectItem.projectEnvironment(project, environment.key)
     this._insertItem(item, root, opts)
-    return environment;
+    return environment
   }
 
   protected _createEnv(env: IEnvironment | Environment | string): Environment {
-    let finalEnv: Environment;
+    let finalEnv: Environment
     if (env instanceof Environment) {
-      finalEnv = env;
+      finalEnv = env
     } else if (typeof env === 'string') {
-      finalEnv = Environment.fromName(env);
+      finalEnv = Environment.fromName(env)
     } else {
-      finalEnv = new Environment(env);
+      finalEnv = new Environment(env)
     }
     if (!finalEnv.key) {
-      finalEnv.key = v4();
+      finalEnv.key = v4()
     }
-    return finalEnv;
+    return finalEnv
   }
 
   /**
    * This is different to `readEnvironments()`. While the `readEnvironments()`
    * function generate a list of all environments that apply to a folder, this method
    * just lists this folder's environments.
-   * 
+   *
    * @returns The list of environments defined in this folder
    */
   getEnvironments(opts: IItemOptions = {}): Environment[] {
     if (Array.isArray(this.initEnvironments)) {
-      return this.initEnvironments;
+      return this.initEnvironments
     }
-    return this.listEnvironments(opts);
+    return this.listEnvironments(opts)
   }
 
   /**
    * @param key The environment key to read.
    */
   getEnvironment(key: string, opts: IItemOptions = {}): Environment | undefined {
-    const root = this._getRoot(opts);
-    const item = root.items.find(i => i.key === key);
+    const root = this._getRoot(opts)
+    const item = root.items.find((i) => i.key === key)
     if (!item) {
-      return undefined;
+      return undefined
     }
-    const project = this.getProject();
+    const project = this.getProject()
     if (!Array.isArray(project.definitions.environments)) {
-      project.definitions.environments = [];
+      project.definitions.environments = []
     }
-    return project.definitions.environments.find(e => e.key === key);
+    return project.definitions.environments.find((e) => e.key === key)
   }
 
   /**
    * Removes an environment from the folder or a sub-folder.
-   * 
+   *
    * @param key the key of the environment to remove
    * @returns The removed environment, if any.
    */
   removeEnvironment(key: string, opts: IItemOptions = {}): Environment | undefined {
-    const root = this._getRoot(opts);
-    const itemIndex = root.items.findIndex(i => i.key === key);
+    const root = this._getRoot(opts)
+    const itemIndex = root.items.findIndex((i) => i.key === key)
     if (itemIndex < 0) {
-      return undefined;
+      return undefined
     }
-    root.items.splice(itemIndex, 1);
-    const project = this.getProject();
+    root.items.splice(itemIndex, 1)
+    const project = this.getProject()
     if (!Array.isArray(project.definitions.environments)) {
-      project.definitions.environments = [];
+      project.definitions.environments = []
     }
-    const defIndex = project.definitions.environments.findIndex(i => i.key === key);
+    const defIndex = project.definitions.environments.findIndex((i) => i.key === key)
     if (defIndex < 0) {
-      return undefined;
+      return undefined
     }
-    const env = project.definitions.environments[defIndex];
-    project.definitions.environments.splice(defIndex, 1);
-    return env;
+    const env = project.definitions.environments[defIndex]
+    project.definitions.environments.splice(defIndex, 1)
+    return env
   }
 
   /**
-   * This is a link to the `getEnvironments()`. The difference is that on the 
+   * This is a link to the `getEnvironments()`. The difference is that on the
    * project level it won't return environments defined with the class initialization.
    */
   listEnvironments(opts: IItemOptions = {}): Environment[] {
-    const root = this._getRoot(opts);
-    const items = root.items.filter(i => i.kind === EnvironmentKind).map(i => i.key);
-    const project = this.getProject();
+    const root = this._getRoot(opts)
+    const items = root.items.filter((i) => i.kind === EnvironmentKind).map((i) => i.key)
+    const project = this.getProject()
     if (!Array.isArray(project.definitions.environments)) {
-      project.definitions.environments = [];
+      project.definitions.environments = []
     }
-    return project.definitions.environments.filter(e => items.includes(e.key));
+    return project.definitions.environments.filter((e) => items.includes(e.key))
   }
 
   /**
@@ -1490,93 +1408,93 @@ export class HttpProject extends ProjectParent {
    * It stops going up in the project structure when selected environment has the `encapsulated`
    * property set to true.
    * The environments are ordered from the top-most level to the selected folder.
-   * 
+   *
    * @param opts The environment read options
    */
   readEnvironments(opts: IReadEnvironmentOptions = {}): Environment[] {
-    const result: Environment[] = [];
-    const { parent, nameOrKey } = opts;
+    const result: Environment[] = []
+    const { parent, nameOrKey } = opts
 
-    const root = parent ? this.findFolder(parent, { keyOnly: true }) : this;
+    const root = parent ? this.findFolder(parent, { keyOnly: true }) : this
     if (!root) {
-      return result;
+      return result
     }
 
-    let current: HttpProject | ProjectFolder | undefined = root;
+    let current: HttpProject | ProjectFolder | undefined = root
     while (current) {
-      const environments = current.getEnvironments();
+      const environments = current.getEnvironments()
       if (environments.length) {
         if (nameOrKey) {
-          const selected = environments.find(i => i.key === nameOrKey || i.info.name === nameOrKey);
+          const selected = environments.find((i) => i.key === nameOrKey || i.info.name === nameOrKey)
           if (selected) {
-            result.push(selected);
+            result.push(selected)
             if (selected.encapsulated) {
-              break;
+              break
             }
           }
         } else {
-          let finished = false;
+          let finished = false
           for (const item of environments) {
-            result.push(item);
+            result.push(item)
             if (item.encapsulated) {
-              finished = true;
-              break;
+              finished = true
+              break
             }
           }
           if (finished) {
-            break;
+            break
           }
         }
       }
-      current = current.getParent();
+      current = current.getParent()
     }
 
-    return result.reverse();
+    return result.reverse()
   }
 
   /**
    * Finds a definition for an environment regardless of its parent.
-   * 
+   *
    * @param key The Key of the environment to find.
    * @returns The environment definition or undefined if not found.
    */
   findEnvironment(key: string): Environment | undefined {
-    return this.definitions.environments.find(i => i.key === key);
+    return this.definitions.environments.find((i) => i.key === key)
   }
 
   /**
    * Finds a definition for a certificate.
-   * 
+   *
    * @param key The key of the certificate to find.
    * @returns The certificate definition or undefined if not found.
    */
   findCertificate(key: string): Certificate | undefined {
-    return this.definitions.certificates.find(i => i.key === key);
+    return this.definitions.certificates.find((i) => i.key === key)
   }
 
   /**
    * Adds a certificate to the project.
-   * 
+   *
    * @param init Either an instance of a certificate or its definition.
    * @returns The inserted certificate.
    */
   addCertificate(init: Certificate | HttpCertificate): Certificate {
-    let finalCert: Certificate;
+    let finalCert: Certificate
     if (init instanceof Certificate) {
-      finalCert = init;
+      finalCert = init
     } else {
-      finalCert = new Certificate(init);
+      finalCert = new Certificate(init)
     }
     if (!this.definitions.certificates) {
-      this.definitions.certificates = [];
+      this.definitions.certificates = []
     }
-    this.definitions.certificates.push(finalCert);
-    return finalCert;
+    this.definitions.certificates.push(finalCert)
+    return finalCert
   }
 
   /**
    * Removes a certificate from the project.
-   * 
+   *
    * @param key the key of the certificate to remove
    * @returns The removed certificate, if any.
    */
@@ -1584,32 +1502,32 @@ export class HttpProject extends ProjectParent {
     if (!Array.isArray(this.definitions.certificates)) {
       return undefined
     }
-    const defIndex = this.definitions.certificates.findIndex(i => i.key === key);
+    const defIndex = this.definitions.certificates.findIndex((i) => i.key === key)
     if (defIndex < 0) {
-      return undefined;
+      return undefined
     }
-    const cert = this.definitions.certificates[defIndex];
-    this.definitions.certificates.splice(defIndex, 1);
-    return cert;
+    const cert = this.definitions.certificates[defIndex]
+    this.definitions.certificates.splice(defIndex, 1)
+    return cert
   }
 
   /**
    * Finds the requests that are using the certificate identified by the key.
-   * 
+   *
    * @param key The key of the certificate to find the usage for.
    * @returns The list of requests that use this certificate.
    */
   findCertificateRequests(key: string): ProjectRequest[] {
     return this.definitions.requests.filter((request) => {
       if (!Array.isArray(request.authorization)) {
-        return false;
+        return false
       }
-      const ccAuth = request.authorization.find(auth => auth.type === 'client certificate');
+      const ccAuth = request.authorization.find((auth) => auth.type === 'client certificate')
       if (!ccAuth) {
-        return false;
+        return false
       }
-      const cnf = ccAuth.config as ICCAuthorization;
-      return !!cnf && !!cnf.certificate && cnf.certificate.key === key;
-    });
+      const cnf = ccAuth.config as ICCAuthorization
+      return !!cnf && !!cnf.certificate && cnf.certificate.key === key
+    })
   }
 }