docs.json

{
  "component-types": [
    {
      "componentName": "HttpConnector",
      "description": "This connector component invokes HTTP endpoints (tyically REST enpoints) and sets the result to the connector data. This connector can be used as data source for other components."
    },
    {
      "componentName": "CookieConnector",
      "description": "This connector component binds its data to a cookie. This connector can be used as data source for other components."
    },
    {
      "componentName": "LocalStorageConnector",
      "description": "This connector component makes its data persistent by serializing it into the Local Storage of the current browser, in the given key. It also provides synchronization capabilities so that the data can be available accros several devices and shared between several users. This connector can be used as data source for other components."
    },
    {
      "componentName": "DataMapper",
      "description": "A data mapper is a component that maps the data of a source component to its own data, applying some transformation(s) to it (typically filter/map/reduce). This connector can be used as data source for other components."
    },
    {
      "componentName": "GeolocConnector",
      "description": "This connector component uses the geolocation API to provide the current user's location in its data. It also support connection to the Nominatim geocoding API, to resolve postal adresses as latitude/longitude coordinates."
    },
    {
      "componentName": "TextView",
      "description": "This component displays a text to the user, with several formatting option available. The text can include HTML elements."
    },
    {
      "componentName": "CheckboxView",
      "description": "This component defines a user input for a true or false value, and displayed as a checkbox or a switch."
    },
    {
      "componentName": "SelectView",
      "description": "This component defines a user input to select one or multiple values within a list of data."
    },
    {
      "componentName": "InputView",
      "description": "This component defines a user input for sereval kinds of data."
    },
    {
      "componentName": "TextareaView",
      "description": "This component is a text area form input, for multiple-line text."
    },
    {
      "componentName": "ButtonView",
      "description": "This component displays a button with a text and an optional icon and can execute actions when clicked."
    },
    {
      "componentName": "ImageView",
      "description": "This component displays an image located at a given URL."
    },
    {
      "componentName": "IconView",
      "description": "This component displays a builtin icon from its name."
    },
    {
      "componentName": "ContainerView",
      "description": "This component contains other components and can be used to layout them in different ways."
    },
    {
      "componentName": "ReferenceView",
      "description": "A reference component allows to insert another component in place of the reference. Several references can refer to the same component, making it convenient to factorize a component and repeat it in serveral places of your application."
    },
    {
      "componentName": "SplitView",
      "description": "This component splits the parent container in 2 parts. The split can be horizontal or vertical. It also provides support for resizable split and default sizes."
    },
    {
      "componentName": "CardView",
      "description": "This component also showing information (title, body, image, ...) in a so-called card."
    },
    {
      "componentName": "IteratorView",
      "description": "This component loops over an array of data in the data source, and repeats a content passing the currently iterated data."
    },
    {
      "componentName": "TabsView",
      "description": "Create a widget of tabbable containes, allowing the user to interactively switch between different containers by clicking on the tabs."
    },
    {
      "componentName": "CollapseView",
      "description": "Easily toggle visibility of almost any content on your pages in a vertically collapsing container."
    },
    {
      "componentName": "DialogView",
      "description": "Dialogs are used to popup or prompt information to the user. The dialog content may contain any component."
    },
    {
      "componentName": "TableView",
      "description": "This component displays tabular data. It supports pagination, filtering, sorting, custom cell components, and various style options. "
    },
    {
      "componentName": "ChartView",
      "description": "This component displays various types of charts (line charts, bar charts, pie charts, radar charts). It is a wrapper of the well-known ChartJS library."
    },
    {
      "componentName": "TimeSeriesChartView",
      "description": "This component is a specific chart that is made to display time series data."
    },
    {
      "componentName": "TagsView",
      "description": "Lightweight custom tagged input form control, with options for customized interface rendering, duplicate tag detection and optional tag validation."
    },
    {
      "componentName": "PopoverView",
      "description": "The Popover feature, provides a tooltip-like behavior, with fully customizable container content."
    },
    {
      "componentName": "DatepickerView",
      "description": "BootstrapVue custom date picker input form control."
    },
    {
      "componentName": "TimepickerView",
      "description": "BootstrapVue custom time picker input form control,"
    },
    {
      "componentName": "PaginationView",
      "description": "Quick first, previous, next, last, and page buttons for pagination control of an iterable component (a table or an iterator)."
    },
    {
      "componentName": "AvatarView",
      "description": "Avatar components are typically used to display a user profile as a picture, an icon, or short text."
    },
    {
      "componentName": "EmbedView",
      "description": "A component to embed media content (video, audio, image), or external web sites."
    },
    {
      "componentName": "MapView",
      "description": "A component to embed a map. It supports the Leaflet and OpenStreetMap API."
    },
    {
      "componentName": "CarouselView",
      "description": "The carousel is a slideshow for cycling through a series of content. It works with a series of images, text, or custom markup. It also includes support for previous/next controls and indicators."
    },
    {
      "componentName": "ProgressView",
      "description": "A custom progress component for displaying simple or complex progress bars, featuring support for horizontally stacked bars, animated backgrounds, and text labels."
    },
    {
      "componentName": "NavbarView",
      "description": "The main navbar component for the application. Contains menus, custom components, user management support, route management support, and various global functions for the application."
    },
    {
      "componentName": "PdfView",
      "description": "A component to show PDF documents embedded in the app."
    },
    {
      "componentName": "CameraView",
      "description": "A component to open the device camera (if available) and take pictures."
    },
    {
      "componentName": "SidebarView",
      "description": "A component to present some content in a sidebar, which can be shown and hidden depending on the needs."
    }
  ],
  "components-documentation": {
    "HttpConnector": [
      {
        "propertyName": "baseUrl",
        "type": "text"
      },
      {
        "propertyName": "errorHandler",
        "type": "code/javascript",
        "description": "A function to handle http errors: <code>(errorStatus, url, initializationObject) => { ... }</code>",
        "literalOnly": true
      },
      {
        "propertyName": "resultType",
        "type": "select",
        "description": "Select the type of result expected when invoking the endpoint (default is JSON, parsed to an object)",
        "possibleValues": [
          "JSON",
          "TEXT",
          "CSV (with headers)"
        ],
        "literalOnly": true
      },
      {
        "propertyName": "csvSeparator",
        "type": "select",
        "description": "If unspecified, defaults to comma (English standard)",
        "possibleValues": [
          {
            "text": ",",
            "value": ","
          },
          {
            "text": ";",
            "value": ";"
          },
          {
            "text": "tab",
            "value": "\t"
          },
          {
            "text": "space",
            "value": " "
          },
          {
            "text": "pipe (|)",
            "value": "|"
          }
        ]
      },
      {
        "propertyName": "method",
        "type": "select",
        "possibleValues": [
          "GET",
          "POST",
          "PUT",
          "DELETE"
        ],
        "literalOnly": true
      },
      {
        "propertyName": "proxy",
        "type": "checkbox",
        "description": "Use a proxy (to be used to allow CORS when accessing REST APIs)",
        "literalOnly": true
      },
      {
        "propertyName": "enableCache",
        "type": "checkbox",
        "description": "Cache the invocation results in the local storage when possible",
        "literalOnly": true
      },
      {
        "propertyName": "cacheExpiration",
        "type": "number",
        "description": "The number of minutes before a cache key expires (when not defined, default is 24 hours)"
      },
      {
        "propertyName": "cacheMaxEntries",
        "type": "number",
        "description": "The maximum number of entries in the cache (each entry corresponds to a set of specific parameter values), default is <code>100</code>. Note that cache eviction takes place when the number of entries reaches the max number of entries and frees 10% of the cache."
      },
      {
        "propertyName": "cacheEvictionStrategy",
        "type": "select",
        "description": "LRU: Least Recently Used, LFU: Least Frequently Used",
        "possibleValues": [
          "LRU",
          "LFU"
        ],
        "literalOnly": true
      },
      {
        "propertyName": "clearCache",
        "type": "action"
      },
      {
        "propertyName": "path",
        "type": "text",
        "description": "The path to the http endpoint. When using the <code>invoke(...params)</code> action on this component, you can access invocation parameters with the <code>this.invokeParams</code> variable (for instance: <code>x/y/${this.invokeParams[0]}/z</code>)"
      },
      {
        "propertyName": "credentials",
        "type": "select",
        "possibleValues": [
          "omit",
          "same-origin",
          "include"
        ],
        "literalOnly": true
      },
      {
        "propertyName": "mode",
        "type": "select",
        "possibleValues": [
          "cors",
          "no-cors",
          "same-origin",
          "navigate"
        ],
        "literalOnly": true
      },
      {
        "propertyName": "form",
        "type": "checkbox",
        "description": "Sends the body as a form data instead of serialized JSON (default)",
        "literalOnly": true
      },
      {
        "propertyName": "bodyType",
        "type": "select",
        "description": "Specifies how the body should be sent (default is serialized <code>JSON</code>). <code>FORM-DATA</code> sends the body as form data. <code>TEXT</code> sends the body as is.",
        "possibleValues": [
          "JSON",
          "FORM-DATA",
          "TEXT"
        ],
        "literalOnly": true
      },
      {
        "propertyName": "headers",
        "type": "code/json",
        "description": "A JSON object containing the headers to be added to the request."
      },
      {
        "propertyName": "body",
        "type": "code/json",
        "description": "An object containing the body of the request. However, when the selected body type is <code>raw-text</code>, you should write a formula that evaluates to a string. When using the <code>invoke(...params)</code> action on this component, you can access invocation parameters with the <code>this.invokeParams</code> variable (for instance: <code>{ key: ${this.invokeParams[0]} }</code>)"
      }
    ],
    "CookieConnector": [
      {
        "propertyName": "name",
        "type": "text",
        "description": "A string representing the name of the cookie. If omitted, this is empty by default."
      },
      {
        "propertyName": "defaultValue",
        "type": "text",
        "description": "The default value of the data model when the cookie does not exist yet or when its value is not valid."
      },
      {
        "propertyName": "expirationDate",
        "type": "text",
        "description": "A date or a number that represents the expiration date of the cookie as the number of seconds since the UNIX epoch. If omitted, the cookie becomes a session cookie."
      },
      {
        "propertyName": "sameSite",
        "type": "select",
        "description": "A <code>cookies.SameSiteStatus</code> value that indicates the SameSite state of the cookie. If omitted, it defaults to <code>no_restriction</code>.",
        "possibleValues": [
          "no_restriction",
          "lax",
          "strict"
        ]
      }
    ],
    "LocalStorageConnector": [
      {
        "propertyName": "idField",
        "type": "text",
        "description": "The id field name (default is \"id\")",
        "literalOnly": true
      },
      {
        "propertyName": "sortField",
        "type": "text"
      },
      {
        "propertyName": "sortDirection",
        "type": "select"
      },
      {
        "propertyName": "query",
        "type": "checkbox",
        "description": "If set, this connector is a query to the local storage (read-only data access). Keys and shared by expressions can be regexp to match existing storage keys - when several keys are matched, the data is merged into a unique collection.",
        "literalOnly": true
      },
      {
        "propertyName": "autoSync",
        "type": "checkbox",
        "description": "If set, this connector automatically synchronizes before and after each data change."
      },
      {
        "propertyName": "autoIds",
        "type": "checkbox",
        "description": "If set, this connector automatically injects IDs to the data objects.",
        "literalOnly": true
      },
      {
        "propertyName": "autoTimestamp",
        "type": "checkbox",
        "description": "If set, this connector automatically injects timestamps to the data objects.",
        "literalOnly": true
      },
      {
        "propertyName": "storeDataInDefaultValue",
        "type": "checkbox",
        "description": "If set, the data is persited in the application model.",
        "literalOnly": true
      },
      {
        "propertyName": "key",
        "type": "text",
        "description": "A string representing key used to store the data in the local storage"
      },
      {
        "propertyName": "sharedBy",
        "type": "text",
        "description": "A user ID - the given user must share the key with you to have access"
      },
      {
        "propertyName": "shares",
        "type": "code/javascript",
        "description": "A list of user ids to share this data with (read/write permissions). For partitioned data, can be a function returning a list of user ids: <code>(id, data) => ...</code>",
        "literalOnly": true
      },
      {
        "propertyName": "readOnlyShares",
        "type": "code/javascript",
        "description": "A list of user ids to share this data with (read-only permission). For partitioned data, can be a function returning a list of user ids: <code>(id, data) => ...</code>",
        "literalOnly": true
      },
      {
        "propertyName": "partitionKey",
        "type": "text",
        "description": "If a partition key is defined, the data, which is an array, will be partitioned in several sub-keys (main-key::partition-key), which can be shared and synchronized independently",
        "literalOnly": true
      },
      {
        "propertyName": "remote",
        "type": "checkbox",
        "description": "If set, the storage is only remote (on the server) and no data is stored locally in the browser - the user must be authenticated"
      },
      {
        "propertyName": "defaultValue",
        "type": "text",
        "description": "The default value of the data model when the data does not exist yet in the local storage or when its value is not valid"
      }
    ],
    "DataMapper": [
      {
        "propertyName": "mapper",
        "type": "code/javascript",
        "description": "A functional expression that maps (transforms, filters, sorts, reduces, ...) the data from the data source to the data model. For instance: <code>data => data.filter(d => d.category === \"c\")</code>"
      }
    ],
    "GeolocConnector": [
      {
        "propertyName": "enableHighAccuracy",
        "type": "checkbox",
        "description": "A boolean value that indicates the application would like to receive the best possible results. If <code>true</code> and if the device is able to provide a more accurate position, it will do so. Note that this can result in slower response times or increased power consumption (with a GPS chip on a mobile device for example). On the other hand, if <code>false</code>, the device can take the liberty to save resources by responding more quickly and/or using less power. Default: <code>false</code>."
      },
      {
        "propertyName": "timeout",
        "type": "number",
        "description": "A positive long value representing the maximum length of time (in milliseconds) the device is allowed to take in order to return a position. The default value is Infinity, meaning that <code>getCurrentPosition()</code> won't return until the position is available."
      },
      {
        "propertyName": "maximumAge",
        "type": "text",
        "description": "A positive long value indicating the maximum age in milliseconds of a possible cached position that is acceptable to return. If set to <code>0</code>, it means that the device cannot use a cached position and must attempt to retrieve the real current position. If set to <code>Infinity</code> the device must return a cached position regardless of its age. Default: <code>0</code>."
      }
    ],
    "TextView": [
      {
        "propertyName": "tag",
        "type": "select",
        "description": "The wrapping element being used - default is \"Block\"",
        "possibleValues": [
          {
            "value": "div",
            "text": "Block"
          },
          {
            "value": "p",
            "text": "Paragraph"
          },
          {
            "value": "h1",
            "text": "Heading 1"
          },
          {
            "value": "h2",
            "text": "Heading 2"
          },
          {
            "value": "h3",
            "text": "Heading 3"
          },
          {
            "value": "h4",
            "text": "Heading 4"
          },
          {
            "value": "h5",
            "text": "Heading 5"
          },
          {
            "value": "h6",
            "text": "Heading 6"
          },
          {
            "value": "badge",
            "text": "Badge"
          },
          {
            "value": "alert",
            "text": "Alert"
          },
          {
            "value": "b",
            "text": "Bold"
          },
          {
            "value": "i",
            "text": "Italic"
          },
          {
            "value": "u",
            "text": "Underline"
          },
          {
            "value": "del",
            "text": "Line-trough"
          }
        ]
      },
      {
        "propertyName": "cols",
        "type": "select",
        "description": "Max number of text columns. The actual number depends on the column width if defined.",
        "possibleValues": [
          1,
          2,
          3,
          4,
          5,
          6,
          7,
          8,
          9,
          10,
          11,
          12
        ]
      },
      {
        "propertyName": "colWidth",
        "type": "text",
        "description": "A minimum width for the text columns (as a CSS width)"
      },
      {
        "propertyName": "columnGap",
        "type": "text"
      },
      {
        "propertyName": "text",
        "type": "code/html"
      },
      {
        "propertyName": "variant",
        "type": "select",
        "possibleValues": [
          "primary",
          "secondary",
          "success",
          "danger",
          "warning",
          "info",
          "light",
          "dark",
          "outline-primary",
          "outline-secondary",
          "outline-success",
          "outline-danger",
          "outline-warning",
          "outline-info",
          "outline-light",
          "outline-dark",
          "link"
        ]
      },
      {
        "propertyName": "pill",
        "type": "checkbox"
      },
      {
        "propertyName": "markdown",
        "type": "checkbox"
      },
      {
        "propertyName": "field",
        "type": "text",
        "description": "The identifier of the field in the data source (only if the data source is an object)"
      }
    ],
    "CheckboxView": [
      {
        "propertyName": "disabled",
        "type": "checkbox"
      },
      {
        "propertyName": "horizontalLayout",
        "type": "checkbox"
      },
      {
        "propertyName": "required",
        "type": "checkbox",
        "description": "When placed in a form container, the value must be defined when submitting the form"
      },
      {
        "propertyName": "state",
        "type": "text"
      },
      {
        "propertyName": "labelClass",
        "type": "text",
        "description": "Class(es) (space-separated) applying to the label"
      },
      {
        "propertyName": "switch",
        "type": "checkbox"
      },
      {
        "propertyName": "size",
        "type": "select",
        "possibleValues": [
          "default",
          "sm",
          "md",
          "lg"
        ]
      },
      {
        "propertyName": "field",
        "type": "text",
        "description": "The identifier of the field in the data source (only if the data source is an object)"
      },
      {
        "propertyName": "label",
        "type": "text"
      },
      {
        "propertyName": "description",
        "type": "text"
      },
      {
        "propertyName": "invalidFeedback",
        "type": "text"
      },
      {
        "propertyName": "validFeedback",
        "type": "text"
      }
    ],
    "SelectView": [
      {
        "propertyName": "options",
        "type": "code/javascript",
        "description": "A list of strings or objects containing <code>value</code> and <code>text</code> properties (or <code>html</code> to use with caution for formatted text)",
        "literalOnly": true
      },
      {
        "propertyName": "showDescriptionAsPopover",
        "type": "checkbox",
        "description": "When checked, an information button will be added to open a popup with the description inside"
      },
      {
        "propertyName": "horizontalLayout",
        "type": "checkbox"
      },
      {
        "propertyName": "allowClearSelection",
        "type": "checkbox",
        "description": "When checked, the user can clear the selection (for dropdown)"
      },
      {
        "propertyName": "displayAsChoices",
        "type": "checkbox",
        "literalOnly": true
      },
      {
        "propertyName": "choicesClass",
        "type": "text",
        "description": "CSS class(es) for the choices"
      },
      {
        "propertyName": "choicesSize",
        "type": "select",
        "description": "Size for the choices (xl is usually for mobile)",
        "possibleValues": [
          "default",
          "sm",
          "md",
          "lg",
          "xl"
        ]
      },
      {
        "propertyName": "buttons",
        "type": "checkbox",
        "literalOnly": true
      },
      {
        "propertyName": "dropdown",
        "type": "checkbox"
      },
      {
        "propertyName": "noNavbarOverlap",
        "type": "checkbox",
        "description": "When dropdown shows as a sidebar, it will not overlap the navbar"
      },
      {
        "propertyName": "buttonVariant",
        "type": "select",
        "possibleValues": [
          "primary",
          "secondary",
          "success",
          "danger",
          "warning",
          "info",
          "light",
          "dark",
          "outline-primary",
          "outline-secondary",
          "outline-success",
          "outline-danger",
          "outline-warning",
          "outline-info",
          "outline-light",
          "outline-dark",
          "link"
        ]
      },
      {
        "propertyName": "dropdownButtonVariant",
        "type": "select",
        "possibleValues": [
          "primary",
          "secondary",
          "success",
          "danger",
          "warning",
          "info",
          "light",
          "dark",
          "outline-primary",
          "outline-secondary",
          "outline-success",
          "outline-danger",
          "outline-warning",
          "outline-info",
          "outline-light",
          "outline-dark",
          "link"
        ]
      },
      {
        "propertyName": "dropdownButtonSplitVariant",
        "type": "select",
        "possibleValues": [
          "primary",
          "secondary",
          "success",
          "danger",
          "warning",
          "info",
          "light",
          "dark",
          "outline-primary",
          "outline-secondary",
          "outline-success",
          "outline-danger",
          "outline-warning",
          "outline-info",
          "outline-light",
          "outline-dark",
          "link"
        ]
      },
      {
        "propertyName": "dropdownButtonSplit",
        "type": "checkbox",
        "description": "When set, renders a split button dropdown"
      },
      {
        "propertyName": "dropdownButtonText",
        "type": "text"
      },
      {
        "propertyName": "dropdownMenuClass",
        "type": "text",
        "description": "The class applyied to the dropdown menu content (including when showing as sidebar). If not defined, defaults to <code>container</code>"
      },
      {
        "propertyName": "hideChoicesInDropdown",
        "type": "checkbox",
        "description": "When set, the dropdown menu does not show the default choices, but only the custom component if any"
      },
      {
        "propertyName": "customHeaderInDropdown",
        "type": "checkbox",
        "description": "Shows a custom/editable header in the dropdown (instead of the default one if any)"
      },
      {
        "propertyName": "customFooterInDropdown",
        "type": "checkbox",
        "description": "Shows a custom/editable footer in the dropdown"
      },
      {
        "propertyName": "dropdownAsSideBarScreenSize",
        "type": "select",
        "description": "Shows the dropdown menu as a sidebar when the screen size is smaller than the given breakpoint",
        "possibleValues": [
          {
            "text": "SM",
            "value": 576
          },
          {
            "text": "MD",
            "value": 768
          },
          {
            "text": "LG",
            "value": 992
          },
          {
            "text": "XL",
            "value": 1200
          }
        ]
      },
      {
        "propertyName": "stacked",
        "type": "checkbox"
      },
      {
        "propertyName": "labelCols",
        "type": "range",
        "description": "Number of columns for the label when horizontal layout (0 or undefined is auto)"
      },
      {
        "propertyName": "placeholder",
        "type": "text",
        "description": "A text to display in the select when no value is selected"
      },
      {
        "propertyName": "labelClass",
        "type": "text",
        "description": "Class(es) (space-separated) applying to the label"
      },
      {
        "propertyName": "selectSize",
        "type": "range"
      },
      {
        "propertyName": "multiple",
        "type": "checkbox",
        "description": "If set, allows multiple selection (the data model is an array)"
      },
      {
        "propertyName": "required",
        "type": "checkbox",
        "description": "When placed in a form container, the value must be defined when submitting the form"
      },
      {
        "propertyName": "disabled",
        "type": "checkbox"
      },
      {
        "propertyName": "state",
        "type": "text"
      },
      {
        "propertyName": "size",
        "type": "select",
        "possibleValues": [
          "default",
          "sm",
          "md",
          "lg"
        ]
      },
      {
        "propertyName": "field",
        "type": "text",
        "description": "The identifier of the field in the data source (only if the data source is an object)"
      },
      {
        "propertyName": "label",
        "type": "text"
      },
      {
        "propertyName": "description",
        "type": "text"
      },
      {
        "propertyName": "invalidFeedback",
        "type": "text"
      },
      {
        "propertyName": "validFeedback",
        "type": "text"
      }
    ],
    "InputView": [
      {
        "propertyName": "inputType",
        "type": "select",
        "possibleValues": [
          "text",
          "password",
          "email",
          "number",
          "formatted-number",
          "url",
          "tel",
          "search",
          "date",
          "datetime-local",
          "month",
          "week",
          "time",
          "range",
          "color"
        ]
      },
      {
        "propertyName": "fillHeight",
        "type": "checkbox",
        "description": "Stretch vertically to fill the parent component height",
        "literalOnly": true
      },
      {
        "propertyName": "mask",
        "type": "text",
        "description": "An input mask. For instance: <code>##:##</code>. <code>#</code>: Number (0-9), <code>A</code>: Letter in any case (a-z,A-Z), <code>N</code>: Number or letter (a-z,A-Z,0-9), <code>X</code>: Any symbol, <code>?</code> Optional (next character)"
      },
      {
        "propertyName": "autocomplete",
        "type": "select",
        "description": "If <code>off</code>, the browser will not fill the value automatically with previously saved values (default is <code>on</code>)",
        "possibleValues": [
          "on",
          "off"
        ]
      },
      {
        "propertyName": "showUploadButton",
        "type": "checkbox",
        "description": "Allow the user to upload a file and set this URL field with an encoded file value"
      },
      {
        "propertyName": "maximumUploadSize",
        "type": "number",
        "description": "Default is 1024KB (= 1MB)"
      },
      {
        "propertyName": "showCameraButton",
        "type": "select",
        "description": "Select a camera connector (create one if needed) in order to allow the user to fill this URL field with an encoded picture taken with the current device's camera"
      },
      {
        "propertyName": "showAsPreview",
        "type": "select",
        "description": "Show the URL with data preview and do not show the input with the encoded data",
        "possibleValues": [
          "image",
          "embed",
          "iframe",
          "video",
          "audio",
          "file"
        ]
      },
      {
        "propertyName": "defaultImage",
        "type": "checkbox",
        "description": "Shows a default image when the image URL is not defined"
      },
      {
        "propertyName": "proxy",
        "type": "checkbox",
        "description": "Use a proxy to access the file"
      },
      {
        "propertyName": "proxyCache",
        "type": "checkbox",
        "description": "Cache files in the proxy and get files from the proxy cache (warning: no effects if caching is not enabled for the proxy)"
      },
      {
        "propertyName": "compressionQuality",
        "type": "range",
        "description": "A hint for the compression quality (if proxy has compression enabled)"
      },
      {
        "propertyName": "resizingWidth",
        "type": "number",
        "description": "A hint for resizing width (if resizing is supported for media file), in pixels"
      },
      {
        "propertyName": "resizingHeight",
        "type": "number",
        "description": "A hint for resizing width (if resizing is supported for media file), in pixels"
      },
      {
        "propertyName": "forceRawContent",
        "type": "checkbox",
        "description": "When checked, the accessed file is the raw (original) content (warning: no effects if compression is not enabled for the proxy)"
      },
      {
        "propertyName": "showDownloadButton",
        "type": "checkbox",
        "description": "Allow the user to download URL as a local file"
      },
      {
        "propertyName": "showDeleteButton",
        "type": "checkbox",
        "description": "Allow the user to delete the URL data"
      },
      {
        "propertyName": "downloadFileName",
        "type": "text",
        "description": "A file name to use when downloading the file"
      },
      {
        "propertyName": "previewClass",
        "type": "text",
        "description": "CSS class(es) to apply to the file preview (case of a URL input type with a preview)"
      },
      {
        "propertyName": "previewStyle",
        "type": "text",
        "description": "CSS style to apply to the file preview (case of a URL input type with a preview)"
      },
      {
        "propertyName": "hiddenInputClass",
        "type": "text",
        "description": "CSS class(es) to apply when the input is not showing (the input shows only when the user clicks)"
      },
      {
        "propertyName": "hiddenInputStyle",
        "type": "text",
        "description": "CSS style to apply when the input is not showing (the input shows only when the user clicks)"
      },
      {
        "propertyName": "disabled",
        "type": "checkbox"
      },
      {
        "propertyName": "showInputOnClick",
        "type": "checkbox"
      },
      {
        "propertyName": "formatter",
        "type": "code/javascript",
        "description": "A function that formats the value that is shown when <code>showInputOnClick</code> is selected and the input is not active.",
        "literalOnly": true
      },
      {
        "propertyName": "required",
        "type": "checkbox",
        "description": "A value evaluating to true is required for this control to have a valid state"
      },
      {
        "propertyName": "suggestions",
        "type": "code/javascript",
        "description": "A list of suggestions (string values) to show to the user when typing in",
        "literalOnly": true
      },
      {
        "propertyName": "placeholder",
        "type": "text"
      },
      {
        "propertyName": "min"
      },
      {
        "propertyName": "max"
      },
      {
        "propertyName": "step",
        "type": "number"
      },
      {
        "propertyName": "horizontalLayout",
        "type": "checkbox"
      },
      {
        "propertyName": "labelCols",
        "type": "range",
        "description": "Number of columns for the label when horizontal layout"
      },
      {
        "propertyName": "labelClass",
        "type": "text",
        "description": "Class(es) (space-separated) applying to the label"
      },
      {
        "propertyName": "size",
        "type": "select",
        "possibleValues": [
          "default",
          "sm",
          "md",
          "lg"
        ]
      },
      {
        "propertyName": "showDescriptionAsPopover",
        "type": "checkbox",
        "description": "When checked, an information button will be added to open a popup with the description inside"
      },
      {
        "propertyName": "state",
        "type": "text"
      },
      {
        "propertyName": "numberStyle",
        "type": "select",
        "possibleValues": [
          {
            "value": "decimal",
            "text": "\"decimal\" for plain number formatting"
          },
          {
            "value": "currency",
            "text": "\"currency\" for currency formatting"
          },
          {
            "value": "percent",
            "text": "\"percent\" for percent formatting"
          },
          {
            "value": "unit",
            "text": "\"unit\" for unit formatting"
          }
        ],
        "literalOnly": true
      },
      {
        "propertyName": "locale",
        "type": "select",
        "possibleValues": [
          {
            "text": ""
          },
          {
            "text": "en (English)",
            "value": "en"
          }
        ]
      },
      {
        "propertyName": "currency",
        "type": "select",
        "possibleValues": [
          "",
          {
            "text": "AED (undefined)",
            "value": "AED"
          },
          {
            "text": "AFN (undefined)",
            "value": "AFN"
          },
          {
            "text": "ALL (undefined)",
            "value": "ALL"
          },
          {
            "text": "AMD (undefined)",
            "value": "AMD"
          },
          {
            "text": "ANG (undefined)",
            "value": "ANG"
          },
          {
            "text": "AOA (undefined)",
            "value": "AOA"
          },
          {
            "text": "ARS (undefined)",
            "value": "ARS"
          },
          {
            "text": "AUD (undefined)",
            "value": "AUD"
          },
          {
            "text": "AWG (undefined)",
            "value": "AWG"
          },
          {
            "text": "AZN (undefined)",
            "value": "AZN"
          },
          {
            "text": "BAM (undefined)",
            "value": "BAM"
          },
          {
            "text": "BBD (undefined)",
            "value": "BBD"
          },
          {
            "text": "BDT (undefined)",
            "value": "BDT"
          },
          {
            "text": "BGN (undefined)",
            "value": "BGN"
          },
          {
            "text": "BHD (undefined)",
            "value": "BHD"
          },
          {
            "text": "BIF (undefined)",
            "value": "BIF"
          },
          {
            "text": "BMD (undefined)",
            "value": "BMD"
          },
          {
            "text": "BND (undefined)",
            "value": "BND"
          },
          {
            "text": "BOB (undefined)",
            "value": "BOB"
          },
          {
            "text": "BRL (undefined)",
            "value": "BRL"
          },
          {
            "text": "BSD (undefined)",
            "value": "BSD"
          },
          {
            "text": "BTN (undefined)",
            "value": "BTN"
          },
          {
            "text": "BWP (undefined)",
            "value": "BWP"
          },
          {
            "text": "BYN (undefined)",
            "value": "BYN"
          },
          {
            "text": "BZD (undefined)",
            "value": "BZD"
          },
          {
            "text": "CAD (undefined)",
            "value": "CAD"
          },
          {
            "text": "CDF (undefined)",
            "value": "CDF"
          },
          {
            "text": "CHF (undefined)",
            "value": "CHF"
          },
          {
            "text": "CLP (undefined)",
            "value": "CLP"
          },
          {
            "text": "CNY (undefined)",
            "value": "CNY"
          },
          {
            "text": "COP (undefined)",
            "value": "COP"
          },
          {
            "text": "CRC (undefined)",
            "value": "CRC"
          },
          {
            "text": "CUC (undefined)",
            "value": "CUC"
          },
          {
            "text": "CUP (undefined)",
            "value": "CUP"
          },
          {
            "text": "CVE (undefined)",
            "value": "CVE"
          },
          {
            "text": "CZK (undefined)",
            "value": "CZK"
          },
          {
            "text": "DJF (undefined)",
            "value": "DJF"
          },
          {
            "text": "DKK (undefined)",
            "value": "DKK"
          },
          {
            "text": "DOP (undefined)",
            "value": "DOP"
          },
          {
            "text": "DZD (undefined)",
            "value": "DZD"
          },
          {
            "text": "EGP (undefined)",
            "value": "EGP"
          },
          {
            "text": "ERN (undefined)",
            "value": "ERN"
          },
          {
            "text": "ETB (undefined)",
            "value": "ETB"
          },
          {
            "text": "EUR (undefined)",
            "value": "EUR"
          },
          {
            "text": "FJD (undefined)",
            "value": "FJD"
          },
          {
            "text": "FKP (undefined)",
            "value": "FKP"
          },
          {
            "text": "GBP (undefined)",
            "value": "GBP"
          },
          {
            "text": "GEL (undefined)",
            "value": "GEL"
          },
          {
            "text": "GHS (undefined)",
            "value": "GHS"
          },
          {
            "text": "GIP (undefined)",
            "value": "GIP"
          },
          {
            "text": "GMD (undefined)",
            "value": "GMD"
          },
          {
            "text": "GNF (undefined)",
            "value": "GNF"
          },
          {
            "text": "GTQ (undefined)",
            "value": "GTQ"
          },
          {
            "text": "GYD (undefined)",
            "value": "GYD"
          },
          {
            "text": "HKD (undefined)",
            "value": "HKD"
          },
          {
            "text": "HNL (undefined)",
            "value": "HNL"
          },
          {
            "text": "HRK (undefined)",
            "value": "HRK"
          },
          {
            "text": "HTG (undefined)",
            "value": "HTG"
          },
          {
            "text": "HUF (undefined)",
            "value": "HUF"
          },
          {
            "text": "IDR (undefined)",
            "value": "IDR"
          },
          {
            "text": "ILS (undefined)",
            "value": "ILS"
          },
          {
            "text": "INR (undefined)",
            "value": "INR"
          },
          {
            "text": "IQD (undefined)",
            "value": "IQD"
          },
          {
            "text": "IRR (undefined)",
            "value": "IRR"
          },
          {
            "text": "ISK (undefined)",
            "value": "ISK"
          },
          {
            "text": "JMD (undefined)",
            "value": "JMD"
          },
          {
            "text": "JOD (undefined)",
            "value": "JOD"
          },
          {
            "text": "JPY (undefined)",
            "value": "JPY"
          },
          {
            "text": "KES (undefined)",
            "value": "KES"
          },
          {
            "text": "KGS (undefined)",
            "value": "KGS"
          },
          {
            "text": "KHR (undefined)",
            "value": "KHR"
          },
          {
            "text": "KMF (undefined)",
            "value": "KMF"
          },
          {
            "text": "KPW (undefined)",
            "value": "KPW"
          },
          {
            "text": "KRW (undefined)",
            "value": "KRW"
          },
          {
            "text": "KWD (undefined)",
            "value": "KWD"
          },
          {
            "text": "KYD (undefined)",
            "value": "KYD"
          },
          {
            "text": "KZT (undefined)",
            "value": "KZT"
          },
          {
            "text": "LAK (undefined)",
            "value": "LAK"
          },
          {
            "text": "LBP (undefined)",
            "value": "LBP"
          },
          {
            "text": "LKR (undefined)",
            "value": "LKR"
          },
          {
            "text": "LRD (undefined)",
            "value": "LRD"
          },
          {
            "text": "LSL (undefined)",
            "value": "LSL"
          },
          {
            "text": "LYD (undefined)",
            "value": "LYD"
          },
          {
            "text": "MAD (undefined)",
            "value": "MAD"
          },
          {
            "text": "MDL (undefined)",
            "value": "MDL"
          },
          {
            "text": "MGA (undefined)",
            "value": "MGA"
          },
          {
            "text": "MKD (undefined)",
            "value": "MKD"
          },
          {
            "text": "MMK (undefined)",
            "value": "MMK"
          },
          {
            "text": "MNT (undefined)",
            "value": "MNT"
          },
          {
            "text": "MOP (undefined)",
            "value": "MOP"
          },
          {
            "text": "MRU (undefined)",
            "value": "MRU"
          },
          {
            "text": "MUR (undefined)",
            "value": "MUR"
          },
          {
            "text": "MVR (undefined)",
            "value": "MVR"
          },
          {
            "text": "MWK (undefined)",
            "value": "MWK"
          },
          {
            "text": "MXN (undefined)",
            "value": "MXN"
          },
          {
            "text": "MYR (undefined)",
            "value": "MYR"
          },
          {
            "text": "MZN (undefined)",
            "value": "MZN"
          },
          {
            "text": "NAD (undefined)",
            "value": "NAD"
          },
          {
            "text": "NGN (undefined)",
            "value": "NGN"
          },
          {
            "text": "NIO (undefined)",
            "value": "NIO"
          },
          {
            "text": "NOK (undefined)",
            "value": "NOK"
          },
          {
            "text": "NPR (undefined)",
            "value": "NPR"
          },
          {
            "text": "NZD (undefined)",
            "value": "NZD"
          },
          {
            "text": "OMR (undefined)",
            "value": "OMR"
          },
          {
            "text": "PAB (undefined)",
            "value": "PAB"
          },
          {
            "text": "PEN (undefined)",
            "value": "PEN"
          },
          {
            "text": "PGK (undefined)",
            "value": "PGK"
          },
          {
            "text": "PHP (undefined)",
            "value": "PHP"
          },
          {
            "text": "PKR (undefined)",
            "value": "PKR"
          },
          {
            "text": "PLN (undefined)",
            "value": "PLN"
          },
          {
            "text": "PYG (undefined)",
            "value": "PYG"
          },
          {
            "text": "QAR (undefined)",
            "value": "QAR"
          },
          {
            "text": "RON (undefined)",
            "value": "RON"
          },
          {
            "text": "RSD (undefined)",
            "value": "RSD"
          },
          {
            "text": "RUB (undefined)",
            "value": "RUB"
          },
          {
            "text": "RWF (undefined)",
            "value": "RWF"
          },
          {
            "text": "SAR (undefined)",
            "value": "SAR"
          },
          {
            "text": "SBD (undefined)",
            "value": "SBD"
          },
          {
            "text": "SCR (undefined)",
            "value": "SCR"
          },
          {
            "text": "SDG (undefined)",
            "value": "SDG"
          },
          {
            "text": "SEK (undefined)",
            "value": "SEK"
          },
          {
            "text": "SGD (undefined)",
            "value": "SGD"
          },
          {
            "text": "SHP (undefined)",
            "value": "SHP"
          },
          {
            "text": "SLL (undefined)",
            "value": "SLL"
          },
          {
            "text": "SOS (undefined)",
            "value": "SOS"
          },
          {
            "text": "SRD (undefined)",
            "value": "SRD"
          },
          {
            "text": "SSP (undefined)",
            "value": "SSP"
          },
          {
            "text": "STN (undefined)",
            "value": "STN"
          },
          {
            "text": "SVC (undefined)",
            "value": "SVC"
          },
          {
            "text": "SYP (undefined)",
            "value": "SYP"
          },
          {
            "text": "SZL (undefined)",
            "value": "SZL"
          },
          {
            "text": "THB (undefined)",
            "value": "THB"
          },
          {
            "text": "TJS (undefined)",
            "value": "TJS"
          },
          {
            "text": "TMT (undefined)",
            "value": "TMT"
          },
          {
            "text": "TND (undefined)",
            "value": "TND"
          },
          {
            "text": "TOP (undefined)",
            "value": "TOP"
          },
          {
            "text": "TRY (undefined)",
            "value": "TRY"
          },
          {
            "text": "TTD (undefined)",
            "value": "TTD"
          },
          {
            "text": "TWD (undefined)",
            "value": "TWD"
          },
          {
            "text": "TZS (undefined)",
            "value": "TZS"
          },
          {
            "text": "UAH (undefined)",
            "value": "UAH"
          },
          {
            "text": "UGX (undefined)",
            "value": "UGX"
          },
          {
            "text": "USD (United States dollar)",
            "value": "USD"
          },
          {
            "text": "UYU (undefined)",
            "value": "UYU"
          },
          {
            "text": "UZS (undefined)",
            "value": "UZS"
          },
          {
            "text": "VES (undefined)",
            "value": "VES"
          },
          {
            "text": "VND (undefined)",
            "value": "VND"
          },
          {
            "text": "VUV (undefined)",
            "value": "VUV"
          },
          {
            "text": "WST (undefined)",
            "value": "WST"
          },
          {
            "text": "XAF (undefined)",
            "value": "XAF"
          },
          {
            "text": "XCD (undefined)",
            "value": "XCD"
          },
          {
            "text": "XDR (undefined)",
            "value": "XDR"
          },
          {
            "text": "XOF (undefined)",
            "value": "XOF"
          },
          {
            "text": "XPF (undefined)",
            "value": "XPF"
          },
          {
            "text": "XSU (undefined)",
            "value": "XSU"
          },
          {
            "text": "YER (undefined)",
            "value": "YER"
          },
          {
            "text": "ZAR (undefined)",
            "value": "ZAR"
          },
          {
            "text": "ZMW (undefined)",
            "value": "ZMW"
          },
          {
            "text": "ZWL (undefined)",
            "value": "ZWL"
          }
        ]
      },
      {
        "propertyName": "currencyDisplay",
        "type": "select",
        "possibleValues": [
          {
            "value": "symbol",
            "text": "\"symbol\" to use a localized currency symbol such as €, this is the default value"
          },
          {
            "value": "narrowSymbol",
            "text": "\"narrowSymbol\" to use a narrow format symbol (\"$100\" rather than \"US$100\")"
          },
          {
            "value": "code",
            "text": "\"code\" to use the ISO currency code"
          },
          {
            "value": "name",
            "text": "\"name\" to use a localized currency name such as \"dollar\""
          }
        ]
      },
      {
        "propertyName": "accounting",
        "type": "checkbox",
        "description": "In many locales, accounting format means to wrap the number with parentheses instead of appending a minus sign. Check this to enable this formatting."
      },
      {
        "propertyName": "notation",
        "type": "select",
        "possibleValues": [
          {
            "value": "standard",
            "text": "\"standard\" - plain number formatting"
          },
          {
            "value": "scientific",
            "text": "\"scientific\" - order-of-magnitude for formatted number"
          },
          {
            "value": "engineering",
            "text": "\"engineering\" - exponent of ten when divisible by three"
          },
          {
            "value": "compact",
            "text": "\"compact\" - string representing exponent; defaults to using the \"short\" form"
          }
        ]
      },
      {
        "propertyName": "signDisplay",
        "type": "select",
        "possibleValues": [
          {
            "value": "always",
            "text": "\"always\" always display sign"
          },
          {
            "value": "auto",
            "text": "\"auto\" sign display for negative numbers only"
          },
          {
            "value": "exceptZero",
            "text": "\"exceptZero\" sign display for positive and negative numbers, but not zero"
          },
          {
            "value": "negative",
            "text": "\"negative\" sign display for negative numbers only, excluding negative zero."
          },
          {
            "value": "never",
            "text": "\"never\" never display sign"
          }
        ]
      },
      {
        "propertyName": "unit",
        "type": "select",
        "possibleValues": [
          "acre",
          "bit",
          "byte",
          "celsius",
          "centimeter",
          "day",
          "degree",
          "fahrenheit",
          "fluid-ounce",
          "foot",
          "gallon",
          "gigabit",
          "gigabyte",
          "gram",
          "hectare",
          "hour",
          "inch",
          "kilobit",
          "kilobyte",
          "kilogram",
          "kilometer",
          "liter",
          "megabit",
          "megabyte",
          "meter",
          "microsecond",
          "mile",
          "mile-scandinavian",
          "milliliter",
          "millimeter",
          "millisecond",
          "minute",
          "month",
          "nanosecond",
          "ounce",
          "percent",
          "petabyte",
          "pound",
          "second",
          "stone",
          "terabit",
          "terabyte",
          "week",
          "yard",
          "year"
        ]
      },
      {
        "propertyName": "unitDisplay",
        "type": "select",
        "possibleValues": [
          {
            "value": "long",
            "text": "\"long\" (e.g., 16 litres)"
          },
          {
            "value": "short",
            "text": "\"short\" (e.g., 16 l)"
          },
          {
            "value": "narrow",
            "text": "\"narrow\" (e.g., 16l)"
          }
        ]
      },
      {
        "propertyName": "useGrouping",
        "type": "select",
        "possibleValues": [
          {
            "value": "always",
            "text": "\"always\": display grouping separators even if the locale prefers otherwise"
          },
          {
            "value": "auto",
            "text": "\"auto\": display grouping separators based on the locale preference, which may also be dependent on the currency"
          },
          {
            "value": "false",
            "text": "\"false\": do not display grouping separators"
          },
          {
            "value": "min2",
            "text": "\"min2\": display grouping separators when there are at least 2 digits in a group"
          }
        ]
      },
      {
        "propertyName": "roundingMode",
        "type": "select",
        "possibleValues": [
          {
            "value": "ceil",
            "text": "\"ceil\": toward +∞"
          },
          {
            "value": "floor",
            "text": "\"floor\": toward -∞"
          },
          {
            "value": "expand",
            "text": "\"expand\": away from 0"
          },
          {
            "value": "trunc",
            "text": "\"trunc\": toward 0"
          },
          {
            "value": "halfCeil",
            "text": "\"halfCeil\": ties toward +∞"
          },
          {
            "value": "halfFloor",
            "text": "\"halfFloor\": ties toward -∞"
          },
          {
            "value": "halfExpand",
            "text": "\"halfExpand\": ties away from 0"
          },
          {
            "value": "halfTrunc",
            "text": "\"halfTrunc\": ties toward 0"
          },
          {
            "value": "halfEven",
            "text": "\"halfEven\": ties toward the value with even cardinality"
          }
        ]
      },
      {
        "propertyName": "minimumIntegerDigits",
        "type": "number",
        "description": "The minimum number of integer digits to use. Possible values are from 1 to 21; the default is 1."
      },
      {
        "propertyName": "minimumFractionDigits",
        "type": "number",
        "description": "The minimum number of fraction digits to use. Possible values are from 0 to 20; the default for plain number and percent formatting is 0; the default for currency formatting is the number of minor unit digits provided by the ISO 4217 currency code list (2 if the list doesn't provide that information)."
      },
      {
        "propertyName": "maximumFractionDigits",
        "type": "number",
        "description": "The maximum number of fraction digits to use. Possible values are from 0 to 20; the default for plain number formatting is the larger of <code>minimumFractionDigits</code> and 3; the default for currency formatting is the larger of <code>minimumFractionDigits</code> and the number of minor unit digits provided by the ISO 4217 currency code list (2 if the list doesn't provide that information); the default for percent formatting is the larger of <code>minimumFractionDigits</code> and 0."
      },
      {
        "propertyName": "minimumSignificantDigits",
        "type": "number",
        "description": "The minimum number of significant digits to use. Possible values are from 1 to 21; the default is 1."
      },
      {
        "propertyName": "maximumSignificantDigits",
        "type": "number",
        "description": "The maximum number of significant digits to use. Possible values are from 1 to 21; the default is 21."
      },
      {
        "propertyName": "field",
        "type": "text",
        "description": "The identifier of the field in the data source (only if the data source is an object)"
      },
      {
        "propertyName": "label",
        "type": "text"
      },
      {
        "propertyName": "description",
        "type": "text"
      },
      {
        "propertyName": "invalidFeedback",
        "type": "text"
      },
      {
        "propertyName": "validFeedback",
        "type": "text"
      }
    ],
    "TextareaView": [
      {
        "propertyName": "fillHeight",
        "type": "checkbox",
        "description": "Stretch vertically to fill the parent component height",
        "literalOnly": true
      },
      {
        "propertyName": "disabled",
        "type": "checkbox"
      },
      {
        "propertyName": "required",
        "type": "checkbox"
      },
      {
        "propertyName": "placeholder",
        "type": "text"
      },
      {
        "propertyName": "rows",
        "type": "number"
      },
      {
        "propertyName": "maxRows",
        "type": "number"
      },
      {
        "propertyName": "horizontalLayout",
        "type": "checkbox"
      },
      {
        "propertyName": "labelCols",
        "type": "range",
        "description": "Number of columns for the label when horizontal layout"
      },
      {
        "propertyName": "labelClass",
        "type": "text",
        "description": "Class(es) (space-separated) applying to the label"
      },
      {
        "propertyName": "size",
        "type": "select",
        "possibleValues": [
          "default",
          "sm",
          "md",
          "lg"
        ]
      },
      {
        "propertyName": "state",
        "type": "text"
      },
      {
        "propertyName": "codeEditor",
        "type": "checkbox"
      },
      {
        "propertyName": "showLineNumbers",
        "type": "checkbox"
      },
      {
        "propertyName": "mode",
        "type": "select",
        "possibleValues": [
          "",
          "css",
          "java",
          "javascript",
          "json",
          "markdown",
          "php"
        ]
      },
      {
        "propertyName": "field",
        "type": "text",
        "description": "The identifier of the field in the data source (only if the data source is an object)"
      },
      {
        "propertyName": "label",
        "type": "text"
      },
      {
        "propertyName": "description",
        "type": "text"
      },
      {
        "propertyName": "invalidFeedback",
        "type": "text"
      },
      {
        "propertyName": "validFeedback",
        "type": "text"
      }
    ],
    "ButtonView": [
      {
        "propertyName": "buttonType",
        "type": "select",
        "description": "When the button is in a form (see parent containter), select the button type to trigger a <code>submit</code> or <code>reset</code> event in the form",
        "possibleValues": [
          "button",
          "submit",
          "reset"
        ],
        "literalOnly": true
      },
      {
        "propertyName": "title",
        "type": "text",
        "description": "A text that shows as a popover when hovering the button"
      },
      {
        "propertyName": "variant",
        "type": "select",
        "possibleValues": [
          "primary",
          "secondary",
          "success",
          "danger",
          "warning",
          "info",
          "light",
          "dark",
          "outline-primary",
          "outline-secondary",
          "outline-success",
          "outline-danger",
          "outline-warning",
          "outline-info",
          "outline-light",
          "outline-dark",
          "link"
        ]
      },
      {
        "propertyName": "size",
        "type": "select",
        "possibleValues": [
          "default",
          "sm",
          "md",
          "lg"
        ]
      },
      {
        "propertyName": "icon",
        "type": "icon"
      },
      {
        "propertyName": "iconPosition",
        "type": "select",
        "possibleValues": [
          "left",
          "right",
          "top",
          "bottom"
        ]
      },
      {
        "propertyName": "iconAnimation",
        "type": "select",
        "description": "<code>cylon</code>: slides the icon left-right, <code>cylon-vertical</code>: slides the icon up-down, <code>fade</code>: fades the icon in and out, <code>spin</code>: smoothly spins the icon clockwise, <code>spin-reverse</code>: smoothly spins the icon counter-clockwise, <code>spin-pulse</code>: spins the icon clockwise, but in a pulsed step style, <code>spin-reverse-pulse</code>: spins the icon counter-clockwise, but in a pulsed step style, <code>throb</code>: scales the icon in and out",
        "possibleValues": [
          "cylon",
          "cylon-vertical",
          "fade",
          "spin",
          "spin-reverse",
          "spin-pulse",
          "spin-reverse-pulse",
          "throb"
        ]
      },
      {
        "propertyName": "openLinkInNewWindow",
        "type": "checkbox"
      },
      {
        "propertyName": "pill",
        "type": "checkbox"
      },
      {
        "propertyName": "squared",
        "type": "checkbox"
      },
      {
        "propertyName": "block",
        "type": "checkbox"
      },
      {
        "propertyName": "disabled",
        "type": "checkbox"
      },
      {
        "propertyName": "field",
        "type": "text",
        "description": "The identifier of the field in the data source (only if the data source is an object)"
      },
      {
        "propertyName": "label",
        "type": "text"
      },
      {
        "propertyName": "href",
        "type": "text"
      },
      {
        "propertyName": "to",
        "type": "text"
      }
    ],
    "ImageView": [
      {
        "propertyName": "src",
        "type": "text",
        "description": "A URL or formula evaluating to a URL that will override the data model (if not defined, the data model is expected to contain an image URL)"
      },
      {
        "propertyName": "proxy",
        "type": "checkbox",
        "description": "Use a proxy to access the image"
      },
      {
        "propertyName": "proxyCache",
        "type": "checkbox",
        "description": "Cache images in the proxy and get images from the proxy cache (warning: no effects if caching is not enabled for the proxy)"
      },
      {
        "propertyName": "compressionQuality",
        "type": "range",
        "description": "A hint for the compression quality (if proxy has compression enabled)"
      },
      {
        "propertyName": "resizingWidth",
        "type": "number",
        "description": "A hint for resizing width, in pixels"
      },
      {
        "propertyName": "resizingHeight",
        "type": "number",
        "description": "A hint for resizing width, in pixels"
      },
      {
        "propertyName": "forceRawContent",
        "type": "checkbox",
        "description": "When checked, the accessed image is the raw (uncompressed) content (warning: no effects if compression is not enabled for the proxy)"
      },
      {
        "propertyName": "href",
        "type": "text",
        "description": "When defined, wraps this image into a link"
      },
      {
        "propertyName": "openLinkInNewWindow",
        "type": "checkbox"
      },
      {
        "propertyName": "defaultImage",
        "type": "checkbox",
        "description": "Shows a default image when the image URL is not defined"
      },
      {
        "propertyName": "blank",
        "type": "checkbox"
      },
      {
        "propertyName": "blankColor"
      },
      {
        "propertyName": "display",
        "type": "select",
        "possibleValues": [
          "default",
          "block",
          "center",
          "fluid",
          "fluid-grow",
          "left",
          "right"
        ]
      },
      {
        "propertyName": "rounded",
        "type": "checkbox"
      },
      {
        "propertyName": "thumbnail",
        "type": "checkbox"
      },
      {
        "propertyName": "invertColors",
        "type": "checkbox"
      },
      {
        "propertyName": "field",
        "type": "text",
        "description": "The identifier of the field in the data source (only if the data source is an object)"
      },
      {
        "propertyName": "width",
        "type": "text"
      },
      {
        "propertyName": "height",
        "type": "text"
      }
    ],
    "IconView": [
      {
        "propertyName": "useData",
        "type": "checkbox",
        "description": "Use the data model of this component to determine the icon dynamically",
        "literalOnly": true
      },
      {
        "propertyName": "allowUserSelection",
        "type": "checkbox",
        "description": "Allow the user to interactively select a new icon and sets the data with it"
      },
      {
        "propertyName": "icon",
        "type": "icon"
      },
      {
        "propertyName": "variant",
        "type": "select",
        "possibleValues": [
          "primary",
          "secondary",
          "success",
          "danger",
          "warning",
          "info",
          "light",
          "dark"
        ]
      },
      {
        "propertyName": "animation",
        "type": "select",
        "description": "<code>cylon</code>: slides the icon left-right, <code>cylon-vertical</code>: slides the icon up-down, <code>fade</code>: fades the icon in and out, <code>spin</code>: smoothly spins the icon clockwise, <code>spin-reverse</code>: smoothly spins the icon counter-clockwise, <code>spin-pulse</code>: spins the icon clockwise, but in a pulsed step style, <code>spin-reverse-pulse</code>: spins the icon counter-clockwise, but in a pulsed step style, <code>throb</code>: scales the icon in and out",
        "possibleValues": [
          "cylon",
          "cylon-vertical",
          "fade",
          "spin",
          "spin-reverse",
          "spin-pulse",
          "spin-reverse-pulse",
          "throb"
        ]
      },
      {
        "propertyName": "flipHorizontally",
        "type": "checkbox"
      },
      {
        "propertyName": "flipVertically",
        "type": "checkbox"
      },
      {
        "propertyName": "field",
        "type": "text",
        "description": "The identifier of the field in the data source (only if the data source is an object)"
      },
      {
        "propertyName": "rotate",
        "type": "text"
      },
      {
        "propertyName": "scale",
        "type": "text"
      }
    ],
    "ContainerView": [
      {
        "propertyName": "title",
        "type": "text",
        "description": "The title of the container"
      },
      {
        "propertyName": "stepper",
        "type": "checkbox",
        "description": "Makes this container a stepper, meaning that each component will be shown individually and that you can use the <code>next()</code>, <code>previous()</code>, and <code>goto(index)</code> actions to navigate within the components.",
        "literalOnly": true
      },
      {
        "propertyName": "stepperAnimation",
        "type": "select",
        "description": "Transition animations for the stepper.",
        "possibleValues": [
          "none",
          "horizontal-slide",
          "vertical-slide",
          "fade"
        ]
      },
      {
        "propertyName": "stepperAnimationDuration",
        "type": "range",
        "description": "The duration of the transition animations for the stepper (in ms)."
      },
      {
        "propertyName": "rowGap",
        "type": "text"
      },
      {
        "propertyName": "columnGap",
        "type": "text"
      },
      {
        "propertyName": "components",
        "type": "ref"
      },
      {
        "propertyName": "itemClass",
        "type": "text",
        "description": "CSS classes to apply to the items of this container. This fomula can be a function taking the item <code>index</code>, <code>col</code>, and <code>row</code> arguments for a grid layout, for example: <code>(index, row, col) => row === 0 ? \"text-bold\" : undefined</code>"
      },
      {
        "propertyName": "itemStyle",
        "type": "text",
        "description": "CSS to apply to the items of this container. This fomula can be a function taking the item <code>index</code>, <code>col</code>, and <code>row</code> arguments for a grid layout, for example: <code>(index, row, col) => row === 0 ? \"font-size: 0.8rem\" : undefined</code>"
      },
      {
        "propertyName": "backgroundSize",
        "type": "select",
        "description": "A size for the background image (default is <code>cover</code>)",
        "possibleValues": [
          "auto",
          "cover",
          "contain",
          "10%",
          "20%",
          "30%",
          "40%",
          "50%",
          "60%",
          "70%",
          "80%",
          "90%",
          "100%"
        ]
      },
      {
        "propertyName": "cols",
        "type": "select"
      },
      {
        "propertyName": "colWidth",
        "type": "text",
        "description": "A minimum width for the columns (as a CSS width)"
      },
      {
        "propertyName": "backgroundPosition",
        "type": "select",
        "description": "Sets the initial position of the background image (default is center)",
        "possibleValues": [
          "top",
          "bottom",
          "left",
          "right",
          "center",
          "10%",
          "25%",
          "50%",
          "75%",
          "90%"
        ]
      },
      {
        "propertyName": "backgroundImage",
        "type": "text",
        "description": "An image to be used for the background of this container. Can be a css gradient, e.g.: <code>linear-gradient(red, blue 10%)</code>"
      },
      {
        "propertyName": "backgroundOpacity",
        "type": "range",
        "description": "An opacity factor to apply to the background variant (if background variant is defined)"
      },
      {
        "propertyName": "form",
        "type": "checkbox",
        "description": "If enabled, this container acts as a form and reacts on <code>@submit</code> and <code>@reset</code> events",
        "literalOnly": true
      },
      {
        "propertyName": "showStateOnInput",
        "type": "checkbox",
        "description": "If enabled, all contained controls show their state as soon as the user inputs a new value",
        "literalOnly": true
      },
      {
        "propertyName": "nativeValidation",
        "type": "checkbox",
        "description": "When set, enables browser native HTML5 validation on controls in the form",
        "literalOnly": true
      },
      {
        "propertyName": "fillHeight",
        "type": "checkbox",
        "description": "Stretch vertically to fill the parent component height",
        "literalOnly": true
      },
      {
        "propertyName": "containerKind",
        "type": "select",
        "description": "Default is <code>no-padding</code> - other values correspond to the boostrap classes (see the doc)",
        "possibleValues": [
          "no-padding",
          "container",
          "container-sm",
          "container-md",
          "container-lg",
          "container-xl",
          "container-fluid"
        ]
      },
      {
        "propertyName": "layoutKind",
        "type": "select",
        "description": "Default is <code>flex</code>. For left-to-right items layout and fixed number of columns, use the <code>grid</code> kind. For top-down items layout, use the <code>column</code> kind. Use <code>list-group</code> to place the items into a vertical list group",
        "possibleValues": [
          "flex",
          "grid",
          "column",
          "list-group"
        ]
      },
      {
        "propertyName": "scrollable",
        "type": "checkbox"
      },
      {
        "propertyName": "focusable",
        "type": "checkbox",
        "description": "Listen to keyboard events.",
        "literalOnly": true
      },
      {
        "propertyName": "direction",
        "type": "select",
        "description": "Tells how to align the items of this container when the <code>flex</code> layout kind is selected. Default is <code>column</code>.",
        "possibleValues": [
          "column",
          "column-reverse",
          "row",
          "row-reverse"
        ]
      },
      {
        "propertyName": "wrap",
        "type": "select",
        "description": "\n                        Tells the wrap behavior when the components overflow the flex container width. \n                        <ul>\n                            <li><code>nowrap</code> (default): all flex items will be on one line.</li> \n                            <li><code>wrap</code>: flex items will wrap onto multiple lines, from top to bottom.</li> \n                            <li><code>wrap-reverse</code>: flex items will wrap onto multiple lines from bottom to top.</li>\n                        </ul>\n                    ",
        "possibleValues": [
          "nowrap",
          "wrap",
          "wrap-reverse"
        ]
      },
      {
        "propertyName": "justify",
        "type": "select",
        "description": "\n                            This defines the flex container alignment along the main axis. It helps distribute extra free space leftover when either all the flex items on a line are inflexible, or are flexible but have reached their maximum size. It also exerts some control over the alignment of items when they overflow the line.\n                            <ul>\n                                <li><code>start</code> (default): items are packed toward the start of the flex direction.</li>\n                                <li><code>end</code>: items are packed toward the end of the flex direction.</li>\n                                <li><code>start</code>: items are packed toward the start of the <code>writing-mode</code> direction.</li>\n                                <li><code>center</code>: items are centered along the line</li>\n                                <li><code>space-between</code>: items are evenly distributed in the line; first item is on the start line, last item on the end line</li>\n                                <li><code>space-around</code>: items are evenly distributed in the line with equal space around them. Note that visually the spaces aren’t equal, since all the items have equal space on both sides. The first item will have one unit of space against the container edge, but two units of space between the next item because that next item has its own spacing that applies.</li>\n                                <li><code>space-evenly</code>: items are distributed so that the spacing between any two items (and the space to the edges) is equal.</li>\n                            </ul>\n                    ",
        "possibleValues": [
          "start",
          "end",
          "center",
          "space-between",
          "space-around",
          "space-evenly"
        ]
      },
      {
        "propertyName": "alignItems",
        "type": "select",
        "description": "\n                        This defines the default behavior for how flex items are laid out along the cross axis on the current line.\n                        <ul>\n                            <li><code>stretch</code> (default): stretch to fill the container (still respect min-width/max-width)</li>\n                            <li><code>start</code>: items are placed at the start of the cross axis. The difference between these is subtle, and is about respecting the flex-direction rules or the writing-mode rules.</li>\n                            <li><code>end</code>: items are placed at the end of the cross axis. The difference again is subtle and is about respecting flex-direction rules vs. writing-mode rules.</li>\n                            <li><code>center</code>: items are centered in the cross-axis</li>\n                            <li><code>baseline</code>: items are aligned such as their baselines align</li> \n                        </ul>\n                    ",
        "possibleValues": [
          "stretch",
          "start",
          "end",
          "center",
          "baseline"
        ]
      },
      {
        "propertyName": "alignContent",
        "type": "select",
        "description": "\n                        This aligns a flex container's lines within when there is extra space in the cross-axis, similar to how <code>justify</code> aligns individual items within the main-axis.\n                        <ul>\n                            <li><code>normal</code> (default): items are packed in their default position as if no&nbsp;value was set.</li>\n                            <li><code>stretch</code>: lines stretch to take up the remaining space</li>\n                            <li><code>start</code>: items packed to the start of the container.</li>\n                            <li><code>end</code>: items packed to the end of the container.</li>\n                            <li><code>center</code>: items centered in the container</li>\n                            <li><code>space-between</code>: items evenly distributed; the first line is at the start of the container while the last one is at the end</li>\n                            <li><code>space-around</code>: items evenly distributed with equal space around each line</li>\n                            <li><code>space-evenly</code>: items are evenly distributed with equal space around them</li>\n                        </ul>                     \n                    ",
        "possibleValues": [
          "normal",
          "stretch",
          "start",
          "end",
          "center",
          "space-between",
          "space-around",
          "space-evenly"
        ]
      },
      {
        "propertyName": "enableLazyLoad",
        "type": "checkbox",
        "description": "When checked, all child components inside this container get lazy loaded when appearing on the screen. Note that before they appear, lazy-loaded components cannot be accessed by other components.",
        "literalOnly": true
      },
      {
        "propertyName": "itemWidthBeforeLazyLoad",
        "type": "text",
        "description": "A CSS width for this container child components before they get lazy loaded"
      },
      {
        "propertyName": "itemHeightBeforeLazyLoad",
        "type": "text",
        "description": "A CSS height for this container child components before they get lazy loaded"
      },
      {
        "propertyName": "field",
        "type": "text",
        "description": "The identifier of the field in the data source (only if the data source is an object)"
      }
    ],
    "ReferenceView": [
      {
        "propertyName": "refId",
        "type": "select"
      },
      {
        "propertyName": "fillHeight",
        "type": "checkbox",
        "description": "Stretch vertically to fill the parent component height",
        "literalOnly": true
      }
    ],
    "SplitView": [
      {
        "propertyName": "resizableSplit",
        "type": "checkbox"
      },
      {
        "propertyName": "fillHeight",
        "type": "checkbox",
        "description": "Stretch vertically to fill the parent component height",
        "literalOnly": true
      },
      {
        "propertyName": "orientation",
        "type": "select",
        "possibleValues": [
          "HORIZONTAL",
          "VERTICAL"
        ]
      },
      {
        "propertyName": "primaryComponent",
        "type": "ref"
      },
      {
        "propertyName": "secondaryComponent",
        "type": "ref"
      },
      {
        "propertyName": "primaryComponentSize",
        "type": "number"
      },
      {
        "propertyName": "secondaryComponentSize",
        "type": "number"
      },
      {
        "propertyName": "componentHidden",
        "type": "select",
        "description": "Hide one of the components",
        "possibleValues": [
          "primary-component",
          "secondary-component"
        ]
      },
      {
        "propertyName": "field",
        "type": "text",
        "description": "The identifier of the field in the data source (only if the data source is an object)"
      },
      {
        "propertyName": "gutterSize",
        "type": "text"
      }
    ],
    "CardView": [
      {
        "propertyName": "fillHeight",
        "type": "checkbox",
        "description": "Stretch vertically to fill the parent component height",
        "literalOnly": true
      },
      {
        "propertyName": "collapsable",
        "type": "checkbox",
        "literalOnly": true
      },
      {
        "propertyName": "initiallyCollapsed",
        "type": "checkbox"
      },
      {
        "propertyName": "visibleIcon",
        "type": "icon"
      },
      {
        "propertyName": "hiddenIcon",
        "type": "icon"
      },
      {
        "propertyName": "imgPosition",
        "type": "select",
        "possibleValues": [
          "top",
          "bottom",
          "left",
          "right",
          "start",
          "end"
        ]
      },
      {
        "propertyName": "imgSrc",
        "type": "text"
      },
      {
        "propertyName": "imgWidth",
        "type": "text"
      },
      {
        "propertyName": "imgHeight",
        "type": "text"
      },
      {
        "propertyName": "text",
        "type": "textarea"
      },
      {
        "propertyName": "headerEnabled",
        "type": "checkbox",
        "literalOnly": true
      },
      {
        "propertyName": "footerEnabled",
        "type": "checkbox",
        "literalOnly": true
      },
      {
        "propertyName": "headerClass",
        "type": "text"
      },
      {
        "propertyName": "headerBgVariant",
        "type": "select",
        "possibleValues": [
          "primary",
          "secondary",
          "success",
          "info",
          "warning",
          "danger",
          "light",
          "dark",
          "default"
        ]
      },
      {
        "propertyName": "headerBorderVariant",
        "type": "select",
        "possibleValues": [
          "primary",
          "secondary",
          "success",
          "info",
          "warning",
          "danger",
          "light",
          "dark",
          "default"
        ]
      },
      {
        "propertyName": "headerTextVariant",
        "type": "select",
        "possibleValues": [
          "primary",
          "secondary",
          "success",
          "info",
          "warning",
          "danger",
          "light",
          "dark",
          "default"
        ]
      },
      {
        "propertyName": "footerClass",
        "type": "text"
      },
      {
        "propertyName": "footerBgVariant",
        "type": "select",
        "possibleValues": [
          "primary",
          "secondary",
          "success",
          "info",
          "warning",
          "danger",
          "light",
          "dark",
          "default"
        ]
      },
      {
        "propertyName": "footerBorderVariant",
        "type": "select",
        "possibleValues": [
          "primary",
          "secondary",
          "success",
          "info",
          "warning",
          "danger",
          "light",
          "dark",
          "default"
        ]
      },
      {
        "propertyName": "footerTextVariant",
        "type": "select",
        "possibleValues": [
          "primary",
          "secondary",
          "success",
          "info",
          "warning",
          "danger",
          "light",
          "dark",
          "default"
        ]
      },
      {
        "propertyName": "textVariant",
        "type": "select",
        "possibleValues": [
          "primary",
          "secondary",
          "success",
          "info",
          "warning",
          "danger",
          "light",
          "dark",
          "default"
        ]
      },
      {
        "propertyName": "bgVariant",
        "type": "select",
        "possibleValues": [
          "primary",
          "secondary",
          "success",
          "info",
          "warning",
          "danger",
          "light",
          "dark",
          "default"
        ]
      },
      {
        "propertyName": "borderVariant",
        "type": "select",
        "possibleValues": [
          "primary",
          "secondary",
          "success",
          "info",
          "warning",
          "danger",
          "light",
          "dark",
          "default"
        ]
      },
      {
        "propertyName": "bodyClass",
        "type": "text"
      },
      {
        "propertyName": "bodyBgVariant",
        "type": "select",
        "possibleValues": [
          "primary",
          "secondary",
          "success",
          "info",
          "warning",
          "danger",
          "light",
          "dark",
          "default"
        ]
      },
      {
        "propertyName": "bodyBorderVariant",
        "type": "select",
        "possibleValues": [
          "primary",
          "secondary",
          "success",
          "info",
          "warning",
          "danger",
          "light",
          "dark",
          "default"
        ]
      },
      {
        "propertyName": "bodyTextVariant",
        "type": "select",
        "possibleValues": [
          "primary",
          "secondary",
          "success",
          "info",
          "warning",
          "danger",
          "light",
          "dark",
          "default"
        ]
      },
      {
        "propertyName": "field",
        "type": "text",
        "description": "The identifier of the field in the data source (only if the data source is an object)"
      },
      {
        "propertyName": "title",
        "type": "text"
      },
      {
        "propertyName": "subTitle",
        "type": "text"
      }
    ],
    "IteratorView": [
      {
        "propertyName": "body",
        "type": "ref"
      },
      {
        "propertyName": "fillHeight",
        "type": "checkbox",
        "description": "Stretch vertically to fill the parent component height",
        "literalOnly": true
      },
      {
        "propertyName": "disableContainerPadding",
        "type": "checkbox",
        "description": "Disable container padding",
        "literalOnly": true
      },
      {
        "propertyName": "stackedMode",
        "type": "checkbox",
        "description": "When checked all the items up to the current page will show.",
        "literalOnly": true
      },
      {
        "propertyName": "stepper",
        "type": "checkbox",
        "description": "Makes this container a stepper, meaning that each component will be shown individually and that you can use the <code>next()</code>, <code>previous()</code>, and <code>goto(index)</code> actions to navigate within the components.",
        "literalOnly": true
      },
      {
        "propertyName": "stepperAnimation",
        "type": "select",
        "description": "Transition animations for the stepper.",
        "possibleValues": [
          "none",
          "horizontal-slide",
          "vertical-slide",
          "fade"
        ]
      },
      {
        "propertyName": "stepperAnimationDuration",
        "type": "range",
        "description": "The duration of the transition animations for the stepper (in ms)."
      },
      {
        "propertyName": "cols",
        "type": "select"
      },
      {
        "propertyName": "colWidth",
        "type": "text",
        "description": "A minimum width for the columns (as a CSS width)"
      },
      {
        "propertyName": "containerKind",
        "type": "select",
        "description": "Default is <code>no-padding</code> - other values correspond to the boostrap classes (see the doc)",
        "possibleValues": [
          "no-padding",
          "container",
          "container-sm",
          "container-md",
          "container-lg",
          "container-xl",
          "container-fluid"
        ]
      },
      {
        "propertyName": "layoutKind",
        "type": "select",
        "description": "Default is <code>flex</code>. For left-to-right items layout and fixed number of columns, use the <code>grid</code> kind. For top-down items layout, use the <code>column</code> kind. Use <code>list-group</code> to place the items into a vertical list group",
        "possibleValues": [
          "flex",
          "grid",
          "column",
          "list-group"
        ]
      },
      {
        "propertyName": "direction",
        "type": "select",
        "description": "Tells how to align the items of this container when the <code>flex</code> layout kind is selected. Default is <code>column</code>.",
        "possibleValues": [
          "column",
          "column-reverse",
          "row",
          "row-reverse"
        ]
      },
      {
        "propertyName": "wrap",
        "type": "select",
        "description": "\n                        Tells the wrap behavior when the components overflow the flex container width. \n                        <ul>\n                            <li><code>nowrap</code> (default): all flex items will be on one line.</li> \n                            <li><code>wrap</code>: flex items will wrap onto multiple lines, from top to bottom.</li> \n                            <li><code>wrap-reverse</code>: flex items will wrap onto multiple lines from bottom to top.</li>\n                        </ul>\n                    ",
        "possibleValues": [
          "nowrap",
          "wrap",
          "wrap-reverse"
        ]
      },
      {
        "propertyName": "justify",
        "type": "select",
        "description": "\n                            This defines the flex container alignment along the main axis. It helps distribute extra free space leftover when either all the flex items on a line are inflexible, or are flexible but have reached their maximum size. It also exerts some control over the alignment of items when they overflow the line.\n                            <ul>\n                                <li><code>start</code> (default): items are packed toward the start of the flex direction.</li>\n                                <li><code>end</code>: items are packed toward the end of the flex direction.</li>\n                                <li><code>start</code>: items are packed toward the start of the <code>writing-mode</code> direction.</li>\n                                <li><code>center</code>: items are centered along the line</li>\n                                <li><code>space-between</code>: items are evenly distributed in the line; first item is on the start line, last item on the end line</li>\n                                <li><code>space-around</code>: items are evenly distributed in the line with equal space around them. Note that visually the spaces aren’t equal, since all the items have equal space on both sides. The first item will have one unit of space against the container edge, but two units of space between the next item because that next item has its own spacing that applies.</li>\n                                <li><code>space-evenly</code>: items are distributed so that the spacing between any two items (and the space to the edges) is equal.</li>\n                            </ul>\n                    ",
        "possibleValues": [
          "start",
          "end",
          "center",
          "space-between",
          "space-around",
          "space-evenly"
        ]
      },
      {
        "propertyName": "alignItems",
        "type": "select",
        "description": "\n                        This defines the default behavior for how flex items are laid out along the cross axis on the current line.\n                        <ul>\n                            <li><code>stretch</code> (default): stretch to fill the container (still respect min-width/max-width)</li>\n                            <li><code>start</code>: items are placed at the start of the cross axis. The difference between these is subtle, and is about respecting the flex-direction rules or the writing-mode rules.</li>\n                            <li><code>end</code>: items are placed at the end of the cross axis. The difference again is subtle and is about respecting flex-direction rules vs. writing-mode rules.</li>\n                            <li><code>center</code>: items are centered in the cross-axis</li>\n                            <li><code>baseline</code>: items are aligned such as their baselines align</li> \n                        </ul>\n                    ",
        "possibleValues": [
          "stretch",
          "start",
          "end",
          "center",
          "baseline"
        ]
      },
      {
        "propertyName": "alignContent",
        "type": "select",
        "description": "\n                        This aligns a flex container's lines within when there is extra space in the cross-axis, similar to how <code>justify</code> aligns individual items within the main-axis.\n                        <ul>\n                            <li><code>normal</code> (default): items are packed in their default position as if no&nbsp;value was set.</li>\n                            <li><code>stretch</code>: lines stretch to take up the remaining space</li>\n                            <li><code>start</code>: items packed to the start of the container.</li>\n                            <li><code>end</code>: items packed to the end of the container.</li>\n                            <li><code>center</code>: items centered in the container</li>\n                            <li><code>space-between</code>: items evenly distributed; the first line is at the start of the container while the last one is at the end</li>\n                            <li><code>space-around</code>: items evenly distributed with equal space around each line</li>\n                            <li><code>space-evenly</code>: items are evenly distributed with equal space around them</li>\n                        </ul>                     \n                    ",
        "possibleValues": [
          "normal",
          "stretch",
          "start",
          "end",
          "center",
          "space-between",
          "space-around",
          "space-evenly"
        ]
      },
      {
        "propertyName": "disableLazyLoad",
        "type": "checkbox",
        "description": "When checked, all component items of this iterator get lazy loaded when appearing on the screen. Note that before they appear, lazy-loaded components cannot be accessed by other components.",
        "literalOnly": true
      },
      {
        "propertyName": "itemWidthBeforeLazyLoad",
        "type": "text",
        "description": "A CSS width for this iterator items before they are lazy loaded (when appearing on the screen)"
      },
      {
        "propertyName": "itemHeightBeforeLazyLoad",
        "type": "text",
        "description": "A CSS height for this iterator items before they are lazy loaded (when appearing on the screen)"
      },
      {
        "propertyName": "field",
        "type": "text",
        "description": "The identifier of the field in the data source (only if the data source is an object)"
      },
      {
        "propertyName": "perPage",
        "type": "text"
      },
      {
        "propertyName": "rowGap",
        "type": "text"
      },
      {
        "propertyName": "columnGap",
        "type": "text"
      }
    ],
    "TabsView": [
      {
        "propertyName": "tabs",
        "type": "ref"
      },
      {
        "propertyName": "tabIndex",
        "type": "code/javascript",
        "description": "A formula to set the initially selected tab index",
        "literalOnly": true
      },
      {
        "propertyName": "validatedTabIndexes",
        "type": "code/javascript",
        "description": "A formula to set the tab validation states. For instance, if you have 3 tabs, [true, false, true] will activate the first and second tabs.",
        "literalOnly": true
      },
      {
        "propertyName": "fillHeight",
        "type": "checkbox",
        "description": "Stretch vertically to fill the parent component height",
        "literalOnly": true
      },
      {
        "propertyName": "align",
        "type": "select",
        "description": "Align the nav items in the nav",
        "possibleValues": [
          "start",
          "center",
          "end"
        ]
      },
      {
        "propertyName": "disableCardLayout",
        "type": "checkbox",
        "description": "Remove the layout of tabs within a card",
        "literalOnly": true
      },
      {
        "propertyName": "pills",
        "type": "checkbox",
        "description": "Render the nav items with the appearance of pill buttons",
        "literalOnly": true
      },
      {
        "propertyName": "wizard",
        "type": "checkbox",
        "description": "Render the nav items with the appearance of steps",
        "literalOnly": true
      },
      {
        "propertyName": "small",
        "type": "checkbox",
        "description": "Make the nav smaller"
      },
      {
        "propertyName": "fill",
        "type": "checkbox",
        "description": "Proportionately fill all horizontal space with nav items. All horizontal space is occupied, but not every nav item has the same width",
        "literalOnly": true
      },
      {
        "propertyName": "justified",
        "type": "checkbox",
        "description": "Fill all horizontal space with nav items, but unlike 'fill', every nav item will be the same width",
        "literalOnly": true
      },
      {
        "propertyName": "vertical",
        "type": "checkbox",
        "description": "Render the tab controls vertically",
        "literalOnly": true
      },
      {
        "propertyName": "end",
        "type": "checkbox",
        "description": "Place the tab controls at the bottom (horizontal tabs), or right (vertical tabs)"
      },
      {
        "propertyName": "lazy",
        "type": "checkbox",
        "description": "Lazily render the tab contents when shown"
      },
      {
        "propertyName": "noFade",
        "type": "checkbox",
        "description": "When set to `true`, disable the fade animation/transition on the component"
      },
      {
        "propertyName": "activeTabClass",
        "type": "text",
        "description": "CSS class (or classes) to apply to the currently active tab"
      },
      {
        "propertyName": "contentClass",
        "type": "text",
        "description": "CSS class (or classes) to apply to the tab-content wrapper"
      },
      {
        "propertyName": "cardClass",
        "type": "text",
        "description": "CSS class (or classes) to apply to card wrapper when the card layout is enabled"
      },
      {
        "propertyName": "field",
        "type": "text",
        "description": "The identifier of the field in the data source (only if the data source is an object)"
      }
    ],
    "CollapseView": [
      {
        "propertyName": "body",
        "type": "ref"
      },
      {
        "propertyName": "accordion",
        "type": "text",
        "description": "The name of the accordion group that this collapse belongs to, if any"
      },
      {
        "propertyName": "appear",
        "type": "checkbox",
        "description": "When set, and visible is true, will animate on initial display"
      },
      {
        "propertyName": "visible",
        "type": "checkbox",
        "description": "Sets the initial visibility of the collapse"
      },
      {
        "propertyName": "field",
        "type": "text",
        "description": "The identifier of the field in the data source (only if the data source is an object)"
      }
    ],
    "DialogView": [
      {
        "propertyName": "showAsSidebar",
        "type": "checkbox"
      },
      {
        "propertyName": "content",
        "type": "ref"
      },
      {
        "propertyName": "bodyClass",
        "type": "text"
      },
      {
        "propertyName": "headerClass",
        "type": "text"
      },
      {
        "propertyName": "size",
        "type": "select",
        "possibleValues": [
          "sm",
          "md",
          "lg",
          "xl"
        ]
      },
      {
        "propertyName": "scrollable",
        "type": "checkbox",
        "description": "Enables scrolling of the modal body"
      },
      {
        "propertyName": "centered",
        "type": "checkbox",
        "description": "Vertically centers the modal in the viewport"
      },
      {
        "propertyName": "footerClass",
        "type": "text"
      },
      {
        "propertyName": "sidebarClass",
        "type": "text",
        "description": "CSS class(es) to be applied to the sidebar, when showing as a sidebar"
      },
      {
        "propertyName": "footerTag",
        "type": "text",
        "description": "Specify the HTML tag to render instead of the default tag for the footer ('footer')"
      },
      {
        "propertyName": "headerTag",
        "type": "text",
        "description": "Specify the HTML tag to render instead of the default tag for the header ('header')"
      },
      {
        "propertyName": "tag",
        "type": "text",
        "description": "Specify the HTML tag to render instead of the default tag ('div')"
      },
      {
        "propertyName": "noCloseOnBackdrop",
        "type": "checkbox",
        "description": "When checked, disables closing the sidebar when the user clicks on the backdrop. Requires \"backdrop\" be checked"
      },
      {
        "propertyName": "noCloseOnEsc",
        "type": "checkbox",
        "description": "When checked, disables closing the sidebar when the user presses ESC"
      },
      {
        "propertyName": "noCloseRouteChange",
        "type": "checkbox",
        "description": "When checked, disables closing of the sidebar on route change"
      },
      {
        "propertyName": "noEnforceFocus",
        "type": "checkbox",
        "description": "Disables the enforce focus routine which maintains focus inside the sidebar"
      },
      {
        "propertyName": "noHeader",
        "type": "checkbox",
        "description": "When checked, disables rendering of the default header (including close button)"
      },
      {
        "propertyName": "noHeaderClose",
        "type": "checkbox",
        "description": "When checked, disables rendering of the header close button"
      },
      {
        "propertyName": "noSlide",
        "type": "checkbox",
        "description": "When checked, disables the default sliding animation"
      },
      {
        "propertyName": "right",
        "type": "checkbox",
        "description": "When checked, positions the sidebar on the right of the viewport"
      },
      {
        "propertyName": "lazy",
        "type": "checkbox",
        "description": "When checked, the content of the sidebar will only be rendered while the sidebar is open"
      },
      {
        "propertyName": "backdrop",
        "type": "checkbox",
        "description": "When checked, shows a backdrop when the sidebar is open"
      },
      {
        "propertyName": "shadow",
        "type": "select",
        "description": "Configures the sidebar shadow. Default is no shadow",
        "possibleValues": [
          {
            "text": "no shadow",
            "value": false
          },
          {
            "text": "small shadow",
            "value": "sm"
          },
          {
            "text": "shadow",
            "value": true
          },
          {
            "text": "large shadow",
            "value": "lg"
          }
        ]
      },
      {
        "propertyName": "backdropVariant",
        "type": "select",
        "description": "Theme variant color for the backdrop of the sidebar. Defaults to 'dark'",
        "possibleValues": [
          "primary",
          "secondary",
          "success",
          "danger",
          "warning",
          "info",
          "light",
          "dark"
        ]
      },
      {
        "propertyName": "bgVariant",
        "type": "select",
        "description": "Theme variant color for the background of the sidebar. Defaults to 'light'",
        "possibleValues": [
          "primary",
          "secondary",
          "success",
          "danger",
          "warning",
          "info",
          "light",
          "dark"
        ]
      },
      {
        "propertyName": "textVariant",
        "type": "select",
        "description": "Theme variant color for the text of the sidebar. Defaults to 'dark'",
        "possibleValues": [
          "primary",
          "secondary",
          "success",
          "danger",
          "warning",
          "info",
          "light",
          "dark"
        ]
      },
      {
        "propertyName": "zIndex",
        "type": "number",
        "description": "Specify an arbitrary z-index value to override the value defined by SCSS/CSS"
      },
      {
        "propertyName": "width",
        "type": "text",
        "description": "CSS width for the sidebar. Defaults to '320px' as defined by SCSS/CSS"
      },
      {
        "propertyName": "title",
        "type": "text"
      },
      {
        "propertyName": "closeLabel",
        "type": "text"
      },
      {
        "propertyName": "noCloseOnRouteChange",
        "type": "text"
      }
    ],
    "TableView": [
      {
        "propertyName": "viewSource",
        "type": "select",
        "description": "A data connector component that stores the view model to be used for this table"
      },
      {
        "propertyName": "notSelectable",
        "type": "checkbox",
        "description": "When set, places the table body rows in not selectable mode"
      },
      {
        "propertyName": "selectMode",
        "type": "select",
        "description": "The selectable mode for the table (default: <code>multi</code>).",
        "possibleValues": [
          "single",
          "multi",
          "range"
        ]
      },
      {
        "propertyName": "pagination",
        "type": "checkbox",
        "description": "Shows the built-in pagination control. For custom behavior, please use a pagination control and bind it to this table data."
      },
      {
        "propertyName": "paginationSize",
        "type": "select",
        "description": "Defines the size of the built-in pagination control when showing (default is <code>md</code>).",
        "possibleValues": [
          "sm",
          "md",
          "lg"
        ]
      },
      {
        "propertyName": "paginationPosition",
        "type": "select",
        "description": "Defines the position of the built-in pagination control when showing (default is <code>top</code>).",
        "possibleValues": [
          "top",
          "bottom"
        ]
      },
      {
        "propertyName": "paginationAlignment",
        "type": "select",
        "description": "Defines the alignment of the built-in pagination control when showing (default is <code>left</code>).",
        "possibleValues": [
          "left",
          "center",
          "right"
        ]
      },
      {
        "propertyName": "fields",
        "type": "custom"
      },
      {
        "propertyName": "defaultCellRenderer",
        "type": "code/javascript",
        "description": "A function returning the HTML to be rendered in table cells, for example: <code>data => `data.value`</code>",
        "literalOnly": true
      },
      {
        "propertyName": "filter",
        "type": "code/javascript",
        "description": "Criteria for filtering. Internal filtering supports only string or RegExpr criteria (otherwise, please use a filter function)",
        "literalOnly": true
      },
      {
        "propertyName": "filterFunction",
        "type": "code/javascript",
        "description": "A filter function taking <code>record</code>, <code>filter</code> arguments, where <code>record</code> is the object in the table and <code>filter</code> is the value of the \"filter\" property - Note that the \"filter\" property must not be <code>null</code>/<code>false</code> in order for this function to be called",
        "literalOnly": true
      },
      {
        "propertyName": "filterExcludedFields",
        "type": "text",
        "description": "Array of top level fields to ignore when filtering the item data"
      },
      {
        "propertyName": "filterIncludedFields",
        "type": "text",
        "description": "Array of fields to include when filtering. Overrides filter-ignore-fields"
      },
      {
        "propertyName": "details",
        "type": "checkbox",
        "description": "Adds a column that expands the rows to show the details section"
      },
      {
        "propertyName": "perPage",
        "type": "text",
        "description": "Number of items per page"
      },
      {
        "propertyName": "stacked",
        "type": "select",
        "description": "Generate a responsive stacked table. Set to true for an always stacked table, or set it to one of the breakpoints <code>sm</code>, <code>md</code>, <code>lg</code>, or <code>xl</code> to make the table visually stacked only on screens smaller than the breakpoint.",
        "possibleValues": [
          "always",
          "sm",
          "md",
          "lg",
          "xl",
          "never"
        ]
      },
      {
        "propertyName": "striped",
        "type": "checkbox",
        "description": "Applies striping to the tbody rows"
      },
      {
        "propertyName": "small",
        "type": "checkbox",
        "description": "Renders the table with smaller cell padding"
      },
      {
        "propertyName": "hideHeader",
        "type": "checkbox",
        "description": "Do not show the table header"
      },
      {
        "propertyName": "hover",
        "type": "checkbox",
        "description": "Enables hover styling on rows"
      },
      {
        "propertyName": "outlined",
        "type": "checkbox",
        "description": "Adds an outline border to the table element"
      },
      {
        "propertyName": "bordered",
        "type": "checkbox",
        "description": "Adds borders to all the cells and headers"
      },
      {
        "propertyName": "borderless",
        "type": "checkbox",
        "description": "Removes all borders from cells"
      },
      {
        "propertyName": "dark",
        "type": "checkbox",
        "description": "Places the table in dark mode"
      },
      {
        "propertyName": "emptyText",
        "type": "code/html",
        "description": "HTML string to show when the table has no items to show"
      },
      {
        "propertyName": "emptyFilteredText",
        "type": "code/html",
        "description": "HTML string to show when the table has no items to show due to filtering"
      },
      {
        "propertyName": "fixed",
        "type": "checkbox",
        "description": "Makes all columns equal width (fixed layout table). Will speed up rendering for large tables. Column widths can be set via CSS or colgroup"
      },
      {
        "propertyName": "responsive",
        "type": "select",
        "description": "Makes the table responsive in width, adding a horizontal scrollbar. Set to true for always responsive or set to one of the breakpoints to switch from responsive to normal: <code>sm</code>, <code>md</code>, <code>lg</code>, <code>xl</code>",
        "possibleValues": [
          true,
          "sm",
          "md",
          "lg",
          "xl"
        ]
      },
      {
        "propertyName": "headRowVariant",
        "type": "select",
        "description": "Apply a Bootstrap theme color variant to the tr element in the thead",
        "possibleValues": [
          "primary",
          "secondary",
          "success",
          "warning",
          "danger",
          "info",
          "light",
          "dark"
        ]
      },
      {
        "propertyName": "tbodyTrClass",
        "type": "text",
        "description": "Classes to be applied to every row on the table. If a function is given, it will be called with <code>(item, type)</code> parameters and it may return an <code>Array</code>, <code>Object</code> or <code>String</code>."
      },
      {
        "propertyName": "tbodyTrAttr",
        "type": "text",
        "description": "Attributes to be applied to every row on the table. If a function is given, it will be called with <code>(item, type)</code> parameters and it must return an <code>Object</code>."
      },
      {
        "propertyName": "tdClass",
        "type": "text",
        "description": "Classes to be applied to every cell on the table. Can be overridden for each column individually (see the fields section). If no classes is defined, it defaults to <code>align-middle</code>."
      },
      {
        "propertyName": "field",
        "type": "text",
        "description": "The identifier of the field in the data source (only if the data source is an object)"
      }
    ],
    "ChartView": [
      {
        "propertyName": "optionsAdapter",
        "type": "code/javascript",
        "description": "Some JavaScript code for custom initialization of the chart.js options - for example: chartOptions.options.scales.x.ticks = { ... }",
        "literalOnly": true
      },
      {
        "propertyName": "hideLegend",
        "type": "checkbox",
        "description": "Hide the chart legend"
      },
      {
        "propertyName": "hideGridX",
        "type": "checkbox"
      },
      {
        "propertyName": "hideGridY",
        "type": "checkbox"
      },
      {
        "propertyName": "interactiveEdits",
        "type": "checkbox",
        "description": "The user can edit the data by dragging the dots"
      },
      {
        "propertyName": "backgroundOpacity",
        "type": "range"
      },
      {
        "propertyName": "minY",
        "type": "code/javascript"
      },
      {
        "propertyName": "suggestedMinY",
        "type": "checkbox",
        "description": "If checked, the given min value can be overridden by the actual min value in the data",
        "literalOnly": true
      },
      {
        "propertyName": "maxY",
        "type": "code/javascript"
      },
      {
        "propertyName": "suggestedMaxY",
        "type": "checkbox",
        "description": "If checked, the given max value can be overridden by the actual max value in the data",
        "literalOnly": true
      },
      {
        "propertyName": "aspectRatio",
        "type": "range"
      },
      {
        "propertyName": "invertAxes",
        "type": "checkbox"
      },
      {
        "propertyName": "fillHeight",
        "type": "checkbox",
        "description": "Stretch vertically to fill the parent component height",
        "literalOnly": true
      },
      {
        "propertyName": "chartType",
        "type": "select",
        "possibleValues": [
          "line",
          "bar",
          "radar",
          "doughnut",
          "pie",
          "polarArea",
          "bubble",
          "scatter"
        ]
      },
      {
        "propertyName": "animation",
        "type": "checkbox"
      },
      {
        "propertyName": "seriesList",
        "type": "custom"
      },
      {
        "propertyName": "labels",
        "type": "text",
        "description": "An array of string labels or a comma-separated list of string values"
      },
      {
        "propertyName": "backgroundColors",
        "type": "text",
        "description": "A color or an array of colors"
      },
      {
        "propertyName": "borderColors",
        "type": "text",
        "description": "A color or an array of colors"
      },
      {
        "propertyName": "hoverBackgroundColors",
        "type": "text",
        "description": "A color or an array of colors"
      },
      {
        "propertyName": "hoverBorderColors",
        "type": "text",
        "description": "A color or an array of colors"
      },
      {
        "propertyName": "cubicInterpolation",
        "type": "range"
      },
      {
        "propertyName": "borderRadius",
        "type": "range"
      },
      {
        "propertyName": "stacked",
        "type": "checkbox"
      },
      {
        "propertyName": "field",
        "type": "text",
        "description": "The identifier of the field in the data source (only if the data source is an object)"
      },
      {
        "propertyName": "title",
        "type": "text"
      }
    ],
    "TimeSeriesChartView": [
      {
        "propertyName": "optionsAdapter",
        "type": "code/javascript",
        "description": "Some JavaScript code for custom initialization of the chart.js options - available in the 'chartOptions' variable",
        "literalOnly": true
      },
      {
        "propertyName": "hideGridX",
        "type": "checkbox"
      },
      {
        "propertyName": "hideGridY",
        "type": "checkbox"
      },
      {
        "propertyName": "hideLegend",
        "type": "checkbox",
        "description": "Hide the chart legend"
      },
      {
        "propertyName": "backgroundOpacity",
        "type": "range"
      },
      {
        "propertyName": "aspectRatio",
        "type": "range"
      },
      {
        "propertyName": "fillHeight",
        "type": "checkbox",
        "description": "Stretch vertically to fill the parent component height",
        "literalOnly": true
      },
      {
        "propertyName": "chartType",
        "type": "select",
        "possibleValues": [
          "line",
          "bar",
          "scatter"
        ]
      },
      {
        "propertyName": "unit",
        "type": "select",
        "possibleValues": [
          "millisecond",
          "second",
          "minute",
          "hour",
          "day",
          "week",
          "month",
          "quarter",
          "year"
        ]
      },
      {
        "propertyName": "animation",
        "type": "checkbox"
      },
      {
        "propertyName": "cubicInterpolation",
        "type": "range"
      },
      {
        "propertyName": "timeSeriesList",
        "type": "custom"
      },
      {
        "propertyName": "labels",
        "type": "text",
        "description": "An array of string labels or a comma-separated list of string values"
      },
      {
        "propertyName": "backgroundColors",
        "type": "text",
        "description": "A color or an array of colors"
      },
      {
        "propertyName": "borderColors",
        "type": "text",
        "description": "A color or an array of colors"
      },
      {
        "propertyName": "stacked",
        "type": "checkbox"
      },
      {
        "propertyName": "field",
        "type": "text",
        "description": "The identifier of the field in the data source (only if the data source is an object)"
      },
      {
        "propertyName": "title",
        "type": "text"
      }
    ],
    "TagsView": [
      {
        "propertyName": "addButtonText",
        "type": "text",
        "description": "Text for the built in 'Add' button."
      },
      {
        "propertyName": "addButtonVariant",
        "type": "select",
        "description": "Applies one of the Bootstrap theme color variants to the 'Add' button",
        "possibleValues": [
          "primary",
          "secondary",
          "success",
          "danger",
          "warning",
          "info",
          "light",
          "dark",
          "outline-primary",
          "outline-secondary",
          "outline-success",
          "outline-danger",
          "outline-warning",
          "outline-info",
          "outline-light",
          "outline-dark",
          "link"
        ]
      },
      {
        "propertyName": "duplicateTagText",
        "type": "text",
        "description": "The message when duplicate tags are detected. Set to an empty string to disable the message"
      },
      {
        "propertyName": "inputClass",
        "type": "text",
        "description": "Class (or classes) to apply to the new tag input element"
      },
      {
        "propertyName": "inputType",
        "type": "select",
        "description": "Specifies the type of input to use: <code>text</code>, <code>email</code>, <code>tel</code>, <code>url</code>, or <code>number</code>. Default is <code>text</code>",
        "possibleValues": [
          "text",
          "email",
          "tel",
          "url",
          "number"
        ]
      },
      {
        "propertyName": "invalidTagText",
        "type": "text",
        "description": "The error message when invalid tags are detected. Set to an empty string to disable the message"
      },
      {
        "propertyName": "limit",
        "type": "number",
        "description": "The maximum amount of tags that can be added. The limit can still be exceeded if manipulated outside of the component"
      },
      {
        "propertyName": "limitTagsText",
        "type": "text",
        "description": "The message when the limit is reached. Set to an empty string to disable the message"
      },
      {
        "propertyName": "noAddOnEnter",
        "type": "checkbox",
        "description": "When set, disables adding the tag on the input's <code>keydown.enter</code> event"
      },
      {
        "propertyName": "noOuterFocus",
        "type": "checkbox",
        "description": "When set, disables the focus styling of the component root element"
      },
      {
        "propertyName": "noTagRemove",
        "type": "checkbox",
        "description": "When set, the tags will not have a remove button"
      },
      {
        "propertyName": "removeOnDelete",
        "type": "checkbox",
        "description": "When set, enables removal of last tag in tags when user presses delete or backspace and the input is empty"
      },
      {
        "propertyName": "separator",
        "type": "text",
        "description": "Separator character(s) that will trigger a tag to be created (use an array in a formula to support several separators)"
      },
      {
        "propertyName": "tagClass",
        "type": "text",
        "description": "Class (or classes) to apply to the tags"
      },
      {
        "propertyName": "tagPills",
        "type": "checkbox",
        "description": "Makes the built in tags have a pill appearance"
      },
      {
        "propertyName": "tagRemoveLabel",
        "type": "text",
        "description": "The value of the ARIA label attribute on the remove button in the tag"
      },
      {
        "propertyName": "tagRemovedLabel",
        "type": "text",
        "description": "Label for the <code>aria-live</code> region that announces removed tag(s) to screen reader users"
      },
      {
        "propertyName": "tagValidator",
        "type": "code/javascript",
        "description": "Optional tag validator method. Passed a single argument of tag being added. Should return <code>true</code> if the tag passes validation, or <code>false</code> if the tag cannot be added"
      },
      {
        "propertyName": "tagVariant",
        "type": "select",
        "description": "Applies one of the Bootstrap theme color variants to the tags",
        "possibleValues": [
          "primary",
          "secondary",
          "success",
          "danger",
          "warning",
          "info",
          "light",
          "dark",
          "outline-primary",
          "outline-secondary",
          "outline-success",
          "outline-danger",
          "outline-warning",
          "outline-info",
          "outline-light",
          "outline-dark",
          "link"
        ]
      },
      {
        "propertyName": "disabled",
        "type": "checkbox"
      },
      {
        "propertyName": "required",
        "type": "checkbox",
        "description": "A value evaluating to true is required for this control to have a valid state"
      },
      {
        "propertyName": "placeholder",
        "type": "text"
      },
      {
        "propertyName": "horizontalLayout",
        "type": "checkbox"
      },
      {
        "propertyName": "labelCols",
        "type": "range",
        "description": "Number of columns for the label when horizontal layout"
      },
      {
        "propertyName": "labelClass",
        "type": "text",
        "description": "Class(es) (space-separated) applying to the label"
      },
      {
        "propertyName": "size",
        "type": "select",
        "possibleValues": [
          "default",
          "sm",
          "md",
          "lg"
        ]
      },
      {
        "propertyName": "state",
        "type": "text"
      },
      {
        "propertyName": "field",
        "type": "text",
        "description": "The identifier of the field in the data source (only if the data source is an object)"
      },
      {
        "propertyName": "label",
        "type": "text"
      },
      {
        "propertyName": "description",
        "type": "text"
      },
      {
        "propertyName": "invalidFeedback",
        "type": "text"
      },
      {
        "propertyName": "validFeedback",
        "type": "text"
      }
    ],
    "PopoverView": [
      {
        "propertyName": "variant",
        "type": "select",
        "possibleValues": [
          "primary",
          "secondary",
          "success",
          "danger",
          "warning",
          "info",
          "light",
          "dark"
        ]
      },
      {
        "propertyName": "content",
        "type": "ref"
      },
      {
        "propertyName": "manualTrigger",
        "type": "checkbox",
        "description": "When set, the popover must be shown/hidden using the 'show' and 'hide' functions"
      },
      {
        "propertyName": "title",
        "type": "text"
      },
      {
        "propertyName": "target",
        "type": "select"
      },
      {
        "propertyName": "placement",
        "type": "select",
        "description": "Default is 'right'",
        "possibleValues": [
          "top",
          "bottom",
          "right",
          "left",
          "topleft",
          "topright",
          "bottomleft",
          "bottomright",
          "lefttop",
          "leftbottom",
          "righttop",
          "rightbottom"
        ]
      },
      {
        "propertyName": "triggers",
        "type": "select",
        "description": "Configures the event on the target that will trigger the popover. Default is 'click'. You can disable auto-trigger and use regular 'show'/'hide' functions.",
        "possibleValues": [
          "click",
          "hover",
          "focus"
        ]
      }
    ],
    "DatepickerView": [
      {
        "propertyName": "showDecadeNav",
        "type": "checkbox"
      },
      {
        "propertyName": "horizontalLayout",
        "type": "checkbox"
      },
      {
        "propertyName": "noDropdown",
        "type": "checkbox",
        "description": "Embeds a calendar control directly, without the dropdown picker",
        "literalOnly": true
      },
      {
        "propertyName": "block",
        "type": "checkbox",
        "description": "If set, stretches the calendar to take the entire available width in the parent"
      },
      {
        "propertyName": "dateFormatOptions",
        "type": "code/json",
        "description": "Format object for displayed text string that is passed to <code>Intl.DateTimeFormat</code>. Default is <code>{ 'year': 'numeric', 'month': 'long', 'day': 'numeric', 'weekday': 'long' }</code>",
        "literalOnly": true
      },
      {
        "propertyName": "initialDate",
        "type": "code/javascript",
        "description": "When the data model is not defined, sets the initial calendar month date that will be presented to the user. Accepts a value in <code>YYYY-MM-DD</code> format or a <code>Date</code> object. Defaults to the current date (or min or max if the current date is out of range)",
        "literalOnly": true
      },
      {
        "propertyName": "cellFormatter",
        "type": "code/javascript",
        "description": "A function that takes the date and returns HTML code to be placed in the corresponding calendar cell, for example: <code>date => `${moment(date).format('DD')}`</code>",
        "literalOnly": true
      },
      {
        "propertyName": "labelCols",
        "type": "range",
        "description": "Number of columns for the label when horizontal layout (<code>0</code> or <code>undefined</code> is auto)"
      },
      {
        "propertyName": "labelClass",
        "type": "text",
        "description": "Class(es) (space-separated) applying to the label"
      },
      {
        "propertyName": "min",
        "type": "date"
      },
      {
        "propertyName": "max",
        "type": "date"
      },
      {
        "propertyName": "required",
        "type": "checkbox",
        "description": "When placed in a form container, the value must be defined when submitting the form"
      },
      {
        "propertyName": "disabled",
        "type": "checkbox"
      },
      {
        "propertyName": "size",
        "type": "select",
        "possibleValues": [
          "default",
          "sm",
          "md",
          "lg"
        ]
      },
      {
        "propertyName": "state",
        "type": "text"
      },
      {
        "propertyName": "resetButton",
        "type": "checkbox",
        "description": "When set, shows the optional 'reset' button"
      },
      {
        "propertyName": "resetButtonVariant",
        "type": "select",
        "possibleValues": [
          "primary",
          "secondary",
          "success",
          "danger",
          "warning",
          "info",
          "light",
          "dark",
          "outline-primary",
          "outline-secondary",
          "outline-success",
          "outline-danger",
          "outline-warning",
          "outline-info",
          "outline-light",
          "outline-dark"
        ]
      },
      {
        "propertyName": "resetValue",
        "type": "text",
        "description": "When the optional <code>reset</code> button is clicked, the selected date will be set to this value. Default is to clear the selected value"
      },
      {
        "propertyName": "todayButton",
        "type": "checkbox",
        "description": "When set, shows the optional 'select today' button"
      },
      {
        "propertyName": "todayButtonVariant",
        "type": "select",
        "possibleValues": [
          "primary",
          "secondary",
          "success",
          "danger",
          "warning",
          "info",
          "light",
          "dark",
          "outline-primary",
          "outline-secondary",
          "outline-success",
          "outline-danger",
          "outline-warning",
          "outline-info",
          "outline-light",
          "outline-dark"
        ]
      },
      {
        "propertyName": "field",
        "type": "text",
        "description": "The identifier of the field in the data source (only if the data source is an object)"
      },
      {
        "propertyName": "label",
        "type": "text"
      },
      {
        "propertyName": "description",
        "type": "text"
      },
      {
        "propertyName": "invalidFeedback",
        "type": "text"
      },
      {
        "propertyName": "validFeedback",
        "type": "text"
      }
    ],
    "TimepickerView": [
      {
        "propertyName": "noDropdown",
        "type": "checkbox",
        "description": "Embeds a calendar control directly, without the dropdown picker",
        "literalOnly": true
      },
      {
        "propertyName": "horizontalLayout",
        "type": "checkbox"
      },
      {
        "propertyName": "labelCols",
        "type": "range",
        "description": "Number of columns for the label when horizontal layout (0 or undefined is auto)"
      },
      {
        "propertyName": "labelClass",
        "type": "text",
        "description": "Class(es) (space-separated) applying to the label"
      },
      {
        "propertyName": "disabled",
        "type": "checkbox"
      },
      {
        "propertyName": "min",
        "type": "time"
      },
      {
        "propertyName": "max",
        "type": "time"
      },
      {
        "propertyName": "required",
        "type": "checkbox",
        "description": "When placed in a form container, the value must be defined when submitting the form"
      },
      {
        "propertyName": "size",
        "type": "select",
        "possibleValues": [
          "default",
          "sm",
          "md",
          "lg"
        ]
      },
      {
        "propertyName": "state",
        "type": "text"
      },
      {
        "propertyName": "resetButton",
        "type": "checkbox",
        "description": "When set, shows the optional 'reset' button"
      },
      {
        "propertyName": "resetButtonVariant",
        "type": "select",
        "possibleValues": [
          "primary",
          "secondary",
          "success",
          "danger",
          "warning",
          "info",
          "light",
          "dark",
          "outline-primary",
          "outline-secondary",
          "outline-success",
          "outline-danger",
          "outline-warning",
          "outline-info",
          "outline-light",
          "outline-dark"
        ]
      },
      {
        "propertyName": "resetValue",
        "type": "text",
        "description": "When the optional 'reset' button is clicked, the selected date will be set to this value. Default is to clear the selected value"
      },
      {
        "propertyName": "nowButton",
        "type": "checkbox",
        "description": "When set, shows the optional 'select now' button"
      },
      {
        "propertyName": "nowButtonVariant",
        "type": "select",
        "possibleValues": [
          "primary",
          "secondary",
          "success",
          "danger",
          "warning",
          "info",
          "light",
          "dark",
          "outline-primary",
          "outline-secondary",
          "outline-success",
          "outline-danger",
          "outline-warning",
          "outline-info",
          "outline-light",
          "outline-dark"
        ]
      },
      {
        "propertyName": "field",
        "type": "text",
        "description": "The identifier of the field in the data source (only if the data source is an object)"
      },
      {
        "propertyName": "label",
        "type": "text"
      },
      {
        "propertyName": "description",
        "type": "text"
      },
      {
        "propertyName": "invalidFeedback",
        "type": "text"
      },
      {
        "propertyName": "validFeedback",
        "type": "text"
      }
    ],
    "PaginationView": [
      {
        "propertyName": "perPage",
        "type": "number",
        "description": "Number of rows per page"
      },
      {
        "propertyName": "initialPage",
        "type": "number",
        "description": "The initial page when this component is shown the first time (starting at 1)"
      },
      {
        "propertyName": "align",
        "type": "select",
        "possibleValues": [
          "left",
          "center",
          "right",
          "fill"
        ]
      },
      {
        "propertyName": "size",
        "type": "select",
        "possibleValues": [
          "default",
          "md",
          "sm",
          "lg"
        ]
      },
      {
        "propertyName": "pills",
        "type": "checkbox"
      },
      {
        "propertyName": "hideGoToEndButtons",
        "type": "checkbox",
        "description": "Hides the goto first and goto last page buttons"
      },
      {
        "propertyName": "hideEllipsis",
        "type": "checkbox",
        "description": "Hides the goto first and goto last page buttons"
      },
      {
        "propertyName": "firstText",
        "type": "text",
        "description": "Content to place in the goto first page button. Default value is '«'"
      },
      {
        "propertyName": "prevText",
        "type": "text",
        "description": "Content to place in the goto previous page button. Default value is '‹'"
      },
      {
        "propertyName": "nextText",
        "type": "text",
        "description": "Content to place in the goto next page button. Default value is '›'"
      },
      {
        "propertyName": "lastText",
        "type": "text",
        "description": "Content to place in the goto last page button. Default value is '»'"
      },
      {
        "propertyName": "ellipsisText",
        "type": "text",
        "description": "Content to place in the ellipsis placeholder. Default value is '…'"
      },
      {
        "propertyName": "disabled",
        "type": "checkbox"
      },
      {
        "propertyName": "limit",
        "type": "text"
      }
    ],
    "AvatarView": [
      {
        "propertyName": "alt",
        "type": "text",
        "description": "Value to place in the <code>alt</code> attribute for image and icon avatars"
      },
      {
        "propertyName": "badge",
        "type": "text",
        "description": "Set to a string for content in the badge (empty string shows an empty badge)"
      },
      {
        "propertyName": "badgeLeft",
        "type": "checkbox",
        "description": "When checked places the badge at the left instead of the right"
      },
      {
        "propertyName": "badgeOffset",
        "type": "text",
        "description": "CSS length to offset the badge. Positive values move the badge inwards, while negative values move the badge outwards"
      },
      {
        "propertyName": "badgeTop",
        "type": "checkbox",
        "description": "When checked places the badge at the top instead of the bottom"
      },
      {
        "propertyName": "badgeVariant",
        "type": "select",
        "description": "Applies one of the Bootstrap theme color variants to the badge",
        "possibleValues": [
          "primary",
          "secondary",
          "success",
          "danger",
          "warning",
          "info",
          "light",
          "dark"
        ]
      },
      {
        "propertyName": "button",
        "type": "checkbox",
        "description": "When set to <code>true</code>, renders the avatar as a button"
      },
      {
        "propertyName": "buttonType",
        "type": "select",
        "description": "Type of button to render (i.e. <code>button</code>, <code>submit</code>, <code>reset</code>). Has no effect if prop button is not set",
        "possibleValues": [
          "button",
          "submit",
          "reset"
        ],
        "literalOnly": true
      },
      {
        "propertyName": "icon",
        "type": "icon",
        "description": "Icon name to use for the avatar. Must be all lowercase. Defaults to <code>person-fill</code> if <code>text</code> or <code>src</code> props not provided"
      },
      {
        "propertyName": "rounded",
        "type": "checkbox",
        "description": "Specifies the type of rounding to apply to the avatar. The <code>square</code> prop takes precedence"
      },
      {
        "propertyName": "size",
        "type": "text",
        "description": "CSS size of the avatar"
      },
      {
        "propertyName": "square",
        "type": "checkbox",
        "description": "Disables rounding of the avatar, rending the avatar with square corners"
      },
      {
        "propertyName": "src",
        "type": "text",
        "description": "Image URL to use for the avatar"
      },
      {
        "propertyName": "text",
        "type": "text",
        "description": "Text to place in the avatar"
      },
      {
        "propertyName": "variant",
        "type": "select",
        "description": "Applies one of the Bootstrap theme color variants to the component",
        "possibleValues": [
          "primary",
          "secondary",
          "success",
          "danger",
          "warning",
          "info",
          "light",
          "dark"
        ]
      },
      {
        "propertyName": "field",
        "type": "text",
        "description": "The identifier of the field in the data source (only if the data source is an object)"
      }
    ],
    "EmbedView": [
      {
        "propertyName": "src",
        "type": "text",
        "description": "A URL or formula evaluating to a URL that will override the data model (if not defined, the data model is expected to contain an URL)"
      },
      {
        "propertyName": "embedType",
        "type": "select",
        "possibleValues": [
          "iframe",
          "audio",
          "video",
          "embed",
          "object"
        ]
      },
      {
        "propertyName": "aspect",
        "type": "select",
        "description": "The aspect ratio of the responsive embed",
        "possibleValues": [
          "21by9",
          "16by9",
          "4by3",
          "1by1",
          "3by4",
          "9by16",
          "9by21"
        ]
      },
      {
        "propertyName": "controls",
        "type": "checkbox",
        "description": "Controls should be displayed (such as a play/pause button, etc)"
      },
      {
        "propertyName": "autoplay",
        "type": "checkbox",
        "description": "Content will start playing as soon as it is ready"
      },
      {
        "propertyName": "loop",
        "type": "checkbox",
        "description": "Content will start over again, every time it is finished"
      },
      {
        "propertyName": "muted",
        "type": "checkbox",
        "description": "The audio output of the video should be muted"
      },
      {
        "propertyName": "poster",
        "type": "text",
        "description": "An image to be shown while the video is downloading, or until the user hits the play button"
      },
      {
        "propertyName": "preload",
        "type": "select",
        "description": "Specify if and how the content should be loaded when the page loads (warning: to be avoided for eco-design)",
        "possibleValues": [
          "auto",
          "metadata",
          "none"
        ]
      },
      {
        "propertyName": "tag",
        "type": "text",
        "description": "Sets the outer element tag which the responsive embed is wrapped in (default is <code>div</code>) to enforce the responsive aspect ratio."
      },
      {
        "propertyName": "field",
        "type": "text",
        "description": "The identifier of the field in the data source (only if the data source is an object)"
      }
    ],
    "MapView": [
      {
        "propertyName": "popupComponent",
        "type": "ref",
        "description": "A component to be shown in the popup when cliking on the markers. Only if popups are enabled for markers."
      },
      {
        "propertyName": "url",
        "type": "text",
        "description": "Map titles server URL, default is \"https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png\" (see the leaflet doc to change URL)"
      },
      {
        "propertyName": "dataSource",
        "type": "select",
        "description": "A list of marker definitions (to be shown on the map). Definitions include the following fields: \n                    <code>latlng</code> (mandatory), <code>disablePopup</code>, <code>popupHtml</code>, <code>iconUrl</code>, <code>iconSize</code>, <code>iconAnchor</code>, <code>html</code>.",
        "possibleValues": [
          "",
          "$parent",
          "datepicker-birthdate",
          "dialog-create-edit-contact",
          "globals",
          "index",
          "input-firstname",
          "input-lastname",
          "input-search",
          "select-company",
          "select-kind",
          "storage-companies",
          "storage-contacts",
          "table-contacts"
        ]
      },
      {
        "propertyName": "disabled",
        "type": "checkbox"
      },
      {
        "propertyName": "zoomControlPosition",
        "type": "select",
        "possibleValues": [
          "topright",
          "topleft",
          "bottomright",
          "bottomleft"
        ]
      },
      {
        "propertyName": "disableZoomControl",
        "type": "checkbox"
      },
      {
        "propertyName": "locked",
        "type": "checkbox",
        "description": "Disable all user interactions with the map (zoom, move, keyboard, ...)"
      },
      {
        "propertyName": "zoom",
        "type": "number",
        "description": "Zoom level"
      },
      {
        "propertyName": "minZoom",
        "type": "number",
        "description": "Min zoom level"
      },
      {
        "propertyName": "maxZoom",
        "type": "number",
        "description": "Max zoom level"
      },
      {
        "propertyName": "center",
        "type": "code/javascript",
        "description": "A coordinates object (e.g. <code>[lat, lng]</code> or <code>{lat: x, lng: y}</code>)",
        "literalOnly": true
      }
    ],
    "CarouselView": [
      {
        "propertyName": "slidesStyle",
        "type": "text",
        "description": "A CSS style to be applied to slides"
      },
      {
        "propertyName": "slidesClass",
        "type": "text",
        "description": "A CSS class to be applied to slides"
      },
      {
        "propertyName": "imgWidth",
        "type": "number",
        "description": "Enforce size ratio for blank slides"
      },
      {
        "propertyName": "imgHeight",
        "type": "number",
        "description": "Enforce size ratio for blank slides"
      },
      {
        "propertyName": "background",
        "type": "text",
        "description": "Set the CSS color of the carousel's background"
      },
      {
        "propertyName": "videoStyle",
        "type": "checkbox",
        "description": "Make the slide show look like a video to be played - paused by clicking on the slide show"
      },
      {
        "propertyName": "controls",
        "type": "checkbox",
        "description": "Enable the previous and next controls"
      },
      {
        "propertyName": "fade",
        "type": "checkbox",
        "description": "When set, changes the slide animation to a crossfade instead of a sliding effect"
      },
      {
        "propertyName": "indicators",
        "type": "checkbox",
        "description": "Enable the indicator buttons for jumping to specific slides"
      },
      {
        "propertyName": "interval",
        "type": "number",
        "description": "Set the delay time (in milliseconds) between slides, 0 means paused auto sliding"
      },
      {
        "propertyName": "initiallyPaused",
        "type": "checkbox",
        "description": "Slide show is intially paused and needs to be started manually"
      },
      {
        "propertyName": "stopOnEdit",
        "type": "checkbox",
        "description": "Stop the slide animations while in edit mode"
      },
      {
        "propertyName": "noAnimation",
        "type": "checkbox",
        "description": "When set, disables animation when transitioning between slides"
      },
      {
        "propertyName": "noHoverPause",
        "type": "checkbox",
        "description": "When set, disables the pausing of the slide show when the current slide is hovered"
      },
      {
        "propertyName": "noWrap",
        "type": "checkbox",
        "description": "Do not restart the slide show when then end is reached"
      },
      {
        "propertyName": "noTouch",
        "type": "checkbox",
        "description": "Disable controlling the slides via touch swipes"
      },
      {
        "propertyName": "useDataModel",
        "type": "checkbox",
        "description": "When set, overrides the slides configuration with the data model (must be a list of slide descriptors or strings containing the URL of the images). Valid properties for slide descriptors are: <code>imgSrc</code> (image URL), <code>captionHtml</code>, <code>textHtml</code>, <code>background</code>, <code>imgBlank</code>, <code>imgBlankColor</code>. If the data is a list of strings, these strings are used as <code>imgSrc</code> properties."
      },
      {
        "propertyName": "slides",
        "type": "custom"
      },
      {
        "propertyName": "labelGotoSlide",
        "type": "text",
        "description": "Sets the prefix for the ARIA label on the slide indicator controls. Will be suffixed with the slide number (1 indexed)"
      },
      {
        "propertyName": "labelIndicators",
        "type": "text",
        "description": "Sets the ARIA label on the indicator controls wrapper"
      },
      {
        "propertyName": "labelNext",
        "type": "text",
        "description": "Sets the ARIA label value for the next slide control"
      },
      {
        "propertyName": "labelPrev",
        "type": "text",
        "description": "Sets the ARIA label value for the previous slide control"
      }
    ],
    "ProgressView": [
      {
        "propertyName": "variant",
        "type": "select",
        "description": "Applies one of the Bootstrap theme color variants to the component",
        "possibleValues": [
          "primary",
          "secondary",
          "success",
          "danger",
          "warning",
          "info",
          "light",
          "dark"
        ]
      },
      {
        "propertyName": "max",
        "type": "number",
        "description": "Set the maximum value"
      },
      {
        "propertyName": "precision",
        "type": "number",
        "description": "The number of digits after the decimal to round the value to"
      },
      {
        "propertyName": "height",
        "type": "text",
        "description": "Override the default height by specifying a CSS height value (including units)"
      },
      {
        "propertyName": "animated",
        "type": "checkbox",
        "description": "Enable the animated background. Also automatically set 'striped'"
      },
      {
        "propertyName": "striped",
        "type": "checkbox",
        "description": "Enable the striped background"
      },
      {
        "propertyName": "displayText",
        "type": "select",
        "description": "Tune the text to be displayed on the progress bar",
        "possibleValues": [
          {
            "value": "no-text",
            "text": "no text"
          },
          {
            "value": "display-progress",
            "text": "display progress (as a percentage)"
          },
          {
            "value": "display-value",
            "text": "show value"
          }
        ]
      },
      {
        "propertyName": "disabled",
        "type": "checkbox"
      },
      {
        "propertyName": "horizontalLayout",
        "type": "checkbox"
      },
      {
        "propertyName": "labelCols",
        "type": "range",
        "description": "Number of columns for the label when horizontal layout (<code>0</code> or <code>undefined</code> is auto)"
      },
      {
        "propertyName": "labelClass",
        "type": "text",
        "description": "Class(es) (space-separated) applying to the label"
      },
      {
        "propertyName": "state",
        "type": "text"
      },
      {
        "propertyName": "field",
        "type": "text",
        "description": "The identifier of the field in the data source (only if the data source is an object)"
      },
      {
        "propertyName": "label",
        "type": "text"
      },
      {
        "propertyName": "description",
        "type": "text"
      },
      {
        "propertyName": "invalidFeedback",
        "type": "text"
      },
      {
        "propertyName": "validFeedback",
        "type": "text"
      }
    ],
    "NavbarView": [
      {
        "propertyName": "navigationTransitionFadeInDuration",
        "type": "text",
        "description": "When set, a fade-in transition animation will show at the indicated duration (for instance, <code>1s</code> or <code>100ms</code>)",
        "literalOnly": true
      },
      {
        "propertyName": "defaultToaster",
        "type": "select",
        "description": "The default toaster to be used when calling <code>$tools.toast(...)</code> without specifying a toaster",
        "possibleValues": [
          "b-toaster-top-right",
          "b-toaster-top-left",
          "b-toaster-top-center",
          "b-toaster-top-full",
          "b-toaster-bottom-right",
          "b-toaster-bottom-left",
          "b-toaster-bottom-center",
          "b-toaster-bottom-full"
        ]
      },
      {
        "propertyName": "fixed",
        "type": "select",
        "description": "Set to <code>top</code> for fixed to the top of the viewport, or <code>bottom</code> for fixed to the bottom of the viewport",
        "possibleValues": [
          "top",
          "bottom"
        ]
      },
      {
        "propertyName": "toggleable",
        "type": "select",
        "description": "Tell when to collapse the menu items in a toggleable burger menu (default is <code>md</code>)",
        "possibleValues": [
          {
            "value": "true",
            "text": "always"
          },
          {
            "value": "false",
            "text": "never"
          },
          {
            "value": "sm",
            "text": "small screens (sm)"
          },
          {
            "value": "md",
            "text": "medium screens (md)"
          },
          {
            "value": "lg",
            "text": "large screens (lg)"
          },
          {
            "value": "xl",
            "text": "extra-large screens (xl)"
          }
        ]
      },
      {
        "propertyName": "showLocaleSelector",
        "type": "checkbox",
        "description": "Show the default locale selector, which uses the i18n entries to determine the supported locales"
      },
      {
        "propertyName": "customCss",
        "type": "code/css",
        "description": "Global custom CSS rules to be applied at the document level.",
        "literalOnly": true
      },
      {
        "propertyName": "i18n",
        "type": "code/javascript",
        "description": "Internationalization resources as an object containing a key-value resource object for each supported locale. All supported locales will be shown in the locale selector. For instance: <code>{ 'en-GB': { key1: 'en-value1', key2: 'en-value2' }, 'fr-FR': { key1: 'fr-value1', ... } }</code>",
        "literalOnly": true
      },
      {
        "propertyName": "stretch",
        "type": "checkbox",
        "description": "Strech the menu items to fill the available space in this nav bar"
      },
      {
        "propertyName": "sticky",
        "type": "checkbox",
        "description": "Set to true to make the navbar stick to the top of the viewport (or parent container that has 'position: relative' set) when scrolled"
      },
      {
        "propertyName": "vertical",
        "type": "checkbox",
        "description": "Applies a vertical layout"
      },
      {
        "propertyName": "end",
        "type": "checkbox",
        "description": "Sets the main navbar to the end of the root container (bottom or right if vertical layout is selected)"
      },
      {
        "propertyName": "itemsLayout",
        "type": "select",
        "description": "How top-level items are shown to the user",
        "possibleValues": [
          "normal",
          "text-only",
          "icon-only",
          "icon-with-label"
        ]
      },
      {
        "propertyName": "variant",
        "type": "select",
        "description": "When unset, defaults to <code>dark</code>; use <code>custom</code> to allow for custom CSS",
        "possibleValues": [
          "primary",
          "success",
          "info",
          "warning",
          "danger",
          "dark",
          "light",
          "custom"
        ]
      },
      {
        "propertyName": "bgType",
        "type": "select",
        "description": "Control the text color by setting to <code>light</code> for use with light background color variants, or <code>dark</code> for dark background color variants; use <code>custom</code> to allow custom CSS",
        "possibleValues": [
          "dark",
          "light",
          "custom"
        ]
      },
      {
        "propertyName": "showUser",
        "type": "checkbox",
        "description": "Show the logged user avatar in the navbar (note that the default profile dialog can be overridden by setting a custom action in the <code>onShowUserProfile</code> property)"
      },
      {
        "propertyName": "showEdit",
        "type": "checkbox",
        "description": "Show the button to switch edit mode on"
      },
      {
        "propertyName": "hideUserProfile",
        "type": "checkbox",
        "description": "Hide the action in the user's menu to show/edit the user's profile"
      },
      {
        "propertyName": "onShowUserProfile",
        "type": "code/javascript",
        "description": "An action to be evaluated when the user asks for opening the user profile",
        "literalOnly": true
      },
      {
        "propertyName": "enableCustomAuthentication",
        "type": "checkbox",
        "description": "Use a custom authentication for this app rather than the builtin one",
        "literalOnly": true
      },
      {
        "propertyName": "signIn",
        "type": "code/javascript",
        "description": "The code that will be executed to login (on success should call <code>setUserProfile(userProfile)</code> on this navbar).",
        "literalOnly": true
      },
      {
        "propertyName": "signOut",
        "type": "code/javascript",
        "description": "The code that will be executed to logout (on success should call <code>setUserProfile(undefined)</code> in this navbar).",
        "literalOnly": true
      },
      {
        "propertyName": "avatarUrl",
        "type": "code/javascript",
        "description": "The user avatar URL (if not defined, falls back to the built-in profile image URL)",
        "literalOnly": true
      },
      {
        "propertyName": "showImpersonate",
        "type": "checkbox",
        "description": "Show the impersonate action in the user menu (for administration purpose only)"
      },
      {
        "propertyName": "hideUserEmail",
        "type": "checkbox",
        "description": "Always hide the user email in the navbar (next to the avatar)"
      },
      {
        "propertyName": "loginPage",
        "type": "checkbox",
        "description": "When checked and user is not signed in, automatically redirects to the page with the <code>login</code> id and hides this navbar"
      },
      {
        "propertyName": "showResourceMonitoring",
        "type": "checkbox",
        "description": "Show a button to open the resource monitoring popup"
      },
      {
        "propertyName": "showCustomComponent",
        "type": "checkbox",
        "description": "Show a custom user-editable component in the navbar"
      },
      {
        "propertyName": "showSync",
        "type": "checkbox",
        "description": "Show the sync button in the navbar (only when logged in)"
      },
      {
        "propertyName": "syncOnRouteChange",
        "type": "checkbox",
        "description": "Synchronize all data when the current route/page changes"
      },
      {
        "propertyName": "infiniteScroll",
        "type": "checkbox",
        "description": "When checked, the application content will switch to 'infinite scroll mode'",
        "literalOnly": true
      },
      {
        "propertyName": "defaultPage",
        "type": "select",
        "description": "Select the page id to fallback to when the given route is undefined or not found (if not set, the default page is <code>index</code>)"
      },
      {
        "propertyName": "navigationItemsMapper",
        "type": "code/javascript",
        "description": "A function to filter or generate menu items dynamically, for example: <code>items => $tools.arrayConcat(items, { label: \"My page\", kind: \"Page\", pageId: \"myPage\" })</code>"
      },
      {
        "propertyName": "navigationItems",
        "type": "custom"
      },
      {
        "propertyName": "defaultValue",
        "type": "textarea",
        "description": "Application global initialization can be defined here and will be accessible with the <code>config</code> variable"
      },
      {
        "propertyName": "brandImageClass",
        "type": "text",
        "description": "Class(es) for the brand image."
      },
      {
        "propertyName": "brandImageStyle",
        "type": "text",
        "description": "Style for the brand image. Default is <code>height: 1.5rem;</code>."
      },
      {
        "propertyName": "brand",
        "type": "text"
      },
      {
        "propertyName": "brandImageUrl",
        "type": "text"
      }
    ],
    "PdfView": [
      {
        "propertyName": "disabled",
        "type": "checkbox"
      },
      {
        "propertyName": "zoom",
        "type": "text",
        "description": "<code>scale, [left, top]</code>. Sets the zoom and scroll factors, using float or integer values. For example, a scale value of 100 indicates a zoom value of 100%. Scroll values left and top are in a coordinate system where 0,0 represents the top left corner of the visible page, regardless of the document rotation"
      },
      {
        "propertyName": "view",
        "type": "select",
        "description": "Sets the view of the displayed page",
        "possibleValues": [
          "Fit",
          "FitH",
          "FitV",
          "FitB",
          "FitBH",
          "FitBV"
        ]
      },
      {
        "propertyName": "viewrect",
        "type": "text",
        "description": "<code>left, top, width, height</code>. Sets the view rectangle, using float or integer values in a coordinate system where 0,0 represents the top left corner of the visible page, regardless of the document rotation"
      },
      {
        "propertyName": "scrollbar",
        "type": "checkbox",
        "description": "Turns scrollbars on or off"
      },
      {
        "propertyName": "toolbar",
        "type": "checkbox",
        "description": "Turns the toolbar on or off"
      },
      {
        "propertyName": "statusbar",
        "type": "checkbox",
        "description": "Turns the status bar on or off"
      },
      {
        "propertyName": "messages",
        "type": "checkbox",
        "description": "Turns the document message bar on or off"
      },
      {
        "propertyName": "navpanes",
        "type": "checkbox",
        "description": "Turns the navigation panes and tabs on or off"
      },
      {
        "propertyName": "search",
        "type": "text",
        "description": "Search for the given words (space-separated) in the document"
      },
      {
        "propertyName": "field",
        "type": "text",
        "description": "The identifier of the field in the data source (only if the data source is an object)"
      },
      {
        "propertyName": "documentPath",
        "type": "text"
      },
      {
        "propertyName": "page",
        "type": "text"
      }
    ],
    "CameraView": [
      {
        "propertyName": "dialogSize",
        "type": "select",
        "description": "The size of the dialog showing the camera video",
        "possibleValues": [
          "sm",
          "md",
          "lg",
          "xl"
        ]
      },
      {
        "propertyName": "facingMode",
        "type": "select",
        "description": "To select back camera initially, select \"environment\"",
        "possibleValues": [
          "user",
          "environment"
        ]
      },
      {
        "propertyName": "imageWidth",
        "type": "number",
        "description": "The image width in pixels"
      }
    ],
    "SidebarView": [
      {
        "propertyName": "content",
        "type": "ref"
      },
      {
        "propertyName": "sidebarClass",
        "type": "text"
      },
      {
        "propertyName": "bodyClass",
        "type": "text"
      },
      {
        "propertyName": "headerClass",
        "type": "text"
      },
      {
        "propertyName": "footerClass",
        "type": "text"
      },
      {
        "propertyName": "footerTag",
        "type": "text",
        "description": "Specify the HTML tag to render instead of the default tag for the footer ('footer')"
      },
      {
        "propertyName": "headerTag",
        "type": "text",
        "description": "Specify the HTML tag to render instead of the default tag for the header ('header')"
      },
      {
        "propertyName": "tag",
        "type": "text",
        "description": "Specify the HTML tag to render instead of the default tag ('div')"
      },
      {
        "propertyName": "noNavbarOverlap",
        "type": "checkbox",
        "description": "Do not overlap the navbar when opened"
      },
      {
        "propertyName": "noCloseOnBackdrop",
        "type": "checkbox",
        "description": "When checked, disables closing the sidebar when the user clicks on the backdrop. Requires \"backdrop\" be checked"
      },
      {
        "propertyName": "noCloseOnEsc",
        "type": "checkbox",
        "description": "When checked, disables closing the sidebar when the user presses ESC"
      },
      {
        "propertyName": "customHeader",
        "type": "checkbox",
        "description": "Shows a custom/editable header instead of the default one"
      },
      {
        "propertyName": "customFooter",
        "type": "checkbox",
        "description": "Shows a custom/editable footer"
      },
      {
        "propertyName": "noCloseRouteChange",
        "type": "checkbox",
        "description": "When checked, disables closing of the sidebar on route change"
      },
      {
        "propertyName": "noEnforceFocus",
        "type": "checkbox",
        "description": "Disables the enforce focus routine which maintains focus inside the sidebar"
      },
      {
        "propertyName": "noHeader",
        "type": "checkbox",
        "description": "When checked, disables rendering of the default header (including close button)"
      },
      {
        "propertyName": "noHeaderClose",
        "type": "checkbox",
        "description": "When checked, disables rendering of the header close button"
      },
      {
        "propertyName": "noSlide",
        "type": "checkbox",
        "description": "When checked, disables the default sliding animation"
      },
      {
        "propertyName": "right",
        "type": "checkbox",
        "description": "When checked, positions the sidebar on the right of the viewport"
      },
      {
        "propertyName": "lazy",
        "type": "checkbox",
        "description": "When checked, the content of the sidebar will only be rendered while the sidebar is open"
      },
      {
        "propertyName": "backdrop",
        "type": "checkbox",
        "description": "When checked, shows a backdrop when the sidebar is open"
      },
      {
        "propertyName": "closeIcon",
        "type": "icon",
        "description": "The close button icon to be used in the header if not custom."
      },
      {
        "propertyName": "shadow",
        "type": "select",
        "description": "Configures the sidebar shadow. Default is no shadow",
        "possibleValues": [
          {
            "text": "no shadow",
            "value": false
          },
          {
            "text": "small shadow",
            "value": "sm"
          },
          {
            "text": "shadow",
            "value": true
          },
          {
            "text": "large shadow",
            "value": "lg"
          }
        ]
      },
      {
        "propertyName": "backdropVariant",
        "type": "select",
        "description": "Theme variant color for the backdrop of the sidebar. Defaults to 'dark'",
        "possibleValues": [
          "primary",
          "secondary",
          "success",
          "danger",
          "warning",
          "info",
          "light",
          "dark"
        ]
      },
      {
        "propertyName": "bgVariant",
        "type": "select",
        "description": "Theme variant color for the background of the sidebar. Defaults to 'light'",
        "possibleValues": [
          "primary",
          "secondary",
          "success",
          "danger",
          "warning",
          "info",
          "light",
          "dark"
        ]
      },
      {
        "propertyName": "textVariant",
        "type": "select",
        "description": "Theme variant color for the text of the sidebar. Defaults to 'dark'",
        "possibleValues": [
          "primary",
          "secondary",
          "success",
          "danger",
          "warning",
          "info",
          "light",
          "dark"
        ]
      },
      {
        "propertyName": "zIndex",
        "type": "number",
        "description": "Specify an arbitrary z-index value to override the value defined by SCSS/CSS"
      },
      {
        "propertyName": "width",
        "type": "text",
        "description": "CSS width for the sidebar. Defaults to '320px' as defined by SCSS/CSS"
      },
      {
        "propertyName": "title",
        "type": "text"
      },
      {
        "propertyName": "closeLabel",
        "type": "text"
      },
      {
        "propertyName": "noCloseOnRouteChange",
        "type": "text"
      }
    ]
  },
  "common-properties": [
    {
      "propertyName": "publicName",
      "type": "text",
      "description": "Generate an anchor for visible components (to be used as navigation points in links or in menus)"
    },
    {
      "propertyName": "init",
      "type": "code/javascript",
      "description": "Some JavaScript code to initialize the <code>this</code> component (for advanced users)",
      "literalOnly": true
    },
    {
      "propertyName": "eventHandlers",
      "type": "custom"
    },
    {
      "propertyName": "dataSource",
      "type": "select",
      "possibleValues": [
        "",
        "$parent",
        "datepicker-birthdate",
        "dialog-create-edit-contact",
        "globals",
        "index",
        "input-firstname",
        "input-lastname",
        "input-search",
        "select-company",
        "select-kind",
        "storage-companies",
        "storage-contacts",
        "table-contacts"
      ]
    },
    {
      "propertyName": "mapper",
      "type": "code/javascript",
      "description": "A functional expression that maps (transforms, filters, sorts, reduces, ...) the data from the data source to the data model. For example: <code>dataSource => transform(dataSource)</code>",
      "literalOnly": true
    },
    {
      "propertyName": "class",
      "type": "text",
      "description": "Class(es) (space-separated) to configure the appearance or layout of the component (see the doc)"
    },
    {
      "propertyName": "layoutClass",
      "type": "text",
      "description": "Class(es) (space-separated) to configure the appearance or layout of the component container"
    },
    {
      "propertyName": "layoutStyle",
      "type": "text",
      "description": "CSS to configure the appearance or layout of the component container"
    },
    {
      "propertyName": "style",
      "type": "text"
    },
    {
      "propertyName": "defaultValue",
      "type": "textarea",
      "description": "If undefined, the data model will be initialized with this default value"
    },
    {
      "propertyName": "dataType",
      "type": "select",
      "description": "The data type expected by this component (if the actual data is not compatible, it may raise non-blocking typing errors)",
      "literalOnly": true
    },
    {
      "propertyName": "dataMultiplicity",
      "type": "select",
      "description": "The data multiplicity (if undefined, it is a 0-1 mutiplicity)",
      "literalOnly": true
    },
    {
      "propertyName": "hidden",
      "type": "checkbox"
    },
    {
      "propertyName": "resizeDirections",
      "type": "select",
      "description": "If a value other than <code>none</code> is selected, the component will be resizable against the given direction(s)",
      "possibleValues": [
        "none",
        "horizontal",
        "vertical",
        "both"
      ]
    },
    {
      "propertyName": "draggable",
      "type": "checkbox"
    },
    {
      "propertyName": "dropTarget",
      "type": "checkbox"
    },
    {
      "propertyName": "checkCanDrop",
      "type": "checkbox",
      "description": "An expression that should return true if dropping the given data is allowed on the current component"
    },
    {
      "propertyName": "observeIntersections",
      "type": "checkbox",
      "description": "When checked, the <code>@intersect</code> event is fired whenever the component intersection with the viewport changes (enters/leaves)",
      "literalOnly": true
    },
    {
      "propertyName": "revealAnimation",
      "type": "select",
      "description": "An animation to apply to this component when revealed to the user (when entering the viewport)",
      "possibleValues": [
        "",
        "bounce",
        "flash",
        "pulse",
        "rubberBand",
        "shakeX",
        "shakeY",
        "headShake",
        "swing",
        "tada",
        "wobble",
        "jello",
        "heartBeat",
        "backInDown",
        "backInLeft",
        "backInRight",
        "backInUp",
        "bounceIn",
        "bounceInDown",
        "bounceInLeft",
        "bounceInRight",
        "bounceInUp",
        "fadeIn",
        "fadeInDown",
        "fadeInDownBig",
        "fadeInLeft",
        "fadeInLeftBig",
        "fadeInRight",
        "fadeInRightBig",
        "fadeInUp",
        "fadeInUpBig",
        "fadeInTopLeft",
        "fadeInTopRight",
        "fadeInBottomLeft",
        "fadeInBottomRight",
        "rotateIn",
        "rotateInDownLeft",
        "rotateInDownRight",
        "rotateInUpLeft",
        "rotateInUpRight",
        "zoomIn",
        "zoomInDown",
        "zoomInLeft",
        "zoomInRight",
        "zoomInUp",
        "slideInDown",
        "slideInLeft",
        "slideInRight",
        "slideInUp"
      ]
    },
    {
      "propertyName": "revealAnimationOccurrence",
      "type": "select",
      "description": "When <code>once</code> is selected, the component is animated only the first time it appears",
      "possibleValues": [
        "",
        "once",
        "always"
      ]
    },
    {
      "propertyName": "revealAnimationDuration",
      "type": "text"
    },
    {
      "propertyName": "revealAnimationDelay",
      "type": "text"
    },
    {
      "propertyName": "field",
      "type": "text",
      "description": "The identifier of the field in the data source (only if the data source is an object)"
    }
  ],
  "tools-documentation": [
    {
      "name": "arrayConcat",
      "usage": "$tools.arrayConcat(array, arrayOrItem)",
      "description": "Concatenates <code>arrayOrItem</code> at the end of the given array.",
      "category": "Array functions"
    },
    {
      "name": "arrayMove",
      "usage": "$tools.arrayMove(array, fromIndex, toIndex)",
      "description": "Moves an item within an array.",
      "category": "Array functions"
    },
    {
      "name": "collectUniqueFieldValues",
      "usage": "$tools.collectUniqueFieldValues(items, fieldName, [isCollectionField], [delimiter])",
      "description": "Returns a list of values that correspond to the values found in the <code>fieldName</code> properties of the items.",
      "category": "Array functions"
    },
    {
      "name": "range",
      "usage": "$tools.range(start, end)",
      "description": "Creates an array with integer values between <code>start and </code>end.",
      "category": "Array functions"
    },
    {
      "name": "characterRange",
      "usage": "$tools.characterRange(startChar, endChar)",
      "description": "Creates an array with characters between <code>startChar</code> and <code>endChar</code>.",
      "category": "Array functions"
    },
    {
      "name": "series",
      "usage": "$tools.series(initialData, nextFunction: (data, series, index) => data, size = undefined)",
      "description": "Generates a series of data from <code>initialData</code> and a <code>nextFunction</code>. The <code>nextFunction</code> takes the current data and should return the next data in the series. If the returned value is <code>undefined</code>, the series ends.",
      "category": "Array functions"
    },
    {
      "name": "paginate",
      "usage": "$tools.paginate(array, length)",
      "description": "Returns an array containes slices/pages of the given <code>array</code> and of the given <code>length</code>. For instance, <code>$tools.paginate([1, 2, 3, 4, 5], 2)</code> returns <code>[[1, 2], [3, 4], [5]]</code>.",
      "category": "Array functions"
    },
    {
      "name": "defaultColor",
      "usage": "$tools.defaultColor(index, [opacity])",
      "description": "Gets the default color at the given index.",
      "category": "Color functions"
    },
    {
      "name": "isValidColor",
      "usage": "$tools.isValidColor(color)",
      "description": "Returns true if the given color object is valid.",
      "category": "Color functions"
    },
    {
      "name": "hexToRgb",
      "usage": "$tools.hexToRgb(hex)",
      "description": "Transforms a hex-color string to its rgb array representation.",
      "category": "Color functions"
    },
    {
      "name": "rgbToHex",
      "usage": "$tools.rgbToHex(r, g, b)",
      "description": "Tansforms a rgb array to an hex-color string.",
      "category": "Color functions"
    },
    {
      "name": "normalizeHex",
      "usage": "$tools.normalizeHex(hex)",
      "description": "Normalizes the hex-color string.",
      "category": "Color functions"
    },
    {
      "name": "colorGradientHex",
      "usage": "$tools.colorGradientHex(hexBegin, hexEnd, blendRatio)",
      "description": "Creates a color gradient from 2 colors.",
      "category": "Color functions"
    },
    {
      "name": "colorGradientRgb",
      "usage": "$tools.colorGradientRgb(rgbBegin, rgbEnd, blendRatio)",
      "category": "Color functions"
    },
    {
      "name": "colorNameToHex",
      "usage": "$tools.colorNameToHex(colorName)",
      "category": "Color functions"
    },
    {
      "name": "mixColors",
      "usage": "$tools.mixColors(rgbA, rgbB, amountToMix)",
      "description": "Mixes two colors A and B to return a color between A and B according to the amountToMix (a value beeteen 1 and 0, the closer to 1, the closer to A).",
      "category": "Color functions"
    },
    {
      "name": "isDarkColor",
      "usage": "$tools.isDakColor(color)",
      "description": "Tells if the given color is more dark than light. Color can be in a CSS, hex, or RGB array format",
      "category": "Color functions"
    },
    {
      "name": "camelToKebabCase",
      "usage": "$tools.camelToKebabCase(str)",
      "description": "Converts a camel-case string to a kebab-case string. For instance <code>abcDef</code> converts to <code>abc-def<code>.",
      "category": "Conversion functions"
    },
    {
      "name": "camelToSnakeCase",
      "usage": "$tools.camelToSnakeCase(str)",
      "description": "Converts a camel-case string to a snake-case string. For instance <code>abcDef</code> converts to <code>abc_def<code>.",
      "category": "Conversion functions"
    },
    {
      "name": "camelToLabelText",
      "usage": "$tools.camelToLabelText(str, lowerCase = false)",
      "description": "Converts a camel-case string to a label-case string. For instance <code>abcDef</code> converts to <code>abc def<code>.",
      "category": "Conversion functions"
    },
    {
      "name": "kebabToCamelCase",
      "usage": "$tools.kebabToCamelCase(str, lowerCase = false)",
      "description": "Converts a kebab-case string to a camel-case string. For instance <code>abc-def</code> converts to <code>abcDef<code>.",
      "category": "Conversion functions"
    },
    {
      "name": "kebabToLabelText",
      "usage": "$tools.kebabToLabelText(str, lowerCase = false)",
      "description": "Converts a kebab-case string to a label-case string. For instance <code>abc-def</code> converts to <code>abc def<code>.",
      "category": "Conversion functions"
    },
    {
      "name": "snakeToCamelCase",
      "usage": "$tools.snakeToCamelCase(str, lowerCase = false)",
      "description": "Converts a snake-case string to a camel-case string. For instance <code>abc_def</code> converts to <code>abcDef<code>.",
      "category": "Conversion functions"
    },
    {
      "name": "snakeToLabelText",
      "usage": "$tools.snakeToLabelText(str, lowerCase = false)",
      "description": "Converts a snake-case string to a label-case string. For instance <code>abc_def</code> converts to <code>abc def<code>.",
      "category": "Conversion functions"
    },
    {
      "name": "markdownToHtml",
      "usage": "$tools.markdownToHtml(markdownText)",
      "description": "Converts a markdown string to html. For instance <code># My Title</code> converts to <code>&lt;h1&gt;My Title&lt;/h1&gt;<code>.",
      "category": "Conversion functions"
    },
    {
      "name": "toLabelText",
      "usage": "$tools.toLabelText(str, lowerCase = false)",
      "description": "Converts a string to a label string.",
      "category": "Conversion functions"
    },
    {
      "name": "csvToArray",
      "usage": "$tools.csvToArray(csv, separator, hasHeaders, headers)",
      "description": "Converts a CSV-formatted text to an array of objects.",
      "category": "Conversion functions"
    },
    {
      "name": "arrayToCsv",
      "usage": "$tools.arrayToCsv(array, separator, keys, headers)",
      "description": "Converts an array of objects to CSV-formatted text.",
      "category": "Conversion functions"
    },
    {
      "name": "convertImage",
      "usage": "$tools.[DEPRECATED] convertImage(sourceImage, dataCallback, quality = 0.5, maxWidth = 800, outputMimeType = 'image/jpg')",
      "description": "Converts an image to another image according to the given conversion parameters.",
      "category": "Conversion functions"
    },
    {
      "name": "convertImageData",
      "usage": "$tools.convertImageData(sourceImageData, conversionOptions)",
      "description": "Converts an image to another image according to the given conversion parameters (quality = 0.5, maxWidth = 800, outputMimeType = 'image/jpg', width, height).",
      "category": "Conversion functions"
    },
    {
      "name": "xmlToJson",
      "usage": "$tools.xmlToJson(xml, options)",
      "description": "Parses an XML string and converts it to a JSON object. Options are parsing options as defined <a href=\"https://github.com/NaturalIntelligence/fast-xml-parser/blob/master/docs/v4/2.XMLparseOptions.md\">here</a>",
      "category": "Conversion functions"
    },
    {
      "name": "isValidDate",
      "usage": "$tools.isValidDate(date)",
      "description": "Returns <code>true</code> if the given <code>date</code> parameter is a valid date.",
      "category": "Date functions"
    },
    {
      "name": "now",
      "usage": "$tools.now()",
      "description": "Returns the current date.",
      "category": "Date functions"
    },
    {
      "name": "date",
      "usage": "$tools.date(date)",
      "description": "Returns a date from a string/object.",
      "category": "Date functions"
    },
    {
      "name": "datetime",
      "usage": "$tools.datetime(date)",
      "description": "Returns a datetime from a string/object.",
      "category": "Date functions"
    },
    {
      "name": "time",
      "usage": "$tools.time(date)",
      "description": "Returns a time from a string/object.",
      "category": "Date functions"
    },
    {
      "name": "dateRange",
      "usage": "$tools.dateRange(dateStart, dateEnd, step=1, stepKind='DAY')",
      "description": "Returns an array of date objects between <code>dateStart</code> and <code>dateEnd</code>, with <code>stepKind = 'SECOND' | 'MINUTE' | 'HOUR' | 'DAY' | 'MONTH' | 'YEAR'</code>.",
      "category": "Date functions"
    },
    {
      "name": "diffBusinessDays",
      "usage": "$tools.diffBusinessDays(firstDate, secondDate)",
      "description": "Returns the number of business days between two dates",
      "category": "Date functions"
    },
    {
      "name": "loadScript",
      "usage": "$tools.loadScript(url, [callback])",
      "description": "Loads a Javascript file from a URL - returns a promise",
      "category": "IO and navigation functions"
    },
    {
      "name": "loadStyleSheet",
      "usage": "$tools.loadStyleSheet(url, callback)",
      "description": "Loads a CSS file from a URL - returns a promise",
      "category": "IO and navigation functions"
    },
    {
      "name": "deleteCookie",
      "usage": "$tools.deleteCookie(name)",
      "description": "Deletes cookie.",
      "category": "IO and navigation functions"
    },
    {
      "name": "getCookie",
      "usage": "$tools.getCookie(name)",
      "description": "Gets cookie.",
      "category": "IO and navigation functions"
    },
    {
      "name": "setCookie",
      "usage": "$tools.setCookie(name, value, expirationDate)",
      "description": "Sets cookie.",
      "category": "IO and navigation functions"
    },
    {
      "name": "download",
      "usage": "$tools.download(data, filename, type)",
      "description": "Downloads the given <code>data</code> as a local file.",
      "category": "IO and navigation functions"
    },
    {
      "name": "upload",
      "usage": "$tools.[DEPRECATED] upload(callback, resultType = 'text', maxSize = 10*1024, sizeExceededCallback = undefined, conversionOptions = undefined)",
      "description": "Uploads a file choosen locally by the user (<code>resultType</code> may be 'file', 'text' (default), or 'json'). When the upload is finished, the <code>callback</code> function is called whith te uploaded data as a parameter.",
      "category": "IO and navigation functions"
    },
    {
      "name": "uploadFile",
      "usage": "$tools.uploadFile(resultType = 'text', maxSize = 10*1024, sizeExceededCallback = undefined, conversionOptions = undefined)",
      "description": "Uploads a file choosen locally by the user (<code>resultType</code> may be <code>'file'</code>, <code>'text'</code> (default), <code>'data'</code>, or <code>'json'</code>). Use <code>'data'</code> for images. When the upload is finished, the promise is resolved with the loaded data or file (if 'file' is specified). For an image, conversionOptions can be set to automatically convert the image (possibly reducing its size).",
      "category": "IO and navigation functions"
    },
    {
      "name": "postFileToServer",
      "usage": "$tools.postFileToServer(postUrl, file, onLoadCallback = undefined)",
      "category": "IO and navigation functions"
    },
    {
      "name": "publicResourceUrl",
      "usage": "$tools.publicResourceUrl(owner, path)",
      "category": "IO and navigation functions"
    },
    {
      "name": "avatarUrl",
      "usage": "$tools.avatarUrl(user)",
      "category": "IO and navigation functions"
    },
    {
      "name": "notifyParentApplication",
      "usage": "$tools.notifyParentApplication(messageName, ...arguments)",
      "category": "IO and navigation functions"
    },
    {
      "name": "requestFromParentApplication",
      "usage": "$tools.requestFromParentApplication(messageName, responseHandler: (result) => void, ...arguments)",
      "category": "IO and navigation functions"
    },
    {
      "name": "onChildApplicationMessage",
      "usage": "$tools.onChildApplicationMessage(applicationName, messageName, handler: (...arguments) => any)",
      "category": "IO and navigation functions"
    },
    {
      "name": "update",
      "usage": "$tools.update(...componentTypes)",
      "category": "IO and navigation functions"
    },
    {
      "name": "linkify",
      "usage": "$tools.linkify(text)",
      "description": "Looks for all the URLs in a text and wrap them with HTML links. For instance, <code>'https//abc.com'</code> will be converted to <code>'&lt;a href=\"https//abc.com\"&gt;https//abc.com&lt;/a&gt;<code>'.",
      "category": "String functions"
    },
    {
      "name": "validateEmail",
      "usage": "$tools.validateEmail(email)",
      "description": "Returns <code>true</code> if the given <code>email</code> parameter is a valid email.",
      "category": "String functions"
    },
    {
      "name": "indexOf",
      "usage": "$tools.indexOf(string, substring, occurrence)",
      "category": "String functions"
    },
    {
      "name": "isValidEmail",
      "usage": "$tools.isValidEmail(email)",
      "description": "Returns <code>true</code> if the given <code>email</code> parameter is a valid email.",
      "category": "String functions"
    },
    {
      "name": "isNotEmpty",
      "usage": "$tools.isNotEmpty(string)",
      "description": "Returns <code>true</code> if the given <code>string</code> parameter is not empty or undefined/null.",
      "category": "String functions"
    },
    {
      "name": "toHex",
      "usage": "$tools.toHex(number, [padding])",
      "description": "Converts a number to its hexadecimal representation. The <code>padding</code> parameters tells the number of digits.",
      "category": "String functions"
    },
    {
      "name": "truncate",
      "usage": "$tools.truncate(str, size)",
      "description": "Truncates the given string so that it does not exceed the given <code>size</code>.",
      "category": "String functions"
    },
    {
      "name": "capitalize",
      "usage": "$tools.capitalize(str, [allLetters])",
      "description": "Capitalizes the given string. If <code>allLetters</code> is false, only the first letter is capitalized, otherwise the whole word.",
      "category": "String functions"
    },
    {
      "name": "normalize",
      "usage": "$tools.normalize(str)",
      "description": "Removes all uppercase letters, accents and special caracters so that normalized strings can be compared with 'lazy' matching.",
      "category": "String functions"
    },
    {
      "name": "toast",
      "usage": "$tools.toast(title, message, variant = null, toaster = 'b-toaster-bottom-right')",
      "description": "Shows a toast to the user with given <code>title</code> and <code>message</code>. The <code>variant</code> is the Bootstrap variant. The <code>toaster</code> parameter defines the toast layout.",
      "category": "UI functions"
    },
    {
      "name": "icon",
      "usage": "$tools.icon(icon, [options])",
      "description": "Creates an SVG icon available in <a href=\"https://bootstrap-vue.org/docs/icons#icons-1\">BootstrapVue icons</a>.",
      "category": "UI functions"
    },
    {
      "name": "getCurrentLocale",
      "usage": "$tools.getCurrentLocale(locale)",
      "description": "Returns the current locale, as defined by the navigator, or selected by the user.",
      "category": "UI functions"
    },
    {
      "name": "countryFlag",
      "usage": "$tools.countryFlag(locale)",
      "description": "Gets the country flag character for the given <code>locale</code>.",
      "category": "UI functions"
    },
    {
      "name": "refresh",
      "usage": "$tools.refresh(...componentTypes)",
      "category": "UI functions"
    },
    {
      "name": "exitFullscreen",
      "usage": "$tools.exitFullscreen()",
      "description": "Leaves fullscreen mode, after requested with <code>$c(...).requestFullscreen()</code>",
      "category": "UI functions"
    },
    {
      "name": "isFullscreen",
      "usage": "$tools.isFullscreen()",
      "description": "Tells if the application is in fullscreen mode, after requested with <code>$c(...).requestFullscreen()</code>",
      "category": "UI functions"
    },
    {
      "name": "showOverlay",
      "usage": "$tools.showOverlay(show)",
      "description": "Shows a spinner overlay on the main area (typically to indicate some on-going work). If <code>show</code> is false, the overlay is hidden.",
      "category": "UI functions"
    },
    {
      "name": "alert",
      "usage": "$tools.alert(message, [title], [size])",
      "description": "Shows an alert modal.",
      "category": "UI functions"
    },
    {
      "name": "confirm",
      "usage": "$tools.confirm(message, [title], [size], [customButtons])",
      "description": "Shows a confirm modal.",
      "category": "UI functions"
    },
    {
      "name": "prompt",
      "usage": "$tools.prompt(message, [defaultValue], [title], [size])",
      "description": "Shows a prompt modal.",
      "category": "UI functions"
    },
    {
      "name": "currencies",
      "usage": "$tools.currencies()",
      "category": "Utilities"
    },
    {
      "name": "uuid",
      "usage": "$tools.uuid()",
      "description": "Creates a unique ID.",
      "category": "Utilities"
    },
    {
      "name": "setTimeoutWithRetry",
      "usage": "$tools.setTimeoutWithRetry(handler, retries, interval)",
      "category": "Utilities"
    },
    {
      "name": "setTimeoutWhileTrue",
      "usage": "$tools.setTimeoutWhileTrue(handler, predicate, interval)",
      "category": "Utilities"
    },
    {
      "name": "toSimpleName",
      "usage": "$tools.toSimpleName(qualifiedName)",
      "category": "Utilities"
    },
    {
      "name": "functionBody",
      "usage": "$tools.functionBody(f)",
      "category": "Utilities"
    },
    {
      "name": "functionParams",
      "usage": "$tools.functionParams(f)",
      "category": "Utilities"
    },
    {
      "name": "inputType",
      "usage": "$tools.inputType(type)",
      "category": "Utilities"
    },
    {
      "name": "diff",
      "usage": "$tools.diff(array, fields)",
      "category": "Utilities"
    },
    {
      "name": "fireCustomEvent",
      "usage": "$tools.fireCustomEvent(eventName, element, data)",
      "category": "Utilities"
    },
    {
      "name": "cloneData",
      "usage": "$tools.cloneData(data)",
      "category": "Utilities"
    },
    {
      "name": "diffData",
      "usage": "$tools.diffData(data1, data2)",
      "description": "Returns the list of data fields that have different values in <code>data1</code> and <code>data2</code>.",
      "category": "Utilities"
    },
    {
      "name": "filterData",
      "usage": "$tools.filterData(data, filter)",
      "category": "Utilities"
    },
    {
      "name": "mapData",
      "usage": "$tools.mapData(data, mapper)",
      "category": "Utilities"
    },
    {
      "name": "rect",
      "usage": "$tools.rect(component)",
      "category": "Utilities"
    },
    {
      "name": "remSize",
      "usage": "$tools.remSize()",
      "category": "Utilities"
    }
  ],
  "components-action-documentation": {
    "HttpConnector": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "invoke",
        "usage": "$c(targetId).invoke(...invokeParams)",
        "category": "Custom actions"
      },
      {
        "name": "clearCache",
        "usage": "$c(targetId).clearCache()",
        "category": "Custom actions"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "CookieConnector": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "LocalStorageConnector": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "rename",
        "usage": "$c(targetId).rename(newName)",
        "category": "Custom actions"
      },
      {
        "name": "wait",
        "usage": "$c(targetId).wait()",
        "category": "Custom actions"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "DataMapper": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "GeolocConnector": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "TextView": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "setVariant",
        "usage": "$c(targetId).setVariant(variant)",
        "description": "Sets a variant, which overrides the defined one (only for badges and alerts).",
        "category": "Custom actions"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "CheckboxView": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "showState",
        "usage": "$c(targetId).showState()",
        "description": "Shows the input validation state.",
        "category": "Custom actions"
      },
      {
        "name": "hideState",
        "usage": "$c(targetId).hideState()",
        "description": "Hides the input validation state.",
        "category": "Custom actions"
      },
      {
        "name": "focus",
        "usage": "$c(targetId).focus()",
        "description": "Makes the current input gain the focus (keyboard).",
        "category": "Custom actions"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "SelectView": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "close",
        "usage": "$c(targetId).close()",
        "description": "Closes the dropdown (or sidebar if responsive)",
        "category": "Custom actions"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "InputView": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "showState",
        "usage": "$c(targetId).showState()",
        "description": "Shows the input validation state.",
        "category": "Custom actions"
      },
      {
        "name": "hideState",
        "usage": "$c(targetId).hideState()",
        "description": "Hides the input validation state.",
        "category": "Custom actions"
      },
      {
        "name": "focus",
        "usage": "$c(targetId).focus()",
        "description": "Makes the current input gain the focus (keyboard).",
        "category": "Custom actions"
      },
      {
        "name": "toggleShowPassword",
        "usage": "$c(targetId).toggleShowPassword()",
        "description": "Shows/hides the password.",
        "category": "Custom actions"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "TextareaView": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "showState",
        "usage": "$c(targetId).showState()",
        "description": "Shows the input validation state.",
        "category": "Custom actions"
      },
      {
        "name": "hideState",
        "usage": "$c(targetId).hideState()",
        "description": "Hides the input validation state.",
        "category": "Custom actions"
      },
      {
        "name": "focus",
        "usage": "$c(targetId).focus()",
        "description": "Makes the current input gain the focus (keyboard).",
        "category": "Custom actions"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "ButtonView": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "focus",
        "usage": "$c(targetId).focus()",
        "description": "Gets the keyboard focus.",
        "category": "Custom actions"
      },
      {
        "name": "startSpinner",
        "usage": "$c(targetId).startSpinner()",
        "description": "Starts the spinner on this button.",
        "category": "Custom actions"
      },
      {
        "name": "stopSpinner",
        "usage": "$c(targetId).stopSpinner()",
        "description": "Stops the spinner on this button.",
        "category": "Custom actions"
      },
      {
        "name": "toggleSpinner",
        "usage": "$c(targetId).toggleSpinner()",
        "description": "Toggles the spinner on this button.",
        "category": "Custom actions"
      },
      {
        "name": "isSpinning",
        "usage": "$c(targetId).isSpinning()",
        "description": "True if the spinner is spinning on this button.",
        "category": "Custom actions"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "ImageView": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "clearProxyCache",
        "usage": "$c(targetId).clearProxyCache()",
        "description": "Clears the cache of the proxy.",
        "category": "Custom actions"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "IconView": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "ContainerView": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "showState",
        "usage": "$c(targetId).showState()",
        "description": "Shows the form input states (valid or invalid).",
        "category": "Custom actions"
      },
      {
        "name": "hideState",
        "usage": "$c(targetId).hideState()",
        "description": "Hides the form input states (valid or invalid).",
        "category": "Custom actions"
      },
      {
        "name": "submit",
        "usage": "$c(targetId).submit()",
        "description": "Submits this form if valid (triggers a <code>@submit</code> event).",
        "category": "Custom actions"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Goes to the next step of this stepper container.",
        "category": "Custom actions"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Goes to the previous step of this stepper container.",
        "category": "Custom actions"
      },
      {
        "name": "goto",
        "usage": "$c(targetId).goto(step)",
        "description": "Goes to the given step of this stepper container.",
        "category": "Custom actions"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "ReferenceView": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "setReference",
        "usage": "$c(targetId).setReference(componentOrId)",
        "description": "Sets the referenced component dynamically, overiding the initial one (note that setting undefined will reset the reference to its initial state).",
        "category": "Custom actions"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "SplitView": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "CardView": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "IteratorView": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "setCurrentPage",
        "usage": "$c(targetId).setCurrentPage(page)",
        "description": "Sets the current page of this paginated component. The <code>page</code> number is 1-indexed.",
        "category": "Custom actions"
      },
      {
        "name": "nextPage",
        "usage": "$c(targetId).nextPage()",
        "description": "Moves this paginated component to the next page.",
        "category": "Custom actions"
      },
      {
        "name": "previousPage",
        "usage": "$c(targetId).previousPage()",
        "description": "Moves this paginated component to the previous page.",
        "category": "Custom actions"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Goes to the next step of this stepper container.",
        "category": "Custom actions"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Goes to the previous step of this stepper container.",
        "category": "Custom actions"
      },
      {
        "name": "goto",
        "usage": "$c(targetId).goto(step)",
        "description": "Goes to the given step of this stepper container.",
        "category": "Custom actions"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "TabsView": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next(validateCurrent)",
        "category": "Custom actions"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "category": "Custom actions"
      },
      {
        "name": "setTabIndex",
        "usage": "$c(targetId).setTabIndex(tabIndex)",
        "category": "Custom actions"
      },
      {
        "name": "validate",
        "usage": "$c(targetId).validate(tabIndex)",
        "category": "Custom actions"
      },
      {
        "name": "invalidate",
        "usage": "$c(targetId).invalidate(tabIndex)",
        "category": "Custom actions"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "CollapseView": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "DialogView": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "TableView": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "showDetails",
        "usage": "$c(targetId).showDetails(objectIndex)",
        "description": "Shows the details for the given object.",
        "category": "Custom actions"
      },
      {
        "name": "hideDetails",
        "usage": "$c(targetId).hideDetails(objectIndex)",
        "description": "Hides the details for the given object.",
        "category": "Custom actions"
      },
      {
        "name": "toggleDetails",
        "usage": "$c(targetId).toggleDetails(objectIndex)",
        "description": "Toggles the details for the given object.",
        "category": "Custom actions"
      },
      {
        "name": "selectRow",
        "usage": "$c(targetId).selectRow(rowIndex)",
        "description": "Selects the given row",
        "category": "Custom actions"
      },
      {
        "name": "unselectRow",
        "usage": "$c(targetId).unselectRow(rowIndex)",
        "description": "Unselects the given row.",
        "category": "Custom actions"
      },
      {
        "name": "selectAllRows",
        "usage": "$c(targetId).selectAllRows()",
        "description": "Selects all rows (only if multi-select is enabled).",
        "category": "Custom actions"
      },
      {
        "name": "clearSelected",
        "usage": "$c(targetId).clearSelected()",
        "description": "Clears the current selection if any.",
        "category": "Custom actions"
      },
      {
        "name": "setCurrentPage",
        "usage": "$c(targetId).setCurrentPage(page)",
        "description": "Sets the current page of this paginated component. The <code>page</code> number is 1-indexed.",
        "category": "Custom actions"
      },
      {
        "name": "nextPage",
        "usage": "$c(targetId).nextPage()",
        "description": "Moves this paginated component to the next page.",
        "category": "Custom actions"
      },
      {
        "name": "previousPage",
        "usage": "$c(targetId).previousPage()",
        "description": "Moves this paginated component to the previous page.",
        "category": "Custom actions"
      },
      {
        "name": "showLiveConfigurationDialog",
        "usage": "$c(targetId).showLiveConfigurationDialog()",
        "description": "Shows a dialog to allow the user to change the table configuration (visible fields, options, ...).",
        "category": "Custom actions"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "ChartView": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "setActiveElements",
        "usage": "$c(targetId).setActiveElements(activeElements)",
        "description": "Sets the active elements of this chart as a list. Each element is an object containing <code>datasetIndex</code> and <code>index</code> fields.",
        "category": "Custom actions"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "TimeSeriesChartView": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "setActiveElements",
        "usage": "$c(targetId).setActiveElements(activeElements)",
        "description": "Sets the active elements of this chart as a list. Each element is an object containing <code>datasetIndex</code> and <code>index</code> fields.",
        "category": "Custom actions"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "TagsView": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "showState",
        "usage": "$c(targetId).showState()",
        "description": "Shows the input validation state.",
        "category": "Custom actions"
      },
      {
        "name": "hideState",
        "usage": "$c(targetId).hideState()",
        "description": "Hides the input validation state.",
        "category": "Custom actions"
      },
      {
        "name": "focus",
        "usage": "$c(targetId).focus()",
        "description": "Makes the current input gain the focus (keyboard).",
        "category": "Custom actions"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "PopoverView": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "DatepickerView": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "showState",
        "usage": "$c(targetId).showState()",
        "description": "Shows the input validation state.",
        "category": "Custom actions"
      },
      {
        "name": "hideState",
        "usage": "$c(targetId).hideState()",
        "description": "Hides the input validation state.",
        "category": "Custom actions"
      },
      {
        "name": "focus",
        "usage": "$c(targetId).focus()",
        "description": "Makes the current input gain the focus (keyboard).",
        "category": "Custom actions"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "TimepickerView": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "showState",
        "usage": "$c(targetId).showState()",
        "description": "Shows the input validation state.",
        "category": "Custom actions"
      },
      {
        "name": "hideState",
        "usage": "$c(targetId).hideState()",
        "description": "Hides the input validation state.",
        "category": "Custom actions"
      },
      {
        "name": "focus",
        "usage": "$c(targetId).focus()",
        "description": "Makes the current input gain the focus (keyboard).",
        "category": "Custom actions"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "PaginationView": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "setCurrentPage",
        "usage": "$c(targetId).setCurrentPage(page)",
        "description": "Sets the current page of this paginated component. The <code>page</code> number is 1-indexed.",
        "category": "Custom actions"
      },
      {
        "name": "nextPage",
        "usage": "$c(targetId).nextPage()",
        "description": "Moves this paginated component to the next page.",
        "category": "Custom actions"
      },
      {
        "name": "previousPage",
        "usage": "$c(targetId).previousPage()",
        "description": "Moves this paginated component to the previous page.",
        "category": "Custom actions"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "AvatarView": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "EmbedView": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "play",
        "usage": "$c(targetId).play()",
        "description": "Plays the media file.",
        "category": "Custom actions"
      },
      {
        "name": "pause",
        "usage": "$c(targetId).pause()",
        "description": "Pauses the media file (if playing).",
        "category": "Custom actions"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "MapView": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "panTo",
        "usage": "$c(targetId).panTo(geolocatedObject)",
        "description": "Moves the map to the given location (to the map center if undefined).",
        "category": "Custom actions"
      },
      {
        "name": "flyTo",
        "usage": "$c(targetId).flyTo(geolocatedObject, zoom)",
        "description": "Moves the map to the given location and zoom level with a \"fly\" animation (to the map center if undefined).",
        "category": "Custom actions"
      },
      {
        "name": "fitBounds",
        "usage": "$c(targetId).fitBounds(bounds)",
        "description": "Adjusts the map to the given bounds, or to the visible markers if undefined. Note that <code>bounds</code> is a leaflet object instance of <code>L.LatLngBounds</code>. See the <code>getBounds(...latlng)</code> and <code>getMarkerBounds()</code> functions.",
        "category": "Custom actions"
      },
      {
        "name": "lock",
        "usage": "$c(targetId).lock(locked)",
        "description": "Disables map user interations.",
        "category": "Custom actions"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "CarouselView": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "setSlide",
        "usage": "$c(targetId).setSlide(index)",
        "description": "Go to slide specified by index",
        "category": "Custom actions"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Go to next slide",
        "category": "Custom actions"
      },
      {
        "name": "prev",
        "usage": "$c(targetId).prev()",
        "description": "Go to previous slide",
        "category": "Custom actions"
      },
      {
        "name": "pause",
        "usage": "$c(targetId).pause()",
        "description": "Pause the slide cycling",
        "category": "Custom actions"
      },
      {
        "name": "start",
        "usage": "$c(targetId).start()",
        "description": "Start slide cycling (prop interval must have a value)",
        "category": "Custom actions"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "ProgressView": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "showState",
        "usage": "$c(targetId).showState()",
        "description": "Shows the input validation state.",
        "category": "Custom actions"
      },
      {
        "name": "hideState",
        "usage": "$c(targetId).hideState()",
        "description": "Hides the input validation state.",
        "category": "Custom actions"
      },
      {
        "name": "focus",
        "usage": "$c(targetId).focus()",
        "description": "Makes the current input gain the focus (keyboard).",
        "category": "Custom actions"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "NavbarView": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "overrideVariant",
        "usage": "$c(targetId).overrideVariant(variant)",
        "description": "Programmatically overrides this navbar variant, defined in the <code>variant</code> property.",
        "category": "Custom actions"
      },
      {
        "name": "go",
        "usage": "$c(targetId).go(place, [top])",
        "description": "Goes to the given place, which can be a page (a pageId), an anchor/hash in the page (defined by a component), or a full route object. Routes can be the following. A path object: <code>{ path: '/users/eduardo' }</code>. Named route with params to let the router build the url: <code>{ name: 'user', params: { username: 'eduardo' } }</code>. With query, resulting in <code>'/register?plan=private'</code>: <code>{ path: '/register', query: { plan: 'private' } }</code>. With hash, resulting in <code>'/about#team'</code>: <code>{ path: '/about', hash: '#team' }</code>.",
        "category": "Custom actions"
      },
      {
        "name": "back",
        "usage": "$c(targetId).back()",
        "description": "Goes back to the previous place in the navigation history.",
        "category": "Custom actions"
      },
      {
        "name": "forward",
        "usage": "$c(targetId).forward()",
        "description": "Goes to the next place in the navigation history (only if back was used before).",
        "category": "Custom actions"
      },
      {
        "name": "selectLocale",
        "usage": "$c(targetId).selectLocale(locale)",
        "description": "Selects the given locale (will apply i18n for all components).",
        "category": "Custom actions"
      },
      {
        "name": "setUserProfile",
        "usage": "$c(targetId).setUserProfile(userProfile)",
        "description": "An object containing the following fields: <code>email</code>, <code>firstName</code>, <code>lastName</code>, <code>imageUrl</code>",
        "category": "Custom actions"
      },
      {
        "name": "signIn",
        "usage": "$c(targetId).signIn()",
        "description": "Triggers custom user login.",
        "category": "Custom actions"
      },
      {
        "name": "signOut",
        "usage": "$c(targetId).signOut()",
        "description": "Triggers custom user logout.",
        "category": "Custom actions"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "PdfView": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "CameraView": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([dataCapturedCallback])",
        "category": "Custom actions"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ],
    "SidebarView": [
      {
        "name": "eval",
        "usage": "$c(targetId).eval(...expression)",
        "description": "Evaluates the given Javascript expressions - should be separated with commas: <code>expr1, expr2, expr3</code>."
      },
      {
        "name": "setVisible",
        "usage": "$c(targetId).setVisible(visible, [data])",
        "description": "Shows or hides the current component depending on the <code>visible</code> value. If <code>data</code> is defined, sets the data of the component while making it visible."
      },
      {
        "name": "toggleVisible",
        "usage": "$c(targetId).toggleVisible([data])",
        "description": "Toggle component visibility. See <code>setVisible</code>"
      },
      {
        "name": "show",
        "usage": "$c(targetId).show([data], [scrollIntoViewOptions])",
        "description": "Makes the current component visible. If <code>data</code> is defined, sets the data of the component."
      },
      {
        "name": "hide",
        "usage": "$c(targetId).hide()",
        "description": "Shows or hides the current component."
      },
      {
        "name": "scrollIntoView",
        "usage": "$c(targetId).scrollIntoView([scrollIntoViewOptions])",
        "description": "Scrolls the component to make it visible in the container."
      },
      {
        "name": "animate",
        "usage": "$c(targetId).animate(animation, duration=1000, delay=0)",
        "description": "Applies an animation to the component."
      },
      {
        "name": "emit",
        "usage": "$c(targetId).emit(event, ...args)",
        "description": "Emits an event."
      },
      {
        "name": "update",
        "usage": "$c(targetId).update()",
        "description": "Updates the data of this component, as defined by its data source."
      },
      {
        "name": "clear",
        "usage": "$c(targetId).clear()",
        "description": "Clears by force the data of this component, even if the data source is not empty."
      },
      {
        "name": "reset",
        "usage": "$c(targetId).reset()",
        "description": "Resets the components data to its default value."
      },
      {
        "name": "forceRender",
        "usage": "$c(targetId).forceRender()",
        "description": "Forces the component to render again fully. Normaly this is not necessary to use because most data modification is reactive, however, in some specific cases it might be necessary."
      },
      {
        "name": "setData",
        "usage": "$c(targetId).setData(data, [byReference])",
        "description": "Sets the data of this component."
      },
      {
        "name": "sendApplicationResult",
        "usage": "$c(targetId).sendApplicationResult(value)"
      },
      {
        "name": "downloadAsPDF",
        "usage": "$c(targetId).downloadAsPDF(options)",
        "description": "Downloads a PDF-version of this component, as it renders currently on the screen."
      },
      {
        "name": "requestFullscreen",
        "usage": "$c(targetId).requestFullscreen()",
        "description": "Requests the browser to switch this component in full screen mode. Can be unswitched programatically with <code>$tools.exitFullscreen()</code>"
      },
      {
        "name": "addData",
        "usage": "$c(targetId).addData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. It is better if the data contains a unique <code>id</code> field",
        "category": "Array data model actions"
      },
      {
        "name": "removeData",
        "usage": "$c(targetId).removeData(data)",
        "description": "If the data model of this component is an array, adds the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "toggleData",
        "usage": "$c(targetId).toggleData(data)",
        "description": "If the data model of this component is an array, adds (if not present yet) or removes (if present yet) the given data to it. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "replaceData",
        "usage": "$c(targetId).replaceData(data)",
        "description": "If the data model of this component is an array, and the data is already found by id, replaces the found data with the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "mergeData",
        "usage": "$c(targetId).mergeData(data, [policy])",
        "description": "Merges an existing data with a new version. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array data model actions"
      },
      {
        "name": "concatArray",
        "usage": "$c(targetId).concatArray(array)",
        "description": "Adds an array of data to the existing array.",
        "category": "Array data model actions"
      },
      {
        "name": "replaceDataAt",
        "usage": "$c(targetId).replaceDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertDataAt",
        "usage": "$c(targetId).insertDataAt(data, index)",
        "category": "Array data model actions"
      },
      {
        "name": "removeDataAt",
        "usage": "$c(targetId).removeDataAt(index)",
        "category": "Array data model actions"
      },
      {
        "name": "insertArrayAt",
        "usage": "$c(targetId).insertArrayAt(array, index)",
        "category": "Array data model actions"
      },
      {
        "name": "moveDataFromTo",
        "usage": "$c(targetId).moveDataFromTo(fromIndex, toIndex)",
        "category": "Array data model actions"
      },
      {
        "name": "setFieldData",
        "usage": "$c(targetId).setFieldData(fieldName, data, [byReference])",
        "description": "If the data model is an object, adds or updates a field named <code>fieldName</code> to this object, filled with the value given by <code>data</code>",
        "category": "Object data model actions"
      },
      {
        "name": "addCollectionData",
        "usage": "$c(targetId).addCollectionData(collectionName, data)",
        "description": "If the data model is an object, adds or updates a field named <code>collectionName</code> to this object, by adding <code>data</code> to the field, which is expected to contain an array",
        "category": "Object data model actions"
      },
      {
        "name": "removeCollectionData",
        "usage": "$c(targetId).removeCollectionData(collectionName, data)",
        "description": "If the data model is an object, updates a field named <code>collectionName</code> to this object, by removing <code>data</code> from the field, which is expected to contain an array",
        "category": "Object data model actions"
      }
    ]
  },
  "components-stateless-action-documentation": {
    "HttpConnector": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      }
    ],
    "CookieConnector": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      }
    ],
    "LocalStorageConnector": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      }
    ],
    "DataMapper": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      }
    ],
    "GeolocConnector": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      },
      {
        "name": "searchGeolocation",
        "usage": "$c(targetId).searchGeolocation(place, [clearCache])",
        "description": "Searches the coordinates for the given place. If <code>clearCache</code> is true, the search will reset the cached value and hit the original service again (to be used with caution).",
        "category": "Custom stateless actions"
      }
    ],
    "TextView": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      }
    ],
    "CheckboxView": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      },
      {
        "name": "isValid",
        "usage": "$c(targetId).isValid()",
        "description": "True is this input data is valid.",
        "category": "Custom stateless actions"
      }
    ],
    "SelectView": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      },
      {
        "name": "getDefaultTitle",
        "usage": "$c(targetId).getDefaultTitle()",
        "description": "Gets the default title of this select",
        "category": "Custom stateless actions"
      }
    ],
    "InputView": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      },
      {
        "name": "isValid",
        "usage": "$c(targetId).isValid()",
        "description": "True is this input data is valid.",
        "category": "Custom stateless actions"
      },
      {
        "name": "isShowingPassword",
        "usage": "$c(targetId).isShowingPassword()",
        "description": "Tells if this input is a password input and if it is currently showing the password.",
        "category": "Custom stateless actions"
      }
    ],
    "TextareaView": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      },
      {
        "name": "isValid",
        "usage": "$c(targetId).isValid()",
        "description": "True is this input data is valid.",
        "category": "Custom stateless actions"
      }
    ],
    "ButtonView": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      }
    ],
    "ImageView": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      },
      {
        "name": "getUrl",
        "usage": "$c(targetId).getUrl()",
        "description": "Returns the image URL.",
        "category": "Custom stateless actions"
      }
    ],
    "IconView": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      }
    ],
    "ContainerView": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      },
      {
        "name": "isValid",
        "usage": "$c(targetId).isValid()",
        "category": "Custom stateless actions"
      },
      {
        "name": "getCurrentStep",
        "usage": "$c(targetId).getCurrentStep()",
        "description": "Gets the current step of this stepper container.",
        "category": "Custom stateless actions"
      },
      {
        "name": "getStepCount",
        "usage": "$c(targetId).getStepCount()",
        "description": "Gets the number of steps of this stepper container.",
        "category": "Custom stateless actions"
      },
      {
        "name": "getComponentAt",
        "usage": "$c(targetId).getComponentAt(step)",
        "description": "Gets the component at the given step.",
        "category": "Custom stateless actions"
      },
      {
        "name": "getCurrentComponent",
        "usage": "$c(targetId).getCurrentComponent()",
        "description": "Gets the component at the current step.",
        "category": "Custom stateless actions"
      }
    ],
    "ReferenceView": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      },
      {
        "name": "getReference",
        "usage": "$c(targetId).getReference()",
        "description": "Gets the referenced component id.",
        "category": "Custom stateless actions"
      }
    ],
    "SplitView": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      }
    ],
    "CardView": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      }
    ],
    "IteratorView": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      },
      {
        "name": "getCurrentPage",
        "usage": "$c(targetId).getCurrentPage()",
        "description": "Returns the 1-indexed current page number of this paginated component data.",
        "category": "Custom stateless actions"
      },
      {
        "name": "getPageCount",
        "usage": "$c(targetId).getPageCount()",
        "description": "Returns the number of pages of this paginated component data (equals to data length divided by the number of items per page).",
        "category": "Custom stateless actions"
      },
      {
        "name": "getItemsPerPage",
        "usage": "$c(targetId).getItemsPerPage()",
        "description": "Returns the number of items per page (most of the time as given by the <code>perPage</code> component property).",
        "category": "Custom stateless actions"
      },
      {
        "name": "getPageFirstIndex",
        "usage": "$c(targetId).getPageFirstIndex([page])",
        "description": "Gets the first item index of the given <code>page</code>. If <code>page</code> is undefined, returns the first item index of the current page.",
        "category": "Custom stateless actions"
      },
      {
        "name": "getPageLastIndex",
        "usage": "$c(targetId).getPageLastIndex([page])",
        "description": "Gets the last item index of the given <code>page</code>. If <code>page</code> is undefined, returns the last item index of the current page.",
        "category": "Custom stateless actions"
      },
      {
        "name": "getCurrentStep",
        "usage": "$c(targetId).getCurrentStep()",
        "description": "Gets the current step of this stepper container.",
        "category": "Custom stateless actions"
      },
      {
        "name": "getStepCount",
        "usage": "$c(targetId).getStepCount()",
        "description": "Gets the number of steps of this stepper container.",
        "category": "Custom stateless actions"
      },
      {
        "name": "getComponentAt",
        "usage": "$c(targetId).getComponentAt(step)",
        "description": "Gets the component at the given step.",
        "category": "Custom stateless actions"
      },
      {
        "name": "getCurrentComponent",
        "usage": "$c(targetId).getCurrentComponent()",
        "description": "Gets the component at the current step.",
        "category": "Custom stateless actions"
      }
    ],
    "TabsView": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      },
      {
        "name": "getTabIndex",
        "usage": "$c(targetId).getTabIndex()",
        "category": "Custom stateless actions"
      }
    ],
    "CollapseView": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      },
      {
        "name": "isCollapsed",
        "usage": "$c(targetId).isCollapsed()",
        "category": "Custom stateless actions"
      }
    ],
    "DialogView": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      }
    ],
    "TableView": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      },
      {
        "name": "isRowSelected",
        "usage": "$c(targetId).isRowSelected(rowIndex)",
        "description": "Returns true if the given row is selected.",
        "category": "Custom stateless actions"
      },
      {
        "name": "getFilteredItems",
        "usage": "$c(targetId).getFilteredItems()",
        "description": "Gets the items as filtered by the filtering criteria if any.",
        "category": "Custom stateless actions"
      },
      {
        "name": "getCurrentPage",
        "usage": "$c(targetId).getCurrentPage()",
        "description": "Returns the 1-indexed current page number of this paginated component data.",
        "category": "Custom stateless actions"
      },
      {
        "name": "getPageCount",
        "usage": "$c(targetId).getPageCount()",
        "description": "Returns the number of pages of this paginated component data (equals to data length divided by the number of items per page).",
        "category": "Custom stateless actions"
      },
      {
        "name": "getItemsPerPage",
        "usage": "$c(targetId).getItemsPerPage()",
        "description": "Returns the number of items per page (most of the time as given by the <code>perPage</code> component property).",
        "category": "Custom stateless actions"
      },
      {
        "name": "getPageFirstIndex",
        "usage": "$c(targetId).getPageFirstIndex([page])",
        "description": "Gets the first item index of the given <code>page</code>. If <code>page</code> is undefined, returns the first item index of the current page.",
        "category": "Custom stateless actions"
      },
      {
        "name": "getPageLastIndex",
        "usage": "$c(targetId).getPageLastIndex([page])",
        "description": "Gets the last item index of the given <code>page</code>. If <code>page</code> is undefined, returns the last item index of the current page.",
        "category": "Custom stateless actions"
      },
      {
        "name": "getSelectedItem",
        "usage": "$c(targetId).getSelectedItem()",
        "description": "Returns the currently selected item.",
        "category": "Custom stateless actions"
      },
      {
        "name": "getSelectedItems",
        "usage": "$c(targetId).getSelectedItems()",
        "description": "Returns the currently selected item(s) as an array.",
        "category": "Custom stateless actions"
      }
    ],
    "ChartView": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      }
    ],
    "TimeSeriesChartView": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      }
    ],
    "TagsView": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      },
      {
        "name": "isValid",
        "usage": "$c(targetId).isValid()",
        "description": "True is this input data is valid.",
        "category": "Custom stateless actions"
      }
    ],
    "PopoverView": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      }
    ],
    "DatepickerView": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      },
      {
        "name": "isValid",
        "usage": "$c(targetId).isValid()",
        "description": "True is this input data is valid.",
        "category": "Custom stateless actions"
      }
    ],
    "TimepickerView": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      },
      {
        "name": "isValid",
        "usage": "$c(targetId).isValid()",
        "description": "True is this input data is valid.",
        "category": "Custom stateless actions"
      }
    ],
    "PaginationView": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      },
      {
        "name": "getCurrentPage",
        "usage": "$c(targetId).getCurrentPage()",
        "description": "Returns the 1-indexed current page number of this paginated component data.",
        "category": "Custom stateless actions"
      },
      {
        "name": "getPageCount",
        "usage": "$c(targetId).getPageCount()",
        "description": "Returns the number of pages of this paginated component data (equals to data length divided by the number of items per page).",
        "category": "Custom stateless actions"
      },
      {
        "name": "getItemsPerPage",
        "usage": "$c(targetId).getItemsPerPage()",
        "description": "Returns the number of items per page (most of the time as given by the <code>perPage</code> component property).",
        "category": "Custom stateless actions"
      },
      {
        "name": "getPageFirstIndex",
        "usage": "$c(targetId).getPageFirstIndex([page])",
        "description": "Gets the first item index of the given <code>page</code>. If <code>page</code> is undefined, returns the first item index of the current page.",
        "category": "Custom stateless actions"
      },
      {
        "name": "getPageLastIndex",
        "usage": "$c(targetId).getPageLastIndex([page])",
        "description": "Gets the last item index of the given <code>page</code>. If <code>page</code> is undefined, returns the last item index of the current page.",
        "category": "Custom stateless actions"
      }
    ],
    "AvatarView": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      }
    ],
    "EmbedView": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      }
    ],
    "MapView": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      },
      {
        "name": "getMarkerBounds",
        "usage": "$c(targetId).getMarkerBounds()",
        "description": "Gets a bounds object that contains all the markers of this map. Note that it returns a leaflet object instance of <code>L.LatLngBounds</code>.",
        "category": "Custom stateless actions"
      },
      {
        "name": "getBounds",
        "usage": "$c(targetId).getBounds(...geolocatedObject)",
        "description": "Gets a bounds object that contains all the given latitude/longitude objects/arrays. Note that it returns a leaflet object instance of <code>L.LatLngBounds</code>.",
        "category": "Custom stateless actions"
      },
      {
        "name": "toLatLng",
        "usage": "$c(targetId).toLatLng(geolocatedObject)",
        "description": "Maps an object to a standard lat/lng array. The geolocated object can be any object containing geolocation fields, or directly a lat/lng object/array.",
        "category": "Custom stateless actions"
      }
    ],
    "CarouselView": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      },
      {
        "name": "getIndex",
        "usage": "$c(targetId).getIndex()",
        "description": "Return the current slide index",
        "category": "Custom stateless actions"
      },
      {
        "name": "isPaused",
        "usage": "$c(targetId).isPaused()",
        "description": "True if the slide show is paused",
        "category": "Custom stateless actions"
      }
    ],
    "ProgressView": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      },
      {
        "name": "isValid",
        "usage": "$c(targetId).isValid()",
        "description": "True is this input data is valid.",
        "category": "Custom stateless actions"
      }
    ],
    "NavbarView": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      },
      {
        "name": "currentPage",
        "usage": "$c(targetId).currentPage()",
        "description": "Gets the current page object. Use <code>currentPage().pageId</code> to get the page ID.",
        "category": "Custom stateless actions"
      },
      {
        "name": "currentPageIndex",
        "usage": "$c(targetId).currentPageIndex()",
        "description": "Gets the current page index.",
        "category": "Custom stateless actions"
      },
      {
        "name": "currentRoute",
        "usage": "$c(targetId).currentRoute()",
        "description": "Gets the current route object.",
        "category": "Custom stateless actions"
      },
      {
        "name": "queryParam",
        "usage": "$c(targetId).queryParam(param)",
        "description": "Gets the value of a query param in the current route.",
        "category": "Custom stateless actions"
      },
      {
        "name": "getCurrentLocaleAsLabel",
        "usage": "$c(targetId).getCurrentLocaleAsLabel()",
        "description": "Returns a label for the current locale.",
        "category": "Custom stateless actions"
      },
      {
        "name": "getSupportedLocales",
        "usage": "$c(targetId).getSupportedLocales()",
        "description": "Returns all the localed defined in i18n (all the entries).",
        "category": "Custom stateless actions"
      }
    ],
    "PdfView": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      }
    ],
    "CameraView": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      }
    ],
    "SidebarView": [
      {
        "name": "isVisible",
        "usage": "$c(targetId).isVisible()",
        "description": "Tells if this component is currently visible"
      },
      {
        "name": "getElement",
        "usage": "$c(targetId).getElement()",
        "description": "Gets the HTML DOM element corresponding to this component"
      },
      {
        "name": "getIteratorIndex",
        "usage": "$c(targetId).getIteratorIndex()",
        "description": "Gets the iterator index of this component, if it is placed in an iterator"
      },
      {
        "name": "getIteratorContext",
        "usage": "$c(targetId).getIteratorContext()",
        "description": "Gets the iterator context of this component, if it is placed in an iterator"
      },
      {
        "name": "findChildren",
        "usage": "$c(targetId).findChildren(matcher)",
        "description": "Recursively finds all the sub-components within this component, that match the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "findParent",
        "usage": "$c(targetId).findParent([matcher])",
        "description": "Finds the first parent that matches the given <code>matcher</code>. The <code>matcher</code> is either a function taking the view model to be matched as a parameter, either a string with the component type name (for instance <code>\"ButtonView\"</code> to find all the buttons)"
      },
      {
        "name": "getChildren",
        "usage": "$c(targetId).getChildren()",
        "description": "Gets all the sub-components within this component, recursively"
      },
      {
        "name": "getParent",
        "usage": "$c(targetId).getParent()",
        "description": "Gets the parent component of this component"
      },
      {
        "name": "previous",
        "usage": "$c(targetId).previous()",
        "description": "Gets the previous component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "next",
        "usage": "$c(targetId).next()",
        "description": "Gets the next component (sibling) of this component if any. Only works if the current component is placed in a container"
      },
      {
        "name": "containsData",
        "usage": "$c(targetId).containsData(data)",
        "description": "Returns true if the component data model contains the given data. Data comparison is performed against the <code>id</code> field of the data, or by reference if the <code>id</code> field is undefined",
        "category": "Array stateless actions"
      }
    ]
  }
}