@asyncapi/generator 1.9.14 → 1.9.16

package/CODEOWNERS

@@ -7,3 +7,6 @@
 # The default owners are automatically added as reviewers when you open a pull request unless different owners are specified in the file.
 
 * @fmvilas @derberg @magicmatatjahu @jonaslagoni @asyncapi-bot-eve
+
+# All .md files
+*.md @Florence-Njeri @pratik2315

package/README.md

@@ -64,15 +64,15 @@ Install both packages using [official installer](https://nodejs.org/en/download/
 ## Using from the command-line interface (CLI)
 
 ### CLI installation
-Learn to install the AsyncAPI CLI from the [installation guide](installation-guide.md).
+Learn to install the AsyncAPI CLI from the [installation guide](docs/installation-guide.md).
 
 ### CLI usage 
 
-Learn more about different ways of using the CLI from the [usage document](usage.md).
+Learn more about different ways of using the CLI from the [usage document](docs/usage.md).
 
 ## Generator version vs Template version
 
-Learn more about versioning from the [versioning document](versioning.md).
+Learn more about versioning from the [versioning document](docs/versioning.md).
 
 ## How to create a template
 
@@ -109,6 +109,8 @@ Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/d
   </tr>
   <tr>
     <td align="center"><a href="https://github.com/lkmandy"><img src="https://avatars.githubusercontent.com/u/17765231?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Amanda  Shafack </b></sub></a><br /><a href="https://github.com/asyncapi/generator/commits?author=lkmandy" title="Documentation">📖</a></td>
+    <td align="center"><a href="https://github.com/Florence-Njeri"><img src="https://avatars.githubusercontent.com/u/40742916?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Florence Njeri</b></sub></a><br /><a href="https://github.com/asyncapi/generator/commits?author=Florence-Njeri" title="Documentation">📖</a> <a href="https://github.com/asyncapi/generator/pulls?q=is%3Apr+reviewed-by%3AFlorence-Njeri" title="Reviewed Pull Requests">👀</a> <a href="#infra-Florence-Njeri" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a> <a href="#maintenance-Florence-Njeri" title="Maintenance">🚧</a></td>
+    <td align="center"><a href="https://unruffled-goodall-dd424e.netlify.app/"><img src="https://avatars.githubusercontent.com/u/77961530?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Pratik Haldankar</b></sub></a><br /><a href="https://github.com/asyncapi/generator/commits?author=pratik2315" title="Documentation">📖</a> <a href="https://github.com/asyncapi/generator/pulls?q=is%3Apr+reviewed-by%3Apratik2315" title="Reviewed Pull Requests">👀</a> <a href="#maintenance-pratik2315" title="Maintenance">🚧</a> <a href="#talk-pratik2315" title="Talks">📢</a></td>
   </tr>
 </table>
 

package/docs/README.md

@@ -1,17 +1,17 @@
 Table of Contents
 
 - [Introduction](index.md)
-- [AsyncAPI document](asyncapi-document.md)
 - [Installation Guide](installation-guide.md)
 - [Usage](usage.md)
-- [Configuration File](configuration-file.md)
-- [Templates](template.md)
-- [Authoring templates](authoring-templates.md)
+- [AsyncAPI document](asyncapi-document.md)
+- [Template](template.md)
+- [Parser](parser.md)
 - [Generator version vs template version](versioning.md)
+- [Template Development](template-development.md)
+- [Configuration File](configuration-file.md)
+- [Template context](template-context.md)
 - [React render engine](react-render-engine.md)
 - [Nunjucks render engine](nunjucks-render-engine.md)
-- [Template context](template-context.md)
-- [Parser](parser.md)
 - [Hooks](hooks.md)
 - [File templates](file-templates.md)
 - [TypeScript support](typescript-support.md)

package/docs/api.md

@@ -1,3 +1,10 @@
+---
+title: Library API
+weight: 75
+---
+
+Reference API documentation for AsyncAPI Generator library.
+
 <a name="Generator"></a>
 
 ## Generator
@@ -6,49 +13,49 @@
 * [Generator](#Generator)
     * [new Generator(templateName, targetDir, options)](#new_Generator_new)
     * _instance_
-        * [.templateName](#Generator+templateName) : <code>String</code>
-        * [.targetDir](#Generator+targetDir) : <code>String</code>
-        * [.entrypoint](#Generator+entrypoint) : <code>String</code>
-        * [.noOverwriteGlobs](#Generator+noOverwriteGlobs) : <code>Array.&lt;String&gt;</code>
-        * [.disabledHooks](#Generator+disabledHooks) : <code>Object.&lt;String, (Boolean\|String\|Array.&lt;String&gt;)&gt;</code>
-        * [.output](#Generator+output) : <code>String</code>
-        * [.forceWrite](#Generator+forceWrite) : <code>Boolean</code>
-        * [.debug](#Generator+debug) : <code>Boolean</code>
-        * [.install](#Generator+install) : <code>Boolean</code>
-        * [.templateConfig](#Generator+templateConfig) : <code>Object</code>
-        * [.hooks](#Generator+hooks) : <code>Object</code>
-        * [.mapBaseUrlToFolder](#Generator+mapBaseUrlToFolder) : <code>Object</code>
-        * [.templateParams](#Generator+templateParams) : <code>Object</code>
-        * [.originalAsyncAPI](#Generator+originalAsyncAPI) : <code>String</code>
-        * [.generate(asyncapiDocument)](#Generator+generate) ⇒ <code>Promise</code>
+        * [.templateName](#Generator+templateName) : `String`
+        * [.targetDir](#Generator+targetDir) : `String`
+        * [.entrypoint](#Generator+entrypoint) : `String`
+        * [.noOverwriteGlobs](#Generator+noOverwriteGlobs) : `Array.<String>`
+        * [.disabledHooks](#Generator+disabledHooks) : `Object.<String, (Boolean|String|Array.<String>)>`
+        * [.output](#Generator+output) : `String`
+        * [.forceWrite](#Generator+forceWrite) : `Boolean`
+        * [.debug](#Generator+debug) : `Boolean`
+        * [.install](#Generator+install) : `Boolean`
+        * [.templateConfig](#Generator+templateConfig) : `Object`
+        * [.hooks](#Generator+hooks) : `Object`
+        * [.mapBaseUrlToFolder](#Generator+mapBaseUrlToFolder) : `Object`
+        * [.templateParams](#Generator+templateParams) : `Object`
+        * [.originalAsyncAPI](#Generator+originalAsyncAPI) : `String`
+        * [.generate(asyncapiDocument)](#Generator+generate) ⇒ `Promise`
         * [.configureTemplate()](#Generator+configureTemplate)
-        * [.generateFromString(asyncapiString, [parserOptions])](#Generator+generateFromString) ⇒ <code>Promise</code>
-        * [.generateFromURL(asyncapiURL)](#Generator+generateFromURL) ⇒ <code>Promise</code>
-        * [.generateFromFile(asyncapiFile)](#Generator+generateFromFile) ⇒ <code>Promise</code>
+        * [.generateFromString(asyncapiString, [parserOptions])](#Generator+generateFromString) ⇒ `Promise`
+        * [.generateFromURL(asyncapiURL)](#Generator+generateFromURL) ⇒ `Promise`
+        * [.generateFromFile(asyncapiFile)](#Generator+generateFromFile) ⇒ `Promise`
         * [.installTemplate([force])](#Generator+installTemplate)
     * _static_
-        * [.getTemplateFile(templateName, filePath, [templatesDir])](#Generator.getTemplateFile) ⇒ <code>Promise</code>
+        * [.getTemplateFile(templateName, filePath, [templatesDir])](#Generator.getTemplateFile) ⇒ `Promise`
+
 
 <a name="new_Generator_new"></a>
 
-### new Generator(templateName, targetDir, options)
+### new Generator
 Instantiates a new Generator object.
 
-
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| templateName | <code>String</code> |  | Name of the template to generate. |
-| targetDir | <code>String</code> |  | Path to the directory where the files will be generated. |
-| options | <code>Object</code> |  |  |
-| [options.templateParams] | <code>String</code> |  | Optional parameters to pass to the template. Each template define their own params. |
-| [options.entrypoint] | <code>String</code> |  | Name of the file to use as the entry point for the rendering process. Use in case you want to use only a specific template file. Note: this potentially avoids rendering every file in the template. |
-| [options.noOverwriteGlobs] | <code>Array.&lt;String&gt;</code> |  | List of globs to skip when regenerating the template. |
-| [options.disabledHooks] | <code>Object.&lt;String, (Boolean\|String\|Array.&lt;String&gt;)&gt;</code> |  | Object with hooks to disable. The key is a hook type. If key has "true" value, then the generator skips all hooks from the given type. If the value associated with a key is a string with the name of a single hook, then the generator skips only this single hook name. If the value associated with a key is an array of strings, then the generator skips only hooks from the array. |
-| [options.output] | <code>String</code> | <code>&#x27;fs&#x27;</code> | Type of output. Can be either 'fs' (default) or 'string'. Only available when entrypoint is set. |
-| [options.forceWrite] | <code>Boolean</code> | <code>false</code> | Force writing of the generated files to given directory even if it is a git repo with unstaged files or not empty dir. Default is set to false. |
-| [options.install] | <code>Boolean</code> | <code>false</code> | Install the template and its dependencies, even when the template has already been installed. |
-| [options.debug] | <code>Boolean</code> | <code>false</code> | Enable more specific errors in the console. At the moment it only shows specific errors about filters. Keep in mind that as a result errors about template are less descriptive. |
-| [options.mapBaseUrlToFolder] | <code>Object.&lt;String, String&gt;</code> |  | Optional parameter to map schema references from a base url to a local base folder e.g. url=https://schema.example.com/crm/  folder=./test/docs/ . |
+**Params**
+
+- templateName `String` - Name of the template to generate.
+- targetDir `String` - Path to the directory where the files will be generated.
+- options `Object`
+    - [.templateParams] `String` - Optional parameters to pass to the template. Each template define their own params.
+    - [.entrypoint] `String` - Name of the file to use as the entry point for the rendering process. Use in case you want to use only a specific template file. Note: this potentially avoids rendering every file in the template.
+    - [.noOverwriteGlobs] `Array.<String>` - List of globs to skip when regenerating the template.
+    - [.disabledHooks] `Object.<String, (Boolean|String|Array.<String>)>` - Object with hooks to disable. The key is a hook type. If key has "true" value, then the generator skips all hooks from the given type. If the value associated with a key is a string with the name of a single hook, then the generator skips only this single hook name. If the value associated with a key is an array of strings, then the generator skips only hooks from the array.
+    - [.output] `String` ` = 'fs'` - Type of output. Can be either 'fs' (default) or 'string'. Only available when entrypoint is set.
+    - [.forceWrite] `Boolean` ` = false` - Force writing of the generated files to given directory even if it is a git repo with unstaged files or not empty dir. Default is set to false.
+    - [.install] `Boolean` ` = false` - Install the template and its dependencies, even when the template has already been installed.
+    - [.debug] `Boolean` ` = false` - Enable more specific errors in the console. At the moment it only shows specific errors about filters. Keep in mind that as a result errors about template are less descriptive.
+    - [.mapBaseUrlToFolder] `Object.<String, String>` - Optional parameter to map schema references from a base url to a local base folder e.g. url=https://schema.example.com/crm/  folder=./test/docs/ .
 
 **Example**  
 ```js
@@ -64,100 +71,114 @@ const generator = new Generator('@asyncapi/html-template', path.resolve(__dirnam
   }
 });
 ```
+
 <a name="Generator+templateName"></a>
 
-### generator.templateName : <code>String</code>
+* generator.templateName : `String`** :
 Name of the template to generate.
 
-**Kind**: instance property of [<code>Generator</code>](#Generator)  
+**Kind**: instance property of [`Generator`](#Generator)  
+
 <a name="Generator+targetDir"></a>
 
-### generator.targetDir : <code>String</code>
+* generator.targetDir : `String`** :
 Path to the directory where the files will be generated.
 
-**Kind**: instance property of [<code>Generator</code>](#Generator)  
+**Kind**: instance property of [`Generator`](#Generator)  
+
 <a name="Generator+entrypoint"></a>
 
-### generator.entrypoint : <code>String</code>
+* generator.entrypoint : `String`** :
 Name of the file to use as the entry point for the rendering process. Use in case you want to use only a specific template file. Note: this potentially avoids rendering every file in the template.
 
-**Kind**: instance property of [<code>Generator</code>](#Generator)  
+**Kind**: instance property of [`Generator`](#Generator)  
+
 <a name="Generator+noOverwriteGlobs"></a>
 
-### generator.noOverwriteGlobs : <code>Array.&lt;String&gt;</code>
+* generator.noOverwriteGlobs : `Array.<String>`** :
 List of globs to skip when regenerating the template.
 
-**Kind**: instance property of [<code>Generator</code>](#Generator)  
+**Kind**: instance property of [`Generator`](#Generator)  
+
 <a name="Generator+disabledHooks"></a>
 
-### generator.disabledHooks : <code>Object.&lt;String, (Boolean\|String\|Array.&lt;String&gt;)&gt;</code>
+* generator.disabledHooks : `Object.<String, (Boolean|String|Array.<String>)>`** :
 Object with hooks to disable. The key is a hook type. If key has "true" value, then the generator skips all hooks from the given type. If the value associated with a key is a string with the name of a single hook, then the generator skips only this single hook name. If the value associated with a key is an array of strings, then the generator skips only hooks from the array.
 
-**Kind**: instance property of [<code>Generator</code>](#Generator)  
+**Kind**: instance property of [`Generator`](#Generator)  
+
 <a name="Generator+output"></a>
 
-### generator.output : <code>String</code>
+* generator.output : `String`** :
 Type of output. Can be either 'fs' (default) or 'string'. Only available when entrypoint is set.
 
-**Kind**: instance property of [<code>Generator</code>](#Generator)  
+**Kind**: instance property of [`Generator`](#Generator)  
+
 <a name="Generator+forceWrite"></a>
 
-### generator.forceWrite : <code>Boolean</code>
+* generator.forceWrite : `Boolean`** :
 Force writing of the generated files to given directory even if it is a git repo with unstaged files or not empty dir. Default is set to false.
 
-**Kind**: instance property of [<code>Generator</code>](#Generator)  
+**Kind**: instance property of [`Generator`](#Generator)  
+
 <a name="Generator+debug"></a>
 
-### generator.debug : <code>Boolean</code>
+* generator.debug : `Boolean`** :
 Enable more specific errors in the console. At the moment it only shows specific errors about filters. Keep in mind that as a result errors about template are less descriptive.
 
-**Kind**: instance property of [<code>Generator</code>](#Generator)  
+**Kind**: instance property of [`Generator`](#Generator)  
+
 <a name="Generator+install"></a>
 
-### generator.install : <code>Boolean</code>
+* generator.install : `Boolean`** :
 Install the template and its dependencies, even when the template has already been installed.
 
-**Kind**: instance property of [<code>Generator</code>](#Generator)  
+**Kind**: instance property of [`Generator`](#Generator)  
+
 <a name="Generator+templateConfig"></a>
 
-### generator.templateConfig : <code>Object</code>
+* generator.templateConfig : `Object`** :
 The template configuration.
 
-**Kind**: instance property of [<code>Generator</code>](#Generator)  
+**Kind**: instance property of [`Generator`](#Generator)  
+
 <a name="Generator+hooks"></a>
 
-### generator.hooks : <code>Object</code>
+* generator.hooks : `Object`** :
 Hooks object with hooks functions grouped by the hook type.
 
-**Kind**: instance property of [<code>Generator</code>](#Generator)  
+**Kind**: instance property of [`Generator`](#Generator)  
+
 <a name="Generator+mapBaseUrlToFolder"></a>
 
-### generator.mapBaseUrlToFolder : <code>Object</code>
+* generator.mapBaseUrlToFolder : `Object`** :
 Maps schema URL to folder.
 
-**Kind**: instance property of [<code>Generator</code>](#Generator)  
+**Kind**: instance property of [`Generator`](#Generator)  
+
 <a name="Generator+templateParams"></a>
 
-### generator.templateParams : <code>Object</code>
+* generator.templateParams : `Object`** :
 The template parameters. The structure for this object is based on each individual template.
 
-**Kind**: instance property of [<code>Generator</code>](#Generator)  
+**Kind**: instance property of [`Generator`](#Generator)  
+
 <a name="Generator+originalAsyncAPI"></a>
 
-### generator.originalAsyncAPI : <code>String</code>
+* generator.originalAsyncAPI : `String`** :
 AsyncAPI string to use as a source.
 
-**Kind**: instance property of [<code>Generator</code>](#Generator)  
+**Kind**: instance property of [`Generator`](#Generator)  
+
 <a name="Generator+generate"></a>
 
-### generator.generate(asyncapiDocument) ⇒ <code>Promise</code>
+### generator.generate
 Generates files from a given template and an AsyncAPIDocument object.
 
-**Kind**: instance method of [<code>Generator</code>](#Generator)  
+**Kind**: instance method of [`Generator`](#Generator)  
+**Params**
 
-| Param | Type | Description |
-| --- | --- | --- |
-| asyncapiDocument | <code>AsyncAPIDocument</code> | AsyncAPIDocument object to use as source. |
+- asyncapiDocument `AsyncAPIDocument` - AsyncAPIDocument object to use as source.
 
 **Example**  
 ```js
@@ -177,23 +198,24 @@ try {
   console.error(e);
 }
 ```
+
 <a name="Generator+configureTemplate"></a>
 
-### generator.configureTemplate()
+* generator.configureTemplate()** :
 Configure the templates based the desired renderer.
 
-**Kind**: instance method of [<code>Generator</code>](#Generator)  
+**Kind**: instance method of [`Generator`](#Generator)  
+
 <a name="Generator+generateFromString"></a>
 
-### generator.generateFromString(asyncapiString, [parserOptions]) ⇒ <code>Promise</code>
+### generator.generateFromString
 Generates files from a given template and AsyncAPI string.
 
-**Kind**: instance method of [<code>Generator</code>](#Generator)  
+**Kind**: instance method of [`Generator`](#Generator)  
+**Params**
 
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| asyncapiString | <code>String</code> |  | AsyncAPI string to use as source. |
-| [parserOptions] | <code>Object</code> | <code>{}</code> | AsyncAPI parser options. Check out [@asyncapi/parser](https://www.github.com/asyncapi/parser-js) for more information. |
+- asyncapiString `String` - AsyncAPI string to use as source.
+- [parserOptions] `Object` ` = {}` - AsyncAPI parser options. Check out [@asyncapi/parser](https://www.github.com/asyncapi/parser-js) for more information.
 
 **Example**  
 ```js
@@ -228,16 +250,16 @@ try {
   console.error(e);
 }
 ```
+
 <a name="Generator+generateFromURL"></a>
 
-### generator.generateFromURL(asyncapiURL) ⇒ <code>Promise</code>
+### generator.generateFromURL
 Generates files from a given template and AsyncAPI file stored on external server.
 
-**Kind**: instance method of [<code>Generator</code>](#Generator)  
+**Kind**: instance method of [`Generator`](#Generator)  
+**Params**
 
-| Param | Type | Description |
-| --- | --- | --- |
-| asyncapiURL | <code>String</code> | Link to AsyncAPI file |
+- asyncapiURL `String` - Link to AsyncAPI file
 
 **Example**  
 ```js
@@ -257,16 +279,16 @@ try {
   console.error(e);
 }
 ```
+
 <a name="Generator+generateFromFile"></a>
 
-### generator.generateFromFile(asyncapiFile) ⇒ <code>Promise</code>
+### generator.generateFromFile
 Generates files from a given template and AsyncAPI file.
 
-**Kind**: instance method of [<code>Generator</code>](#Generator)  
+**Kind**: instance method of [`Generator`](#Generator)  
+**Params**
 
-| Param | Type | Description |
-| --- | --- | --- |
-| asyncapiFile | <code>String</code> | AsyncAPI file to use as source. |
+- asyncapiFile `String` - AsyncAPI file to use as source.
 
 **Example**  
 ```js
@@ -286,37 +308,37 @@ try {
   console.error(e);
 }
 ```
+
 <a name="Generator+installTemplate"></a>
 
-### generator.installTemplate([force])
+### generator.installTemplate
 Downloads and installs a template and its dependencies
 
-**Kind**: instance method of [<code>Generator</code>](#Generator)  
+**Kind**: instance method of [`Generator`](#Generator)  
+**Params**
+
+- [force] `Boolean` ` = false` - Whether to force installation (and skip cache) or not.
 
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| [force] | <code>Boolean</code> | <code>false</code> | Whether to force installation (and skip cache) or not. |
 
 <a name="Generator.getTemplateFile"></a>
 
-### Generator.getTemplateFile(templateName, filePath, [templatesDir]) ⇒ <code>Promise</code>
+### Generator.getTemplateFile
 Returns the content of a given template file.
 
-**Kind**: static method of [<code>Generator</code>](#Generator)  
+**Kind**: static method of [`Generator`](#Generator)  
+**Params**
 
-| Param | Type | Default | Description |
-| --- | --- | --- | --- |
-| templateName | <code>String</code> |  | Name of the template to generate. |
-| filePath | <code>String</code> |  | Path to the file to render. Relative to the template directory. |
-| [templatesDir] | <code>String</code> | <code>DEFAULT_TEMPLATES_DIR</code> | Path to the directory where the templates are installed. |
+- templateName `String` - Name of the template to generate.
+- filePath `String` - Path to the file to render. Relative to the template directory.
+- [templatesDir] `String` ` = DEFAULT_TEMPLATES_DIR` - Path to the directory where the templates are installed.
 
 **Example**  
 ```js
-const Generator = require('asyncapi-generator');
+const Generator = require('@asyncapi/generator');
 const content = await Generator.getTemplateFile('@asyncapi/html-template', 'partials/content.html');
 ```
 **Example** *(Using a custom &#x60;templatesDir&#x60;)*  
 ```js
-const Generator = require('asyncapi-generator');
+const Generator = require('@asyncapi/generator');
 const content = await Generator.getTemplateFile('@asyncapi/html-template', 'partials/content.html', '~/my-templates');
 ```

package/docs/asyncapi-document.md

@@ -84,4 +84,4 @@ In the sample code snippet below, notice how you can access the contents of the
   const channels = asyncapi.channels();
 ```
 
-> To learn about the various instances you can use to access the documents' content, look at the API of the AsyncAPI JavaScript Parser and the structure of [AsyncAPIDocument](https://github.com/asyncapi/parser-js/blob/master/API.md#module_@asyncapi/parser+AsyncAPIDocument)
+> To learn about the various instances you can use to access the documents' content, look at the API of the AsyncAPI JavaScript Parser and the structure of [AsyncAPIDocument](https://github.com/asyncapi/parser-js/blob/master/API.md#module_@asyncapi/parser+AsyncAPIDocument)

package/docs/configuration-file.md

@@ -1,6 +1,6 @@
 ---
 title: "Configuration file"
-weight: 30
+weight: 90
 ---
 
 The `generator` property from `package.json` file must contain a JSON object that may have the following information:
@@ -17,7 +17,7 @@ The `generator` property from `package.json` file must contain a JSON object tha
 |`conditionalFiles[filePath].subject`| String | The `subject` is a [JMESPath](http://jmespath.org/) query to grab the value you want to apply the condition to. It queries an object with the whole AsyncAPI document and, when specified, the given server. The object looks like this: `{ asyncapi: { ... }, server: { ... } }`. If the template supports `server` parameter, you can access server details like for example protocol this way: `server.protocol`. During validation with `conditionalFiles` only the server that template user selected is available in the specification file. For more information about `server` parameter [read about special parameters](#special-parameters).
 |`conditionalFiles[filePath].validation`| Object | The `validation` is a JSON Schema Draft 07 object. This JSON Schema definition will be applied to the JSON value resulting from the `subject` query. If validation doesn't have errors, the condition is met, and therefore the given file will be rendered. Otherwise, the file is ignored. Check [JSON Schema Validation](https://json-schema.org/draft-07/json-schema-validation.html#rfc.section.6) document for a list of all possible validation keywords.
 |`nonRenderableFiles`| [String] | A list of file paths or [globs](https://en.wikipedia.org/wiki/Glob_(programming)) that must be copied "as-is" to the target directory, i.e., without performing any rendering process. This is useful when you want to copy binary files.
-|`generator`| [String] | A string representing the Generator version-range the template is compatible with. This value must follow the [semver](https://nodejs.dev/learn/semantic-versioning-using-npm) syntax. E.g., `>=1.0.0`, `>=1.0.0 <=2.0.0`, `~1.0.0`, `^1.0.0`, `1.0.0`, etc. [Read more about semver](https://docs.npmjs.com/about-semantic-versioning).
+|`generator`| [String] | A string representing the generator version-range the template is compatible with. This value must follow the [semver](https://nodejs.dev/learn/semantic-versioning-using-npm) syntax. E.g., `>=1.0.0`, `>=1.0.0 <=2.0.0`, `~1.0.0`, `^1.0.0`, `1.0.0`, etc. [Read more about semver](https://docs.npmjs.com/about-semantic-versioning).
 |`filters`| [String] | A list of modules containing functions that can be used as Nunjucks filters. In case of external modules, remember they need to be added as a dependency in `package.json` of your template.
 |`hooks`| Object[String, String] or Object[String, Array[String]] | A list of modules containing hooks, except for the ones you keep locally in your template in default location. For each module you must specify the exact name of the hook that should be used in the template. For a single hook you can specify it as a string, for more you must pass an array of strings. In case of external modules, remember they need to be added as a dependency in `package.json` of your template.
 

package/docs/file-templates.md

@@ -1,6 +1,6 @@
 ---
 title: "File templates"
-weight: 110
+weight: 140
 ---
 
 It is possible to generate files for each specific object in your AsyncAPI documentation. For example, you can specify a filename like `$$channel$$.js` to generate a file for each channel defined in your AsyncAPI. The following file-template names and extra variables in them are available:

package/docs/hooks.md

@@ -1,6 +1,6 @@
 ---
 title: "Hooks"
-weight: 100
+weight: 130
 ---
 
 Hooks are functions called by the generator on a specific moment in the generation process. Hooks can be anonymous functions but you can also add function names. These hooks can have arguments provided to them or being expected to return a value.

package/docs/index.md

@@ -3,7 +3,7 @@ title: "Introduction"
 weight: 10
 ---
 
-The AsyncAPI generator is a tool that generates anything you want using the **[AsyncAPI Document](generator/asyncapi-documents)** and **[Template](generator/template)** that are supplied as inputs to the AsyncAPI CLI. The generator was built with extensibility in mind; you can use the generator to generate anything you want, provided that it can be defined in a template, such as code, diagrams, markdown files, microservices, and applications. A number of [community-maintained templates](https://github.com/search?q=topic%3Aasyncapi+topic%3Agenerator+topic%3Atemplate) are now available for immediate usage.
+The AsyncAPI generator is a tool that generates anything you want using the **[AsyncAPI Document](generator/asyncapi-document)** and **[Template](generator/template)** that are supplied as inputs to the AsyncAPI CLI. The generator was built with extensibility in mind; you can use the generator to generate anything you want, provided that it can be defined in a template, such as code, diagrams, markdown files, microservices, and applications. A number of [community-maintained templates](https://github.com/search?q=topic%3Aasyncapi+topic%3Agenerator+topic%3Atemplate) are now available for immediate usage.
 
 ### Generator use cases 
 - Generation of interactive and understandable API documentation
@@ -50,4 +50,4 @@ graph LR
   D --> J[Java Spring Boot]
   D --> K[Anything else]
   ```
-**`params`** are template-specific options passed to the `asyncapi generate fromTemplate` CLI command to customize the generated output.
+**`params`** are template-specific options passed to the `asyncapi generate fromTemplate` CLI command to customize the generated output.

package/docs/jsdoc2md-handlebars/custom-sig-name.hbs

@@ -0,0 +1,12 @@
+{{#if virtual}}*{{/if}}{{#with (parentObject)}}{{#if virtual}}*{{/if~}}{{/with~}}
+{{#if name}}{{#sig~}}
+{{{@depOpen}~}}
+{{{@codeOpen}~}}
+{{#if @prefix}}{{@prefix}} {{/if~}}
+{{@parent~}}
+{{@accessSymbol}}{{#if (isEvent)}}"{{{name}}}"{{else}}{{{escape name}}}{{/if~}}
+{{{@codeClose}~}}
+{{#if @suffix}} {{@suffix}}{{/if~}}
+{{{@depClose}~}}
+{{~/sig}}{{/if}}
+{{#if virtual}}*{{/if}}{{#with (parentObject)}}{{#if virtual}}*{{/if~}}{{/with~}}

package/docs/jsdoc2md-handlebars/defaultvalue.hbs

@@ -0,0 +1 @@
+{{#unless (equal defaultvalue undefined)}}`{{#if equals}} = {{/if}}{{#if (equal type.names.[0] "string")}}{{{json-stringify defaultvalue}}}{{else}}{{{defaultvalue}}}{{/if}}`{{/unless}}

package/docs/jsdoc2md-handlebars/header.hbs

@@ -0,0 +1,12 @@
+
+<a name="{{{anchorName}}}"></a>
+
+{{#if (equal kind "class")}}
+{{>heading-indent}}{{>custom-sig-name}}
+{{~else~}}
+{{#if params}}
+{{>heading-indent}}{{>custom-sig-name}}
+{{~else~}}
+* {{>sig-name}}** :
+{{/if}}
+{{/if}}

package/docs/jsdoc2md-handlebars/link.hbs

@@ -0,0 +1,25 @@
+{{! usage: link to="namepath" html=true/false caption="optional caption"~}}
+
+{{~#if html~}}
+<code>
+
+{{~#link to~}}
+{{#if url~}}
+<a href="{{{url}}}">{{#if ../../caption}}{{../../../caption}}{{else}}{{name}}{{/if}}</a>
+{{~else~}}
+{{#if ../../caption}}{{../../../caption}}{{else}}{{name}}{{/if~}}
+{{/if~}}
+{{/link~}}
+
+</code>
+{{~else~}}
+
+{{#link to~}}
+{{#if url~}}
+[`{{#if ../../caption}}{{{../../../caption}}}{{else}}{{{name}}}{{/if}}`]({{{url}}})
+{{~else~}}
+`{{#if ../../caption}}{{{../../../caption}}}{{else}}{{{name}}}{{/if~}}`
+{{~/if~}}
+{{/link~}}
+
+{{/if~}}

package/docs/jsdoc2md-handlebars/main.hbs

@@ -0,0 +1,8 @@
+---
+title: Library API
+weight: 75
+---
+
+Reference API documentation for AsyncAPI Generator library.
+{{>main-index~}}
+{{>all-docs~}}

package/docs/jsdoc2md-handlebars/params-table.hbs

@@ -0,0 +1,9 @@
+{{#if params}}
+{{#params}}**Params**
+
+{{#each this~}}
+{{indent}}- {{name}}{{#if type}} {{>linked-type-list types=type.names delimiter=" | " }}{{/if}}{{#unless (equal defaultvalue undefined)}} {{>defaultvalue equals=true ~}}{{/unless}}{{#if description}} - {{{inlineLinks description}}}{{/if}}
+{{/each}}
+
+{{/params~}}
+{{/if}}

package/docs/nunjucks-render-engine.md

@@ -1,6 +1,6 @@
 ---
 title: "Nunjucks render engine"
-weight: 70
+weight: 120
 ---
 
 [Nunjucks](https://mozilla.github.io/nunjucks) is the default render engine, however, we strongly recommend adopting the [React](#react) engine.

package/docs/parser.md

@@ -1,6 +1,96 @@
 ---
 title: "Parser"
-weight: 90
+weight: 60
 ---
 
->This document is under construction.
+## Parser
+
+The AsyncAPI Parser is a package used to parse and validate the [AsyncAPI documents](asyncapi-document.md) in your Node.js or browser application. These documents can be either in YAML or JSON format.
+
+The Parser validates these documents using dedicated schema-supported plugins. 
+
+Supported schemas:
+
+- AsyncAPI schema (no plugin needed)
+- OpenAPI schema
+- JSON schema
+- Avro schema
+- RAML data-type schema
+
+The Parser allows the template developer to easily access schemas provided in the above supported formats. This is because the JavaScript parser converts all of them into JSON schema.
+
+If the document is valid, the Parser returns an `AsyncAPIDocument instance` with a set of helper functions that enable easier access to the contents of the AsyncAPI document. The parser provides dereferenced output. During the dereference process, the AsyncAPI parser substitutes a reference with a full definition. The dereferenced output is always in JSON format. The parser provides a message listing all errors if a document is invalid. The original AsyncAPI document is part of the [Template Context](template-context.md) as the generator also passes the original AsyncAPI document to the template context.	
+
+The following AsyncAPI document example has two channels: `channelOne` and `channelTwo`. Each channel has one operation and a single message:
+
+```yaml
+asyncapi: '2.5.0'
+info:
+  title: Demo API
+  version: '1.0.0'
+channels:
+  channelOne:
+    publish:
+      summary: This is the first sample channel
+      operationId: onMessage
+      message:
+        name: FirstMessage
+        payload:
+            id:
+              type: integer
+              minimum: 0
+              description: Id of the channel
+            sentAt:
+              type: string
+              format: date-time
+              description: Date and time when the message was sent.
+  channelTwo:
+    publish:
+      summary: This is the second sample channel
+      operationId: messageRead
+      message:
+        name: SecondMessage
+        payload:
+            id:
+              type: integer
+              minimum: 0
+              description: Id of the channel
+            sentAt:
+              type: string
+              format: date-time
+              description: Date and time when the message was sent.
+```
+We can use helper functions provided by the Parser to operate on the above JSON file. For example, we can use the helper method `asyncAPIDocument.channelNames()`, which returns an array of all channel names currently present in the AsyncAPI document. Another example where you can use a helper function is to list out messages present in your JSON file. Instead of fetching a single message one at a time, you can use the function `asyncAPIDocument.allMessages()` that returns the map of all messages in your AsyncAPI document.
+
+```js
+  const channelNames = asyncAPIDocument.channelNames();
+  const messages = asyncAPIDocument.allMessages();
+```
+
+> The Parser gives you access to a number of these [helper functions](https://github.com/asyncapi/parser-js/blob/master/API.md) that you can implement to access the contents of your AsyncAPI document. 
+
+## AsyncAPI document validation process
+
+1. **AsyncAPI document** is fed as an input to the Generator.
+1. Generator sends the AsyncAPI document to the Parser as **asyncapiString**; the stringified version of the original AsyncAPI document.
+1. The Parser uses additional plugins such as the OpenAPI, RAML, or Avro schemas to validate custom schemas of message payloads defined in the AsyncAPI document.
+1. If the AsyncAPI document is invalid, it throws an error based on the encountered failure type. For example, if the AsyncAPI document is not a string nor a JavaScript object, the Parser throws an `invalid-document-type` error. 
+   Similarly, you may encounter errors such as:
+      - `invalid-json`
+      - `invalid-yaml`
+      - `impossible-to-convert-to-json`
+1. If the document is valid, the Parser modifies the AsyncAPI document, returns a set of helper functions, and bundles them together into the **asyncapi** variable. These helper functions in the form of an **asyncapi** variable are passed to the **Template Context**.
+1. The Template Context passes all of these values to the [**Render Engine**](react-render-engine.md) of your choice. Finally, the Render Engine generates whatever output you may have specified in your template. (i.e. code, documentation, diagrams, pdfs, applications, etc.)
+
+```mermaid
+graph TD
+    A[AsyncAPI document] --> B
+    B[Generator] -->|asyncapiString| C(Parser)
+    C --> D{Validation}
+    D -->|invalid| B
+    D -->|asyncapi -> helper functions| E[Template Context]
+    E --> F[Render Engine]
+```
+
+> To learn more about the Parser and access all of its features, check out the AsyncAPI [Parser’s GitHub repository](https://github.com/asyncapi/parser-js).
+

package/docs/react-render-engine.md

@@ -1,6 +1,6 @@
 ---
 title: "React render engine"
-weight: 60
+weight: 110
 ---
 
 [React](https://reactjs.org) is the render engine that we strongly suggest you should use for any new templates. The only reason it is not the default render engine is to stay backward compatible.
@@ -31,7 +31,7 @@ export default function({ asyncapi, params, originalAsyncAPI }) {
 }
 ```
 
-The exported default function returns a `File` component as a root component which the [Generator](https://github.com/asyncapi/generator) uses to figure out what file should be generated. In our case we overwrite the default functionality of saving the file as `MyTemplate.js` but instead use the filename `asyncapi.md`. It is then specified that we should render `Some text that should render as is\n` within that file. Notice the `\n` character at the end, this is something that is automatically added after the `Text` component. 
+The exported default function returns a `File` component as a root component which the generator uses to determine what file should be generated. In our case, we overwrite the default functionality of saving the file as `MyTemplate.js` but instead use the filename `asyncapi.md`. It is then specified that we should render `Some text that should render as is\n` within that file. Notice the `\n` character at the end, which is automatically added after the `Text` component. 
 
 For further information about components, props etc. see the [Generator React SDK](https://github.com/asyncapi/generator-react-sdk)
 

package/docs/special-file-names.md

@@ -1,6 +1,6 @@
 ---
 title: "Special file names"
-weight: 130
+weight: 160
 ---
 
 We use NPM behind the scenes to download and install the templates. Since NPM will not fetch files like `.gitignore`, you should name them differently. Luckily, the Generator will take care of renaming them back for you. The following is a table of the special file names:

package/docs/template-context.md

@@ -1,6 +1,6 @@
 ---
 title: "Template context"
-weight: 60
+weight: 100
 ---
 
 While using the generator tool, you may want dynamic values populated to your templates and rendered in the output. The generator can achieve that using the **template context**.

package/docs/template-development.md

@@ -0,0 +1,153 @@
+---
+title: "Template development"
+weight: 80
+---
+
+## Minimum template requirements
+
+Let's break down the minimum template requirements: the `template` directory and a `package.json` file.
+
+> You can also check [Template for Generator Templates](https://github.com/asyncapi/template-for-generator-templates) project to see show-case template based on the AsyncAPI Generator.
+
+### `template` directory
+
+The `template` directory stores generated outputs in files. In other words, the generator processes all the files stored in this directory.
+
+```js
+import { File, Text } from "@asyncapi/generator-react-sdk";
+
+export default function({ asyncapi, params, originalAsyncAPI }) {
+return (
+    <File name="asyncapi.md">
+    <Text>My application's markdown file.</Text>
+    <Text>App name: **{ asyncapi.info().title() }**</Text>
+    </File>
+);
+}
+```
+### `package.json` file
+
+Before the generation process begins, the generator installs the template into its dependencies. A `package.json` file is necessary to identify the template name.
+
+The following block shows an example `package.json` file that points to the [React Render Engine](react-render-engine.md) and necessary dependencies:
+
+```json
+{
+  "name": "myTemplate",
+  "generator": {
+    "renderer": "react"
+  },
+  "dependencies": {
+    "@asyncapi/generator-react-sdk": "^0.2.25"
+  }
+}
+```
+
+The above example of a `template/index.js` file shows the generation process result. The user also receives an `asyncapi.md` file with hardcoded and dynamic (application title from the AsyncAPI document) information.
+
+Every template must depend on the [`@asyncapi/generator-react-sdk` package](https://github.com/asyncapi/generator-react-sdk), which contains a template file's basic components.
+
+## Additional configuration options
+
+You must configure the generator's `package.json` file to contain JSON objects with the required parameters for template configuration, such as:
+
+|Name|Type|Description|
+|---|---|---|
+|`renderer`| String | Its value can be either `react` or `nunjucks` (default).
+|`supportedProtocols`| [String] | A list with all the protocols this template supports.
+|`parameters`| Object[String, Object] | An object with all the parameters that can be passed when generating the template. When using the command line, it's done by indicating `--param name=value` or `-p name=value`.
+|`parameters[param].description`| String | A user-friendly description about the parameter.
+|`parameters[param].default`| Any | Default value of the parameter if not specified. Shouldn't be used for mandatory `required=true` parameters.
+|`parameters[param].required`| Boolean | Whether the parameter is required or not.
+
+The above table lists some configuration options that help the generator achieve a specific set of tasks throughout the generation process. The `generator` property from 'package.json' contains all the configuration information. To learn more about template configuration and various supported parameters, read the [generator configuration file](configuration-file.md).
+
+> Whenever you make a change to the package.json, make sure you perform an update by running `npm install`;  this command synchronizes with the `package-lock.json` and validates the file.
+
+### `package.json` configuration options 
+
+The following examples show some advanced configurations that we can use in our `package.json` file:
+
+```json
+{
+  "name": "myTemplate",
+  "generator": {
+    "renderer": "react",
+    "supportedProtocols": "mqtt"
+  },
+  "dependencies": {
+    "@asyncapi/generator-react-sdk": "^0.2.25"
+  }
+}
+```
+The above `package.json` file has a newly added configuration called `supportedProtocols` which is set to `mqtt`. This configuration displays all the protocols that this template supports. You can have multiple supported protocols in our template. 
+
+For example, if you want to generate an output using the above template, you need to have an AsyncAPI document with servers that use `mqtt` to generate your desired output. If your AsyncAPI document has server connections with `kafka`, the generation process will be terminated since the only supported protocol mentioned is `mqtt`. 
+
+### Accessing template parameters
+
+Additionally, we can also have a configuration called `parameters`, which is an object with all the parameters that can be passed when generating the template:
+
+```json
+{
+  "name": "myTemplate",
+  "generator": {
+    "renderer": "react",
+    "supportedProtocols": "mqtt",
+    "parameters": {
+        "version": {
+          "description": "Overrides application version under `info.version` in the AsyncAPI document.",
+          "required": false
+        }
+    }
+  },
+  "dependencies": {
+    "@asyncapi/generator-react-sdk": "^0.2.25"
+  }
+}
+```
+
+The default version of your application is always fetched from your AsyncAPI document. The above configuration helps the template user override the existing version with a new one on the command line.
+
+The changes done in the template will be as follows:
+
+Original:
+
+```js
+<Text>App name: **{ asyncapi.info().title() }**</Text>
+```
+
+Newer:
+
+```js
+<Text>App name: **{ asyncapi.info().title() }**</Text>
+<Text>Version is: **{params.version || asyncapi.info.version()}**</Text>
+```
+
+Now that you have added all the configuration options, you can start the generation process using the generator CLI. You can pass these parameters via the CLI: `--param name=value or -p name=value`.
+The above configuration helps template users override the existing version with a new version on the command line. (Example: `-p version=2.0.0`)
+
+## Hooks
+
+[Hooks](hooks.md) enable templates to perform multiple tasks. You can add Hooks to your template as fractions of code. In the template, you must store it in the `hooks` directory under the template directory. You can also store it in other modules and external libraries or configure it inside the template. The generation process can perform multiple actions.
+
+**Templates** can perform multiple actions _before_ or _after_ the generation process with the help of **hooks**.
+
+Hooks help you change the specification version with the new `version` that you can pass before the generation process even begins:
+
+```js
+module.exports = {
+  'generate:before': ({ asyncapi, templateParams = {} }) => {
+    const version = templateParams.version || asyncapi.info().version();
+    asyncapi._json.info.version = version;
+  }
+};
+```
+This can be an even better alternative to overriding the `version` parameter we discussed in the previous section. A markdown document will be generated, and the AsyncAPI document passed to the generator will be returned with the overwritten version.
+
+The updated template looks like the following:
+
+```js
+<Text>App name: **{ asyncapi.info().title() }**</Text>
+<Text>Version: **{asyncapi.info.version()}**</Text>
+```

package/docs/template.md

@@ -1,6 +1,73 @@
 ---
 title: "Template"
-weight: 40
+weight: 50
 ---
 
->This document is under construction.
+## Template
+
+A template is a project that specifies the generation process output by using the AsyncAPI generator and an [AsyncAPI document](asyncapi-file.md). These files describe the generation results depending on the AsyncAPI document's content.
+
+Examples outputs:
+
+- Code
+- Documentation
+- Markdown diagrams
+- Python and Java applications
+
+A template is an independent Node.js project unrelated to the `generator` repository. AsyncAPI templates are managed, released, and published separately. You can also create templates and manage templates on your own.
+
+The generator uses the official [Arborist](https://www.npmjs.com/package/@npmcli/arborist) NPM library. (This means templates do not have to be published to package managers to use them.) Arborist helps the generator fetch the template's source code and use it for the generation process. 
+
+You can store template projects on a local drive or as a `git` repository during the development process. 
+
+## Template generation process
+
+1. Template is provided as input to the **Generator**.
+2. **asyncapi** is the original AsyncAPI document injected into your template file by default.
+3. **params** are the parameters you pass to the generator CLI. Later, you can also pass these **params** further to other components. 
+4. The generator passes both the original **asyncapi**, the original AsyncAPI document, and the **params** to the **Template Context**.
+5. Concurrently, the generator passes **Template files** to the **Render engine** as well. AsyncAPI uses two render engines — _react_ and _nunjucks_.
+6. Once the Render Engine receives both the Template Files and the Template Context, it injects all the dynamic values into your react or nunjucks engine, based on the Template Files using the Template Context.
+7. The render engine generates whatever output you may have specified in your template. (i.e. code, documentation, diagrams, pdfs, applications, etc.)
+
+```mermaid
+graph LR
+    A[Template Context]
+    B{Generator}
+    D[Render Engine]
+    F[Template] --> B
+  subgraph Generator Library
+    B --> | asyncapi | A
+    B--> | params | A
+    A --> D
+    B --> | Template Files | D
+  end
+```
+
+## Generator `templates` list
+
+AsyncAPI has a list of available templates to enhance your generation process. Templates are stored as repositories on AsyncAPI's official GitHub profile.
+
+<!-- templates list is validated with GitHub Actions do not remove list markers -->
+<!-- TEMPLATES-LIST:START -->
+
+Template Name | Description | Source code
+---|---|---
+`@asyncapi/nodejs-template` | Generates Node.js service that uses Hermes package | [Nodej.s template](https://github.com/asyncapi/nodejs-template)
+`@asyncapi/nodejs-ws-template` | Generates Node.js service that supports WebSocket protocol only | [Node.js WebSocket template](https://github.com/asyncapi/nodejs-ws-template)
+`@asyncapi/java-template` | Generates Java JMS application | [Java template](https://github.com/asyncapi/java-template)
+`@asyncapi/java-spring-template` | Generates Java Spring service | [Java spring template](https://github.com/asyncapi/java-spring-template)
+`@asyncapi/java-spring-cloud-stream-template` | Generates Java Spring Cloud Stream service | [Java spring cloud stream template](https://github.com/asyncapi/java-spring-cloud-stream-template)
+`@asyncapi/python-paho-template` | Generates Python service that uses Paho library | [Python paho template](https://github.com/asyncapi/python-paho-template)
+`@asyncapi/html-template` | Generates HTML documentation site | [HTML template](https://github.com/asyncapi/html-template)
+`@asyncapi/markdown-template` | Generates documentation in Markdown file | [Markdown template](https://github.com/asyncapi/markdown-template)
+`@asyncapi/ts-nats-template` | Generates TypeScript NATS client | [TypeScript/Node.js NATS template](https://github.com/asyncapi/ts-nats-template/)
+`@asyncapi/go-watermill-template` | Generates Go client using Watermill | [GO watermill template](https://github.com/asyncapi/go-watermill-template)
+`@asyncapi/dotnet-nats-template` | Generates .NET C# client using NATS | [.NET C# NATS template](https://github.com/asyncapi/dotnet-nats-template)
+
+<!-- TEMPLATES-LIST:END -->
+
+> Some of these templates are maintained by various third-party organizations. The README file usually contains this information and more, such as configuration options the user can pass to the template, usage, technical requirements, etc.
+
+> Check out all our community [generator templates](https://github.com/search?q=topic%3Aasyncapi+topic%3Agenerator+topic%3Atemplate)
+

package/docs/typescript-support.md

@@ -1,6 +1,6 @@
 ---
 title: "TypeScript support"
-weight: 120
+weight: 150
 ---
 
 The AsyncAPI generator has TypeScript support for [hooks](#hooks) and Nunjucks's [filters](#filters). Assumptions:

package/docs/usage.md

@@ -87,7 +87,7 @@ The generator skips all hooks of the `generate:before` type and `foo`, `bar` hoo
 asyncapi generate fromTemplate asyncapi.yaml ~/my-template
 ```
 
-It creates a symbolic link to the target directory (`~/my-template` in this case).
+It creates a symbolic link to the target directory (`~/my-template` in this case). 
 
 **Installing the template from a git URL:**
 ```bash

package/docs/versioning.md

@@ -1,6 +1,6 @@
 ---
 title: "Generator version vs template version"
-weight: 60
+weight: 70
 ---
 
 The generator tool generates whatever you want, as long as it can be defined in a template based on the [AsyncAPI document](asyncapi-document). On the other hand, a **template** is a file or group of files that specify the kind of output you expect from using the generator's features. For example, you may want to use the [NodeJS template](https://github.com/asyncapi/nodejs-template) to generate boilerplate code for your message-based APIs.

package/lib/generator.js

@@ -334,11 +334,11 @@ class Generator {
    * Returns the content of a given template file.
    *
    * @example
-   * const Generator = require('asyncapi-generator');
+   * const Generator = require('@asyncapi/generator');
    * const content = await Generator.getTemplateFile('@asyncapi/html-template', 'partials/content.html');
    *
    * @example <caption>Using a custom `templatesDir`</caption>
-   * const Generator = require('asyncapi-generator');
+   * const Generator = require('@asyncapi/generator');
    * const content = await Generator.getTemplateFile('@asyncapi/html-template', 'partials/content.html', '~/my-templates');
    *
    * @static

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asyncapi/generator",
-  "version": "1.9.14",
+  "version": "1.9.16",
   "description": "The AsyncAPI generator. It can generate documentation, code, anything!",
   "main": "./lib/generator.js",
   "bin": {
@@ -18,7 +18,7 @@
     "test:integration": "npm run test:cleanup && jest --testPathPattern=integration --modulePathIgnorePatterns='./__mocks__'",
     "test:cli": "node cli.js ./test/docs/dummy.yml @asyncapi/html-template -o test/output --force-write --debug && test -e test/output/index.html",
     "test:cleanup": "rimraf \"test/temp\"",
-    "docs": "jsdoc2md lib/generator.js > docs/api.md",
+    "docs": "jsdoc2md --partial docs/jsdoc2md-handlebars/custom-sig-name.hbs docs/jsdoc2md-handlebars/main.hbs docs/jsdoc2md-handlebars/docs.hbs docs/jsdoc2md-handlebars/header.hbs docs/jsdoc2md-handlebars/defaultvalue.hbs docs/jsdoc2md-handlebars/link.hbs docs/jsdoc2md-handlebars/params-table.hbs --files lib/generator.js > docs/api.md",
     "docker:build": "docker build -t asyncapi/generator:latest .",
     "lint": "eslint --max-warnings 0 --config .eslintrc .",
     "lint:tpl:validator": "eslint --fix --config .eslintrc .github/templates-list-validator",
@@ -50,7 +50,7 @@
     "@asyncapi/avro-schema-parser": "^1.1.0",
     "@asyncapi/generator-react-sdk": "^0.2.23",
     "@asyncapi/openapi-schema-parser": "^2.0.1",
-    "@asyncapi/parser": "^1.17.1",
+    "@asyncapi/parser": "^1.17.3",
     "@asyncapi/raml-dt-schema-parser": "^2.0.1",
     "@npmcli/arborist": "^2.2.4",
     "ajv": "^6.10.2",

package/.releaserc

@@ -1,10 +0,0 @@
----
-branches:
-- master
-plugins:
-- - "@semantic-release/commit-analyzer"
-  - preset: conventionalcommits
-- - "@semantic-release/release-notes-generator"
-  - preset: conventionalcommits
-- "@semantic-release/npm"
-- "@semantic-release/github"

package/docs/authoring-templates.md

@@ -1,17 +0,0 @@
----
-title: "Authoring templates"
-weight: 50
----
-
-The AsyncAPI generator has been built with extensibility in mind. The package uses a set of default templates to let you generate documentation and code. However, you can create and use your own templates. In this section, you learn how to create your own one.
-
-To work on a template, you need an AsyncAPI specification file that you can use for testing. For this purpose, you can use [this](../test/docs/dummy.yml) dummy file as it's purpose is to cover as many features of AsyncAPI as possible. Do not copy this file to your template but use it directly from this repo like this: `ag https://raw.githubusercontent.com/asyncapi/generator/master/test/docs/dummy.yml ./your-template`
-
-> In case you find some features missing or other possible improvements in the dummy file, suggest changes. The goal is to build a file that all templates can use and check their specification features coverage.
-
-1. A template is a directory in your file system.
-1. The template can have own dependencies. Just create `package.json` for the template. The generator makes sure to trigger the installation of dependencies.
-1. Templates can be configured. Configuration must be stored in the `package.json` file under custom `generator` property. [Read more about the configuration file](#configuration-file).
-1. The template engine can be either [React](#react) (recommended) or [Nunjucks](#nunjucks) (default). This can be controlled with the `renderer` property in the [template configuration](#template-configuration).
-1. Templates may contain `hooks` that are functions invoked during specific moment of the generation. In the template, they must be stored in the `hooks` directory under the template directory. They can also be stored in other modules and external libraries and configured inside the template [Read more about hooks](#hooks).
-1. There are parameters with special meaning. [Read more about special parameters](#special-parameters).