openc3 5.0.6

data/data/config/item_modifiers.yaml

@@ -0,0 +1,221 @@
+---
+<%= MetaConfigParser.load('param_item_modifiers.yaml').to_meta_config_yaml(0) %>
+STATE:
+  summary: Defines a key/value pair for the current item
+  description: Key value pairs allow for user friendly strings. For example,
+    you might define states for ON = 1 and OFF = 0. This allows the word ON to be
+    used rather than the number 1 when sending the telemetry item and allows
+    for much greater clarity and less chance for user error.
+  example: |
+    APPEND_ITEM ENABLE 32 UINT "Enable setting"
+      STATE FALSE 0
+      STATE TRUE 1
+    APPEND_ITEM STRING 1024 STRING "String"
+      STATE "NOOP" "NOOP" GREEN
+      STATE "ARM LASER" "ARM LASER" YELLOW
+      STATE "FIRE LASER" "FIRE LASER" RED
+  parameters:
+    - name: Key
+      required: true
+      description: The string state name
+      values: .*
+    - name: Value
+      required: true
+      description: The numerical state value
+      values: .*
+    - name: Color
+      required: false
+      description: The color the state should be displayed as
+      values: ['GREEN', 'YELLOW', 'RED']
+READ_CONVERSION:
+  summary: Applies a conversion to the current telemetry item
+  description: Conversions are implemented in a custom Ruby file which should be
+    located in the target's lib folder and required by the target's target.txt
+    file (see REQUIRE). The class must require 'openc3/conversions/conversion'
+    and inherit from Conversion. It must implement the initialize method if it
+    takes extra parameters and must always implement the call method. The conversion
+    factor is applied to the raw value in the telemetry packet before it is displayed
+    to the user. The user still has the ability to see the raw unconverted value
+    in a details dialog.
+  example: |
+    READ_CONVERSION the_great_conversion.rb 1000
+
+    Defined in the_great_conversion.rb:
+
+    require 'openc3/conversions/conversion'
+    module OpenC3
+      class TheGreatConversion < Conversion
+        def initialize(multiplier)
+          super()
+          @multiplier = multiplier.to_f
+        end
+        def call(value, packet, buffer)
+          return value * multiplier
+        end
+      end
+    end
+  parameters:
+    - name: Class Filename
+      required: true
+      description: The filename which contains the Ruby class. The filename must
+        be named after the class such that the class is a CamelCase version of the
+        underscored filename. For example, 'the_great_conversion.rb' should contain
+        'class TheGreatConversion'.
+      values: .*\.rb
+    - name: Parameter
+      required: false
+      description: Additional parameter values for the conversion which are passed
+        to the class constructor.
+      values: .*
+POLY_READ_CONVERSION:
+  summary: Adds a polynomial conversion factor to the current telemetry item
+  description: The conversion factor is applied to raw value in the telemetry
+    packet before it is displayed to the user. The user still has the ability
+    to see the raw unconverted value in a details dialog.
+  example: POLY_READ_CONVERSION 10 0.5 0.25
+  parameters:
+    - name: C0
+      required: true
+      description: Coefficient
+      values: .*
+    - name: Cx
+      required: false
+      description: Additional coefficient values for the conversion. Any order
+        polynomial conversion may be used so the value of 'x' will vary with the
+        order of the polynomial. Note that larger order polynomials take longer
+        to process than shorter order polynomials, but are sometimes more accurate.
+      values: .*
+SEG_POLY_READ_CONVERSION:
+  summary: Adds a segmented polynomial conversion factor to the current telemetry item
+  description: This conversion factor is applied to the raw value in the telemetry packet
+    before it is displayed to the user. The user still has the ability to see the raw
+    unconverted value in a details dialog.
+  example: |
+    SEG_POLY_READ_CONVERSION 0 10 0.5 0.25 # Apply the conversion to all values < 50
+    SEG_POLY_READ_CONVERSION 50 11 0.5 0.275 # Apply the conversion to all values >= 50 and < 100
+    SEG_POLY_READ_CONVERSION 100 12 0.5 0.3 # Apply the conversion to all values >= 100
+  parameters:
+    - name: Lower Bound
+      required: true
+      description: Defines the lower bound of the range of values that this segmented
+        polynomial applies to. Is ignored for the segment with the smallest lower bound.
+      values: .*
+    - name: C0
+      required: true
+      description: Coefficient
+      values: .*
+    - name: Cx
+      required: false
+      description: Additional coefficient values for the conversion. Any order
+        polynomial conversion may be used so the value of 'x' will vary with the
+        order of the polynomial. Note that larger order polynomials take longer
+        to process than shorter order polynomials, but are sometimes more accurate.
+      values: .*
+GENERIC_READ_CONVERSION_START:
+  summary: Start a generic read conversion
+  description: Adds a generic conversion function to the current telemetry item.
+    This conversion factor is applied to the raw value in the telemetry packet
+    before it is displayed to the user. The user still has the ability to see the
+    raw unconverted value in a details dialog. The conversion is specified as
+    ruby code that receives two implied parameters. 'value' which is the raw
+    value being read and 'packet' which is a reference to the telemetry packet
+    class (Note, referencing the packet as 'myself' is still supported for backwards
+    compatibility). The last line of ruby code given should return the converted
+    value. The GENERIC_READ_CONVERSION_END keyword specifies that all lines of
+    ruby code for the conversion have been given.
+  warning: Generic conversions are not a good long term solution. Consider creating
+    a conversion class and using READ_CONVERSION instead. READ_CONVERSION is easier
+    to debug and higher performance.
+  example: |
+    APPEND_ITEM ITEM1 32 UINT
+      GENERIC_READ_CONVERSION_START
+        value * 1.5  # Convert the value by a scale factor
+      GENERIC_READ_CONVERSION_END
+  parameters:
+    - name: Converted Type
+      required: false
+      description: Type of the converted value
+      values: <%= %w(INT UINT FLOAT STRING BLOCK) %>
+    - name: Converted Bit Size
+      required: false
+      description: Bit size of converted value
+      values: \d+
+GENERIC_READ_CONVERSION_END:
+  summary: Complete a generic read conversion
+LIMITS:
+  summary: Defines a set of limits for a telemetry item
+  description: If limits are violated a message is printed in the Command and Telemetry Server
+    to indicate an item went out of limits. Other tools also use this information
+    to update displays with different colored telemetry items or other useful information.
+    The concept of "limits sets" is defined to allow for different limits values
+    in different environments. For example, you might want tighter or looser limits
+    on telemetry if your environment changes such as during thermal vacuum testing.
+  example: |
+    LIMITS DEFAULT 3 ENABLED -80.0 -70.0 60.0 80.0 -20.0 20.0
+    LIMITS TVAC 3 ENABLED -80.0 -30.0 30.0 80.0
+  parameters:
+    - name: Limits Set
+      required: true
+      description: Name of the limits set. If you have no unique limits sets use
+        the keyword DEFAULT.
+      values: .+
+    - name: Persistence
+      required: true
+      description: Number of consecutive times the telemetry item must be within
+        a different limits range before changing limits state.
+      values: \d+
+    - name: Initial State
+      required: true
+      description: Whether limits monitoring for this telemetry item is initially enabled or disabled.
+        Note if you have multiple LIMITS items they should all have the same initial state.
+      values: ['ENABLED', 'DISABLED']
+    - name: Red Low Limit
+      required: true
+      description: If the telemetry value is less than or equal to this value a
+        Red Low condition will be detected
+      values: .+
+    - name: Yellow Low Limit
+      required: true
+      description: If the telemetry value is less than or equal to this value,
+        but greater than the Red Low Limit, a Yellow Low condition will be detected
+      values: .+
+    - name: Yellow High Limit
+      required: true
+      description: If the telemetry value is greater than or equal to this value,
+        but less than the Red High Limit, a Yellow High condition will be detected
+      values: .+
+    - name: Red High Limit
+      required: true
+      description: If the telemetry value is greater than or equal to this value
+        a Red High condition will be detected
+      values: .+
+    - name: Green Low Limit
+      required: false
+      description: Setting the Green Low and Green High limits defines an
+        "operational limit" which is colored blue by OpenC3. This allows for a
+        distinct desired operational range which is narrower than the green safety limit.
+        If the telemetry value is greater than or equal to this value, but less
+        than the Green High Limit, a Blue operational condition will be detected.
+      values: .+
+    - name: Green High Limit
+      required: false
+      description: Setting the Green Low and Green High limits defines an
+        "operational limit" which is colored blue by OpenC3. This allows for a
+        distinct desired operational range which is narrower than the green safety limit.
+        If the telemetry value is less than or equal to this value, but greater
+        than the Green Low Limit, a Blue operational condition will be detected.
+      values: .+
+LIMITS_RESPONSE:
+  summary: Defines a response class that is called when the limits state of the current item changes
+  example: LIMITS_RESPONSE example_limits_response.rb 10
+  parameters:
+    - name: Response Class Filename
+      required: true
+      description: Name of the Ruby file which implements the limits response.
+        This file should be in the config/TARGET/lib directory so it can be found by OpenC3.
+      values: .+
+    - name: Response Specific Options
+      required: false
+      description: Variable length number of options that will be passed to the
+        class constructor
+      values: .+

data/data/config/microservice.yaml

@@ -0,0 +1,78 @@
+---
+MICROSERVICE:
+  summary: Defines a new microservice
+  example: MICROSERVICE EXAMPLE example-microservice
+  description: Defines a microservice that the plugin adds to the OpenC3 system. Microservices are background software processes that perform persistent processing.
+  parameters:
+    - name: Microservice Folder Name
+      description: The exact name of the microservice folder in the plugin. ie. microservices/<Microservice Folder Name>
+      required: true
+      values: .+
+    - name: Microservice Name
+      description: The specific name of this instance of the microservice in the OpenC3 system
+      required: true
+      values: .+
+  modifiers:
+    ENV:
+      summary: Sets an environment variable in the microservice.
+      parameters:
+        - name: Key
+          required: true
+          description: Environment variable name
+          values: .+
+        - name: Value
+          required: true
+          description: Environment variable value
+          values: .+
+    WORK_DIR:
+      summary: Set the working directory
+      description: Working directory to run the microservice CMD in.  Can be a path relative to the microservice folder in the plugin, or an absolute path in the container the microservice runs in.
+      parameters:
+        - name: Directory
+          required: true
+          description: Working directory to run the microservice CMD in. Can be a path relative to the microservice folder in the plugin, or an absolute path in the container the microservice runs in.
+          values: .+
+    TOPIC:
+      summary: Associate a Redis topic
+      description: Redis topic to associate with this microservice. Standard OpenC3 microservices such as decom_microservice use this information to know what packet streams to subscribe to. The TOPIC keyword can be used as many times as necessary to associate all needed topics.
+      parameters:
+        - name: Topic Name
+          required: true
+          description: Redis Topic to associate with the microservice
+          values: .+
+    TARGET_NAME:
+      summary: Associate a OpenC3 target
+      description: OpenC3 target to associate with the microservice. For standard OpenC3 microservices such as decom_microservice this causes the target configuration to get loaded into the container for the microservice.
+      parameters:
+        - name: Target Name
+          required: true
+          description: OpenC3 target to associate with the microservice
+          values: .+
+    CMD:
+      summary: Command line to execute to run the microservice.
+      description: Command line to execute to run the microservice.
+      parameters:
+        - name: Args
+          required: true
+          description: One or more arguments to exec to run the microservice.
+          values: .+
+    OPTION:
+      summary: Pass an option to the microservice
+      description: Generic key/value(s) options to pass to the microservice. These take the form of KEYWORD/PARAMS like a line in a OpenC3 configuration file. Multiple OPTION keywords can be used to pass multiple options to the microservice.
+      parameters:
+        - name: Option Name
+          required: true
+          description: Name of the option
+          values: .+
+        - name: Option Value(s)
+          required: true
+          description: One or more values to associate with the option
+          values: .+
+    CONTAINER:
+      summary: Docker Container.
+      description: Container to execute and run the microservice in.
+      parameters:
+        - name: Args
+          required: false
+          description: Name of the container
+          values: .+

data/data/config/param_item_modifiers.yaml

@@ -0,0 +1,52 @@
+---
+FORMAT_STRING:
+  summary: Adds printf style formatting
+  example: FORMAT_STRING "0x%0X"
+  parameters:
+    - name: Format
+      required: true
+      description: How to format using printf syntax.
+        For example, '0x%0X' will display the value in hex.
+      values: .*
+UNITS:
+  summary: Add displayed units
+  example: |
+    UNITS Celsius C
+    UNITS Kilometers KM
+  parameters:
+    - name: Full Name
+      required: true
+      description: Full name of the units type, e.g. Celsius
+      values: .*
+    - name: Abbreviated
+      required: true
+      description: Abbreviation for the units, e.g. C
+      values: .*
+DESCRIPTION:
+  summary: Override the defined description
+  parameters:
+    - name: Value
+      required: true
+      description: The new description
+      values: .*
+META:
+  summary: Stores custom user metadata
+  description: Meta data is user specific data that can be used by custom tools
+    for various purposes. One example is to store additional information needed
+    to generate source code header files.
+  example: META TEST "This parameter is for test purposes only"
+  parameters:
+    - name: Meta Name
+      required: true
+      description: Name of the metadata to store
+      values: .*
+    - name: Meta Values
+      required: false
+      description: One or more values to be stored for this Meta Name
+      values: .*
+OVERLAP:
+  summary: This item is allowed to overlap other items in the packet
+  description:
+    If an item's bit offset overlaps another item, OpenC3 issues a warning. This keyword explicitly
+    allows an item to overlap another and supresses the warning message.
+  since: 4.4.1

data/data/config/parameter_modifiers.yaml

@@ -0,0 +1,200 @@
+---
+<%= MetaConfigParser.load('param_item_modifiers.yaml').to_meta_config_yaml(0) %>
+REQUIRED:
+  summary: Parameter is required to be populated in scripts
+  description: When sending the command via Script Runner a value must always be
+    given for the current command parameter. This prevents the user from relying
+    on a default value. Note that this does not affect Command Sender which will
+    still populate the field with the default value provided in the PARAMETER definition.
+MINIMUM_VALUE:
+  summary: Override the defined minimum value
+  parameters:
+    - name: Value
+      required: true
+      description: The new minimum value for the parameter
+      values: .*
+MAXIMUM_VALUE:
+  summary: Override the defined maximum value
+  parameters:
+    - name: Value
+      required: true
+      description: The new maximum value for the parameter
+      values: .*
+DEFAULT_VALUE:
+  summary: Override the defined default value
+  parameters:
+    - name: Value
+      required: true
+      description: The new default value for the parameter
+      values: .*
+STATE:
+  summary: Defines a key/value pair for the current command parameter
+  description: Key value pairs allow for user friendly strings. For example,
+    you might define states for ON = 1 and OFF = 0. This allows the word ON to be
+    used rather than the number 1 when sending the command parameter and allows
+    for much greater clarity and less chance for user error.
+  example: |
+    APPEND_PARAMETER ENABLE 32 UINT 0 1 0 "Enable setting"
+      STATE FALSE 0
+      STATE TRUE 1
+    APPEND_PARAMETER STRING 1024 STRING "NOOP" "String parameter"
+      STATE "NOOP" "NOOP"
+      STATE "ARM LASER" "ARM LASER" HAZARDOUS "Arming the laser is an eye safety hazard"
+      STATE "FIRE LASER" "FIRE LASER" HAZARDOUS "WARNING! Laser will be fired!"
+  parameters:
+    - name: Key
+      required: true
+      description: The string state name
+      values: .*
+    - name: Value
+      required: true
+      description: The numerical state value
+      values: .*
+    - name: Hazardous
+      required: false
+      description: Indicates the state is hazardous. This will cause a popup
+        to ask for user confirmation when sending this command.
+      values: ['HAZARDOUS']
+    - name: Hazardous Description
+      required: false
+      description: String describing why this state is hazardous
+      values: "['\"].*['\"]"
+WRITE_CONVERSION:
+  summary: Applies a conversion when writing the current command parameter
+  description: Conversions are implemented in a custom Ruby file which should be
+    located in the target's lib folder and required by the target's target.txt
+    file (see REQUIRE). The class must require 'openc3/conversions/conversion'
+    and inherit from Conversion. It must implement the initialize method if it
+    takes extra parameters and must always implement the call method. The conversion
+    factor is applied to the value entered by the user before it is written into
+    the binary command packet and sent.
+
+    <div class="note info">
+    <h5>Multiple write conversions on command parameters</h5>
+    <p>When a command is built, each item gets written (and write conversions are run)
+    to set the default value. Then items are written (again write conversions are run)
+    with user provided values. Thus write conversions can be run twice. Also there are
+    no guarantees which parameters have already been written. The packet itself has a
+    given_values() method which can be used to retrieve a hash of the user provided
+    values to the command. That can be used to check parameter values passed in.</p>
+    </div>
+  example: |
+    WRITE_CONVERSION the_great_conversion.rb 1000
+
+    Defined in the_great_conversion.rb:
+
+    require 'openc3/conversions/conversion'
+    module OpenC3
+      class TheGreatConversion < Conversion
+        def initialize(multiplier)
+          super()
+          @multiplier = multiplier.to_f
+        end
+        def call(value, packet, buffer)
+          return value * multiplier
+        end
+      end
+    end
+  parameters:
+    - name: Class Filename
+      required: true
+      description: The filename which contains the Ruby class. The filename must
+        be named after the class such that the class is a CamelCase version of the
+        underscored filename. For example, 'the_great_conversion.rb' should contain
+        'class TheGreatConversion'.
+      values: .*\.rb
+    - name: Parameter
+      required: false
+      description: Additional parameter values for the conversion which are passed
+        to the class constructor.
+      values: .*
+POLY_WRITE_CONVERSION:
+  summary: Adds a polynomial conversion factor to the current command parameter
+  description: The conversion factor is applied to the value entered by the user
+    before it is written into the binary command packet and sent.
+  example: POLY_WRITE_CONVERSION 10 0.5 0.25
+  parameters:
+    - name: C0
+      required: true
+      description: Coefficient
+      values: .*
+    - name: Cx
+      required: false
+      description: Additional coefficient values for the conversion. Any order
+        polynomial conversion may be used so the value of 'x' will vary with the
+        order of the polynomial. Note that larger order polynomials take longer
+        to process than shorter order polynomials, but are sometimes more accurate.
+      values: .*
+SEG_POLY_WRITE_CONVERSION:
+  summary: Adds a segmented polynomial conversion factor to the current command parameter
+  description: This conversion factor is applied to the value entered by the user
+    before it is written into the binary command packet and sent.
+  example: |
+    SEG_POLY_WRITE_CONVERSION 0 10 0.5 0.25 # Apply the conversion to all values < 50
+    SEG_POLY_WRITE_CONVERSION 50 11 0.5 0.275 # Apply the conversion to all values >= 50 and < 100
+    SEG_POLY_WRITE_CONVERSION 100 12 0.5 0.3 # Apply the conversion to all values >= 100
+  parameters:
+    - name: Lower Bound
+      required: true
+      description: Defines the lower bound of the range of values that this segmented
+        polynomial applies to. Is ignored for the segment with the smallest lower bound.
+      values: .*
+    - name: C0
+      required: true
+      description: Coefficient
+      values: .*
+    - name: Cx
+      required: false
+      description: Additional coefficient values for the conversion. Any order
+        polynomial conversion may be used so the value of 'x' will vary with the
+        order of the polynomial. Note that larger order polynomials take longer
+        to process than shorter order polynomials, but are sometimes more accurate.
+      values: .*
+GENERIC_WRITE_CONVERSION_START:
+  summary: Start a generic write conversion
+  description: Adds a generic conversion function to the current command parameter.
+    This conversion factor is applied to the value entered by the user before it
+    is written into the binary command packet and sent. The conversion is specified
+    as ruby code that receives two implied parameters. 'value' which is the raw
+    value being written and 'packet' which is a reference to the command packet
+    class (Note, referencing the packet as 'myself' is still supported for backwards
+    compatibility). The last line of ruby code given should return the converted
+    value. The GENERIC_WRITE_CONVERSION_END keyword specifies that all lines of
+    ruby code for the conversion have been given.
+
+    <div class="note info">
+    <h5>Multiple write conversions on command parameters</h5>
+    <p>When a command is built, each item gets written (and write conversions are run)
+    to set the default value. Then items are written (again write conversions are run)
+    with user provided values. Thus write conversions can be run twice. Also there are
+    no guarantees which parameters have already been written. The packet itself has a
+    given_values() method which can be used to retrieve a hash of the user provided
+    values to the command. That can be used to check parameter values passed in.</p>
+    </div>
+  warning: Generic conversions are not a good long term solution. Consider creating
+    a conversion class and using WRITE_CONVERSION instead. WRITE_CONVERSION is easier
+    to debug and higher performance.
+  example: |
+    APPEND_PARAMETER ITEM1 32 UINT 0 0xFFFFFFFF 0
+      GENERIC_WRITE_CONVERSION_START
+        (value * 1.5).to_i # Convert the value by a scale factor
+      GENERIC_WRITE_CONVERSION_END
+GENERIC_WRITE_CONVERSION_END:
+  summary: Complete a generic write conversion
+OVERFLOW:
+  summary: Set the behavior when writing a value overflows the type
+  description: By default OpenC3 throws an error if you try to write a value
+    which overflows its specified type, e.g. writing 255 to a 8 bit signed value.
+    Setting the overflow behavior also allows for OpenC3 to 'TRUNCATE'
+    the value by eliminating any high order bits. You can also set 'SATURATE' which
+    causes OpenC3 to replace the value with the maximum or minimum allowable value
+    for that type. Finally you can specify 'ERROR_ALLOW_HEX' which will allow for
+    a maximum hex value to be writen, e.g. you can successfully write 255 to a 8
+    bit signed value.
+  example: OVERFLOW TRUNCATE
+  parameters:
+    - name: Behavior
+      required: true
+      description: How OpenC3 treats an overflow value. Only applies to signed and
+        unsigned integer data types.
+      values: <%= %w(ERROR ERROR_ALLOW_HEX TRUNCATE SATURATE) %>

data/data/config/plugins.yaml

@@ -0,0 +1,80 @@
+---
+VARIABLE:
+  summary: Define a configurable variable for the plugin
+  description: The VARIABLE keyword defines a variable that will be requested for the user to enter during plugin installation.   Variables can be used to handle details of targets that are user defined such as specific IP addresses and ports.  Variables should also be used to allow users to rename targets to whatever name they want and support multiple installations of the same target with different names.
+    Variables can be used later in plugin.txt or in any other configuration file included in a plugin using Ruby ERB syntax.  The variables are assigned to accessible local variables in the file.
+    At a high level, ERB allows you to run Ruby code in configuration files.
+  parameters:
+    - name: Variable Name
+      required: true
+      description: The name of the variable
+      values: .+
+    - name: Default Value
+      required: true
+      description: Default value of the variable
+      values: .+
+INTERFACE:
+  modifiers:
+    <%= MetaConfigParser.load('interface_modifiers.yaml').to_meta_config_yaml(4) %>
+  summary: Defines a connection to a physical target
+  description: Interfaces are what OpenC3 uses to talk to a particular piece
+    of hardware. Interfaces require a Ruby file which implements all the interface
+    methods necessary to talk to the hardware. OpenC3 defines many built in interfaces
+    or you can define your own as long as it implements the interface protocol.
+  parameters:
+    - name: Interface Name
+      required: true
+      description: Name of the interface. This name will appear in the
+        Interfaces tab of the Server and is also referenced by other keywords.
+        The OpenC3 convention is to name interfaces after their targets with
+        '_INT' appended to the name, e.g. INST_INT for the INST target.
+      values: \D\S*
+    - name: Filename
+      required: true
+      description: Ruby file to use when instantiating the interface.
+      values:
+        <%= MetaConfigParser.load('_interfaces.yaml').to_meta_config_yaml(8) %>
+      documentation: Additional parameters are required. Please see the [Interfaces](/docs/v5/interfaces)
+        documentation for more details.
+ROUTER:
+  modifiers:
+    ROUTE:
+      summary: Map an interface to a router
+      description: Once an interface has been mapped to a router, all its received telemetry
+        will be sent out through the router.
+      parameters:
+        - name: Interface
+          required: true
+          description: Name of the interface
+          values: .+
+    <%= MetaConfigParser.load('interface_modifiers.yaml').to_meta_config_yaml(4) %>
+  summary: Create router to receive commands and output telemetry packets from one or more interfaces
+  description: Creates an router which receives command packets from
+    their remote clients and sends them to associated interfaces. They receive telemetry
+    packets from their interfaces and send them to their remote clients. This allows
+    routers to be intermediaries between an external client and an actual device.
+  parameters:
+    - name: Name
+      required: true
+      description: Name of the router
+      values: .+
+    - name: Filename
+      required: true
+      description: Ruby file to use when instantiating the interface.
+      values:
+        <%= MetaConfigParser.load('_interfaces.yaml').to_meta_config_yaml(8) %>
+      documentation: Additional parameters are required. Please see the [Interfaces](/docs/v5/interfaces)
+        documentation for more details.
+<%= MetaConfigParser.load('target.yaml').to_meta_config_yaml() %>
+<%= MetaConfigParser.load('microservice.yaml').to_meta_config_yaml() %>
+<%= MetaConfigParser.load('tool.yaml').to_meta_config_yaml() %>
+WIDGET:
+  summary: Define a custom widget
+  example: WIDGET HELLOWORLD
+  description: Defines a custom widget that can be used in Telemetry Viewer screens.
+  parameters:
+    - name: Widget Name
+      description: The name of the widget wil be used to build a path to the widget implementation. For example, `WIDGET HELLOWORLD` will find the as-built file tools/widgets/HelloworldWidget/HelloworldWidget.umd.min.js. See the [Custom Widgets](/docs/v5/custom-widgets)
+        guide for more details.
+      required: true
+      values: .+