@asyncapi/generator 1.9.13 → 1.9.15

package/docs/installation-guide.md

@@ -0,0 +1,81 @@
+---
+title: "Installation guide"
+weight: 20
+---
+
+You can use the generator library to generate whatever you want in your event-driven architecture apps. Find your preferred method below:
+- [AsyncAPI CLI](#asyncapi-cli)
+- [Generator library in Node.js apps](#generator-library-in-nodejs-apps)
+  
+## Prerequisites
+Before you install and use the AsyncAPI CLI and the generator library, ensure you meet the prerequisites below, then [install the CLI](#installation).
+1. Node.js v12.16 and higher
+2. Npm v6.13.7 and higher
+   
+To verify the versions of Node and Npm you have, run the following command on your terminal:
+```
+npm -v
+```
+```
+node -v
+```
+
+If you don't have either Node or Npm installed, use the [official node.js installer](https://nodejs.org/en/download/).
+
+If you have the correct versions installed, proceed to the CLI installation guide below. Otherwise, upgrading the Npm or Node version is lower than the recommended versions specified above.
+
+## AsyncAPI CLI
+The AsyncAPI CLI tool allows you to do many different things with the [AsyncAPI document](asyncapi-document). You can generate message-based API boilerplate code, documentation, or anything else you need as long as you specify it in your [template](template) or the existing template already supports it. To use the generator via the AsyncAPI CLI, you need to install the AsyncAPI CLI tool.
+
+### Installation
+
+#### Install AsyncAPI CLI using NPM
+
+The AsyncAPI CLI is a NodeJS project, so the easiest way to install it is by using the following `npm` command:
+```
+npm install -g @asyncapi/cli
+```
+
+To install a specific version of the generator tool, pass the version during installation:
+```
+npm install -g @asyncapi/cli@{version}
+```
+
+#### MacOS 
+You can install in MacOS by using brew: `brew install asyncapi`. 
+
+#### Linux 
+You can install in Linux by using `dpkg`, a package manager for debian:
+1. `curl -OL https://github.com/asyncapi/cli/releases/latest/download/asyncapi.deb`
+2. `sudo dpkg -i asyncapi.deb`
+
+#### Other operating systems
+For further installation instructions for different operating systems, read the [AsyncAPI CLI documentation](https://github.com/asyncapi/cli#installation).
+
+> **Remember:** 
+> Each [community-developed template](https://github.com/search?q=topic%3Aasyncapi+topic%3Agenerator+topic%3Atemplate) is dependent on a certain version of the generator for it to work correctly. Before you install the generator CLI, check the template's `package.json` for the version of the generator CLI your template is compatible with. Read the [versioning docs](versioning) to learn why it's important to use certain generator versions with your templates.
+
+### Update AsyncAPI CLI
+There are several reasons why you might want to update your generator version:
+* You have the generator tool installed but want to use the latest released features. To upgrade to the latest version, use the command below:
+```
+npm install -g @asyncapi/cli
+```
+* If your template isn't compatible with the latest generator version, you can update it to a specific version of the generator. Check the [version you need](https://github.com/asyncapi/cli/releases) and specify the version you want by using the **@** symbol as shown in the command below:
+```
+npm install -g @asyncapi/cli@{version}
+```
+> Sometimes you have to force additional npm installation like this: `npm install -g --force @asyncapi/cli`
+
+### Uninstall AsyncAPI CLI
+To uninstall the generator, use the following command:
+```
+npm uninstall @asyncapi/cli -g
+``` 
+
+> :memo: **Note:**  To use the generator in your CI/CD pipeline to automate whatever you generate for your event-driven architecture apps, install the AsyncAPI CLI in your pipeline. If you are using GitHub Actions, use [Github Actions for Generator](https://github.com/marketplace/actions/generator-for-asyncapi-documents).
+
+## Generator library in Node.js apps
+Use the generator library in your Node.js projects by installing it via the following command: `npm install @asyncapi/generator`.
+
+> Don't include the `-g` flag in the installation command above since you're not installing the generator library globally but in your Node.js project.

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
+title: "Nunjucks render engine"
+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
+title: "React render engine"
+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

@@ -0,0 +1,41 @@
+---
+title: "Template context"
+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**.
+The **template context** allows you to access the contents of the [AsyncAPI document](asyncapi-document.md) and inject dynamic values to the template files passed to the asyncAPI CLI during the generation process. The render engine then displays these dynamically assigned values in the output.
+
+## Generation process
+1. The **Generator** receives **Template** and **params** as input.
+2. The **Generator** sends to the **Parser** the **asyncapiString** which is a stringified version of the original **AsyncAPI document**. 
+3. The **Parser** validates the format of the **asyncapiString** using OpenAPI, RAML, or Avro schemas.
+4. If the **asyncapiString** is valid, the **parser** manipulates it, returns a set of helper functions and properties, and bundles them into an **asyncapi** variable. The **asyncapi** variable is an instance of the **AsyncAPI document**. The helper functions and properties make it easier to access the contents of the **AsyncAPI document** in the template.
+5. The **Generator** then passes the **params**, which are template-specific options used to customize the output, the **Template files**, and the **asyncapi** which collectively make up the **Template Context**.
+6. The **Template Context** is then passed to the **Render Engine**. The **Render Engine** then injects all the dynamic values from the **Template Context** into the **Template files**.
+   
+``` mermaid
+graph LR
+    A[Template Context]
+    B{Generator}
+    C[Parser]
+    D[Render Engine]
+    E[Template] --> B
+    F[Params] --> B
+    G[AsyncAPI Document] --> B
+  subgraph Generator
+    B -->| params | A
+    B--> | asyncapiString| C
+    B -->| originalAsyncAPI | A
+    C --> | asyncapi -> AsyncAPIDocument type | A
+    B--> | Template Files | D
+    A --> D
+  end
+```
+
+## Template context
+The extra context passed to the render engine during the generation process and made accessible in the templates includes:
+
+- **`originalAsyncAPI`** is a stringified version of the original AsyncAPI document that the user passed to the Generator.
+- **`asyncapi`** is a parsed AsyncAPI document with helper functions and properties. You should use it to access document contents e.g `asyncapi.title`.
+- **`params`** is an object with all the parameters passed to the Generator by the user.

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
+title: "TypeScript support"
+weight: 150
 ---
 
 The AsyncAPI generator has TypeScript support for [hooks](#hooks) and Nunjucks's [filters](#filters). Assumptions: