An action is a global operation which you can add to the plus sign in the upper right corner or any custom component added to the header.

Factory to implement if used in a hook for Multi Provider extension.

An extension HOOK can use either a pure value:

 { provide: HOOK_X, useValue: { ...hookValue }, multi: true }

Or an array to directly register multiple:

 { provide: HOOK_X, useValue: [{ ...hookValues }], multi: true }

Or an ExtensionFactory which allows to define a get() function. This function gets called on each navigation with the current route and can return values async (observable or promise).

 { provide: HOOK_X, useFactory: { get: (route) => doSomethingAsync(route) }, multi: true }

Factory to implement if used in a hook for Multi Provider extension.

An action bar item is a action in scope of a current route of the application.

Factory to implement in order to add action controls from an extension.

Custom column type. Either declared by an explicit path (legacy) or with the asset property library of DTM

A filter predicate function.

Represents a partial filter chip with required properties 'displayValue' and 'value'.

Represents a partial filter chip with either 'columnName' and 'externalFilterQuery' or 'columnName' and 'filterPredicate'.

A callback function to fetch server data.

Describes a result from server with data and additional statistics.

Sorting order: ascending, descending, or not specified.

An extension HOOK can use either a pure value:

 { provide: HOOK_X, useValue: { ...hookValue }, multi: true }

Or an array to directly register multiple:

 { provide: HOOK_X, useValue: [{ ...hookValues }], multi: true }

Or an ExtensionFactory which allows to define a get() function. This function gets called on each navigation with the current route and can return values async (observable or promise).

 { provide: HOOK_X, useFactory: { get: (route) => doSomethingAsync(route) }, multi: true }

Represents the available aggregation options. Aggregation 'none' is not handled by our backend.

Represents the status of aggregation options. Used to determine which aggregation options should be disabled.

Represents the navigation options for an alarm component.

The configuration for the alarms-events selector modal if some properties should be omitted.

Object representing state of dashboard widgets. Its main purpose is to allow to undo and redo changes applied to dashboard children.

Asset paths.

An extension HOOK can use either a pure value:

 { provide: HOOK_X, useValue: { ...hookValue }, multi: true }

Or an array to directly register multiple:

 { provide: HOOK_X, useValue: [{ ...hookValues }], multi: true }

Or an ExtensionFactory which allows to define a get() function. This function gets called on each navigation with the current route and can return values async (observable or promise).

 { provide: HOOK_X, useFactory: { get: (route) => doSomethingAsync(route) }, multi: true }

Factory to implement if used in a hook for Multi Provider extension.

A crumb of the breadcrumb.

Leaflet marker extended with either asset or event information.

Type representing the attribute keys for a Cumulocity marker.

Configuration for the cluster map, including center and refresh interval.

General map configuration, including options for following, real-time, icon, color, zoom, pan, and bounds.

Configuration for the status buttons shown on the map UI.

Represents a merged export column header, e.g. 'Temperature - 5 -> c8y_Temperature.T [ºC] (max)'

Represents a mapping of column headers and their corresponding values. e.g. 'Temperature - 5 -> c8y_Temperature.T [ºC] (max)': 25

Represents a mapping of datapoints series values. The key of the map is a source, and the value is the value data from requested series.

Represents the details unique for a merged file.

Represents the min and max values for a specific timestamp. Both min and max values are available only when using series API.

Represents a map of datapoints series data. The key of the map is a source, and the value is the data for requested series.

Represents a mapping where the key is a datapoint identifier containing the date and device name, and the value is an array of data point table items or null.

Represents an object where key is a timestamp and value is an array where first record contains min and max values for a corresponding timestamp.

Determines which values will be displayed as values for datapoints. e.g. if user chose 'min', only the minimum values will be displayed.

Represents a value object where key is an object with min and max properties with its corresponding values.

Input query params is an object representing all possible query params related to widget time context. It can be provided by user typing them in browser URL address bar, so all of them should be considered.

Output query params is an object representing params that are applied to current URL in browser address bar. These params are set programmatically. Time context interval and time range described by date "from" and date "to" exclude each other.

Type for describing widget change events. It's possible to extend this by adding additional events to discriminated union type.

A link on the right drawer.

An extension HOOK can use either a pure value:

 { provide: HOOK_X, useValue: { ...hookValue }, multi: true }

Or an array to directly register multiple:

 { provide: HOOK_X, useValue: [{ ...hookValues }], multi: true }

Or an ExtensionFactory which allows to define a get() function. This function gets called on each navigation with the current route and can return values async (observable or promise).

 { provide: HOOK_X, useFactory: { get: (route) => doSomethingAsync(route) }, multi: true }

A dynamic component can be defined in a the HOOK_COMPONENTS to display any kind of component dynamically just by referencing it's id. The most common use case is on dashboards, where the configComponent is used to define what is displayed on the component on the dashboard.

To use the component you can use the c8y-dynamic-component.

  <c8y-dynamic-component
    componentId="angular.widget.demo"
    [config]="{ text: 'Hello world' }"
    [mode]="editComponent ? 'config' : 'component'"
  ></c8y-dynamic-component>

An extension HOOK can use either a pure value:

 { provide: HOOK_X, useValue: { ...hookValue }, multi: true }

Or an array to directly register multiple:

 { provide: HOOK_X, useValue: [{ ...hookValues }], multi: true }

Or an ExtensionFactory which allows to define a get() function. This function gets called on each navigation with the current route and can return values async (observable or promise).

 { provide: HOOK_X, useFactory: { get: (route) => doSomethingAsync(route) }, multi: true }

Configuration with exported asset information

Configuration with imported asset information

Configuration type with target objects prepared for export

Represents a target-based object with export information

Configuration type with target objects prepared for import

Represents a target-based object with import information

Helper type to identify arrays of objects with __target property

Transforms a type to replace arrays of objects with __target property to ExportedTargetObject[]

Transforms a type to replace arrays of objects with __target property to ImportedTargetObject[]

An extension HOOK can use either a pure value:

 { provide: HOOK_X, useValue: { ...hookValue }, multi: true }

Or an array to directly register multiple:

 { provide: HOOK_X, useValue: [{ ...hookValues }], multi: true }

• Or a class to register:

 { provide: HOOK_X, useExisting: BooleanFilterMapper, multi: true }

Or an ExtensionFactory ExtensionFactory:

 { provide: HOOK_X, useFactory: (route) => doSomethingAsync(route), multi: true }

Helper type for form group configuration based on a given entity interface. Ensures that model changes will be detected at compile time avoiding runtime errors and possible data loss.

Defines the various options to define if a given part from the data grid configuration will be omited when configuration is persisted. A truthy or missing value means that the given configuration part will be persisted. A falsy value means that the configuration part will not be persisted.

Defines the various types of configuration options for data grid component.

Defines the various types of configuration change events the data grid component can emit.

Can be used to mark a step as completed and adds the current index to the step.

The mode for components using infinite scroll:

• auto: Tries to automatically load more data;
• show: Shows a load more button for the user to decide;
• none: Doesn't perform any load more action;
• hidden: Loads more data automatically but with no visible button for the user.

Filters for subscribers list.

Data necessary for deleting a subscriber.

Filters for topics list.

Filters for topics list.

An extension HOOK can use either a pure value:

 { provide: HOOK_X, useValue: { ...hookValue }, multi: true }

Or an array to directly register multiple:

 { provide: HOOK_X, useValue: [{ ...hookValues }], multi: true }

Or an ExtensionFactory which allows to define a get() function. This function gets called on each navigation with the current route and can return values async (observable or promise).

 { provide: HOOK_X, useFactory: { get: (route) => doSomethingAsync(route) }, multi: true }

Factory enabling extension of the navigator menu through the HOOK_NAVIGATOR_NODES hook. Refer to Libraries > Component library > Extension points in our Web SDK guide.

export class ExampleNavigatorFactory implements NavigatorNodeFactory {
  get() {
    const navs: NavigatorNode[] = [];
    navs.push(
      new NavigatorNode({
        label: 'Hello',
        icon: 'rocket',
        path: '/hello',
        priority: 100
      })
    );
    return navs;
  }
}

Paging query parameters.

Pagination statistics.

The list of partial application objects.

An extension HOOK can use either a pure value:

 { provide: HOOK_X, useValue: { ...hookValue }, multi: true }

Or an array to directly register multiple:

 { provide: HOOK_X, useValue: [{ ...hookValues }], multi: true }

Or an ExtensionFactory which allows to define a get() function. This function gets called on each navigation with the current route and can return values async (observable or promise).

 { provide: HOOK_X, useFactory: { get: (route) => doSomethingAsync(route) }, multi: true }

Factory to implement if used in a hook for Multi Provider extension.

A route that can be added via the HOOK_ROUTE.

A ViewContext base route.

An extension HOOK can use either a pure value:

 { provide: HOOK_X, useValue: { ...hookValue }, multi: true }

Or an array to directly register multiple:

 { provide: HOOK_X, useValue: [{ ...hookValues }], multi: true }

Or an ExtensionFactory which allows to define a get() function. This function gets called on each navigation with the current route and can return values async (observable or promise).

 { provide: HOOK_X, useFactory: { get: (route) => doSomethingAsync(route) }, multi: true }

Factory to implement if used in a hook for Multi Provider extension.

Sorting query parameters.

An extension HOOK can use either a pure value:

 { provide: HOOK_X, useValue: { ...hookValue }, multi: true }

Or an array to directly register multiple:

 { provide: HOOK_X, useValue: [{ ...hookValues }], multi: true }

Or an ExtensionFactory which allows to define a get() function. This function gets called on each navigation with the current route and can return values async (observable or promise).

 { provide: HOOK_X, useFactory: { get: (route) => doSomethingAsync(route) }, multi: true }

An tab allows to switch routes on a page or provide an additional component.

If used for switching route, the router link can be provided as string or any[], as supported in the routerLink directive.

Factory to implement if used in a hook for Multi Provider extension.

Type alias for tab orientation.

An extension HOOK can use either a pure value:

 { provide: HOOK_X, useValue: { ...hookValue }, multi: true }

Or an array to directly register multiple:

 { provide: HOOK_X, useValue: [{ ...hookValues }], multi: true }

Or an ExtensionFactory which allows to define a get() function. This function gets called on each navigation with the current route and can return values async (observable or promise).

 { provide: HOOK_X, useFactory: { get: (route) => doSomethingAsync(route) }, multi: true }

An extension HOOK can use either a pure value:

 { provide: HOOK_X, useValue: { ...hookValue }, multi: true }

Or an array to directly register multiple:

 { provide: HOOK_X, useValue: [{ ...hookValue1 }, { ...hookValue2 }], multi: true }

Or an ExtensionFactory which allows to define a get() function. This function gets called on each navigation with the current route and can return values async (observable or promise).

 { provide: HOOK_X, useFactory: { get: (route) => doSomethingAsync(route) }, multi: true }