diff --git a/docs/node-observ-lib/README.md b/docs/node-observ-lib/README.md new file mode 100644 index 0000000000..c190efc39d --- /dev/null +++ b/docs/node-observ-lib/README.md @@ -0,0 +1,163 @@ +# Node exporter observability lib + +This jsonnet observability lib can be used to generate observability package for node exporter. + +## Import + +```sh +jb init +jb install https://github.com/grafana/node_exporter/docs/node-observ-lib +``` + +## Examples + +### Example 1: Basic example + +You can use observ-lib to fill in monitoring-mixin structure: + +```jsonnet +// mixin.libsonnet file +local nodelib = import 'node-observ-lib/main.libsonnet'; + +local linux = + nodelib.new() + + nodelib.withConfigMixin({ + filteringSelector: 'job=~".*node.*"', + groupLabels: ['job'], + instanceLabels: ['instance'], + dashboardNamePrefix: 'Node exporter / ', + dashboardTags: ['node-exporter-mixin'], + uid: 'node', + // enable loki logs + enableLokiLogs: true, + }); + +{ + grafanaDashboards+:: linux.grafana.dashboards, + prometheusAlerts+:: linux.prometheus.alerts, + prometheusRules+:: linux.prometheus.recordingRules, +} + +``` + +### Example 2: Fill in monitoring-mixin with default config values and enable loki logs: + + +```jsonnet +// mixin.libsonnet file +local nodelib = import 'node-observ-lib/main.libsonnet'; + +local linux = + nodelib.new() + + nodelib.withConfigMixin({ + enableLokiLogs: true, + }); + +{ + grafanaDashboards+:: linux.grafana.dashboards, + prometheusAlerts+:: linux.prometheus.alerts, + prometheusRules+:: linux.prometheus.recordingRules, +} + +``` + +### Example 3: Override some of default config values from file: + + +```jsonnet +// overrides.libsonnet +{ + // Memory utilzation (%) level on which to trigger the + // 'NodeMemoryHighUtilization' alert. + memoryHighUtilizationThreshold: 80, + + // Threshold for the rate of memory major page faults to trigger + // 'NodeMemoryMajorPagesFaults' alert. + memoryMajorPagesFaultsThreshold: 1000, + + // Disk IO queue level above which to trigger + // 'NodeDiskIOSaturation' alert. + diskIOSaturationThreshold: 20, +} + +// mixin.libsonnet file +local configOverride = import './overrides.libsonnet'; +local nodelib = import 'node-observ-lib/main.libsonnet'; + +local linux = + nodelib.new() + + nodelib.withConfigMixin(configOverride); + +{ + grafanaDashboards+:: linux.grafana.dashboards, + prometheusAlerts+:: linux.prometheus.alerts, + prometheusRules+:: linux.prometheus.recordingRules, +} + +``` + +### Example 4: Modify specific panel before rendering dashboards + +```jsonnet +local g = import './g.libsonnet'; +// mixin.libsonnet file +local nodelib = import 'node-observ-lib/main.libsonnet'; + +local linux = + nodelib.new() + + nodelib.withConfigMixin({ + filteringSelector: 'job=~".*node.*"', + groupLabels: ['job'], + instanceLabels: ['instance'], + dashboardNamePrefix: 'Node exporter / ', + dashboardTags: ['node-exporter-mixin'], + uid: 'node', + }) + + { + grafana+: { + panels+: { + networkSockstatAll+: + + g.panel.timeSeries.fieldConfig.defaults.custom.withDrawStyle('bars') + } + } + }; + +{ + grafanaDashboards+:: linux.grafana.dashboards, + prometheusAlerts+:: linux.prometheus.alerts, + prometheusRules+:: linux.prometheus.recordingRules, +} + +``` + +## Collectors used: + +Grafana Agent or combination of node_exporter/promtail can be used in order to collect data required. + +### Logs collection + +Loki logs are used to populate logs dashboard and also for annotations. + +To use logs, you need to opt-in, with setting `enableLokiLogs: true` in config. + +See example above. + +The following scrape snippet can be used in grafana-agent/promtail: + +```yaml + - job_name: integrations/node_exporter_journal_scrape + journal: + max_age: 24h + labels: + instance: '' + job: integrations/node_exporter + relabel_configs: + - source_labels: ['__journal__systemd_unit'] + target_label: 'unit' + - source_labels: ['__journal__boot_id'] + target_label: 'boot_id' + - source_labels: ['__journal__transport'] + target_label: 'transport' + - source_labels: ['__journal_priority_keyword'] + target_label: 'level' +``` diff --git a/docs/node-observ-lib/alerts.libsonnet b/docs/node-observ-lib/alerts.libsonnet new file mode 100644 index 0000000000..0ba8e2fbcd --- /dev/null +++ b/docs/node-observ-lib/alerts.libsonnet @@ -0,0 +1,420 @@ +{ + new(this): { + groups: [ + { + name: if this.config.uid == 'node' then 'node-exporter-filesystem' else this.config.uid + '-linux-filesystem-alerts', + rules: [ + { + alert: 'NodeFilesystemSpaceFillingUp', + expr: ||| + ( + node_filesystem_avail_bytes{%(filteringSelector)s,%(fsSelector)s,%(fsMountpointSelector)s} / node_filesystem_size_bytes{%(filteringSelector)s,%(fsSelector)s,%(fsMountpointSelector)s} * 100 < %(fsSpaceFillingUpWarningThreshold)d + and + predict_linear(node_filesystem_avail_bytes{%(filteringSelector)s,%(fsSelector)s,%(fsMountpointSelector)s}[6h], 24*60*60) < 0 + and + node_filesystem_readonly{%(filteringSelector)s,%(fsSelector)s,%(fsMountpointSelector)s} == 0 + ) + ||| % this.config, + 'for': '1h', + labels: { + severity: 'warning', + }, + annotations: { + summary: 'Filesystem is predicted to run out of space within the next 24 hours.', + description: 'Filesystem on {{ $labels.device }}, mounted on {{ $labels.mountpoint }}, at {{ $labels.instance }} has only {{ printf "%.2f" $value }}% available space left and is filling up.', + }, + }, + { + alert: 'NodeFilesystemSpaceFillingUp', + expr: ||| + ( + node_filesystem_avail_bytes{%(filteringSelector)s,%(fsSelector)s,%(fsMountpointSelector)s} / node_filesystem_size_bytes{%(filteringSelector)s,%(fsSelector)s,%(fsMountpointSelector)s} * 100 < %(fsSpaceFillingUpCriticalThreshold)d + and + predict_linear(node_filesystem_avail_bytes{%(filteringSelector)s,%(fsSelector)s,%(fsMountpointSelector)s}[6h], 4*60*60) < 0 + and + node_filesystem_readonly{%(filteringSelector)s,%(fsSelector)s,%(fsMountpointSelector)s} == 0 + ) + ||| % this.config, + 'for': '1h', + labels: { + severity: '%(nodeCriticalSeverity)s' % this.config, + }, + annotations: { + summary: 'Filesystem is predicted to run out of space within the next 4 hours.', + description: 'Filesystem on {{ $labels.device }}, mounted on {{ $labels.mountpoint }}, at {{ $labels.instance }} has only {{ printf "%.2f" $value }}% available space left and is filling up fast.', + }, + }, + { + alert: 'NodeFilesystemAlmostOutOfSpace', + expr: ||| + ( + node_filesystem_avail_bytes{%(filteringSelector)s,%(fsSelector)s,%(fsMountpointSelector)s} / node_filesystem_size_bytes{%(filteringSelector)s,%(fsSelector)s,%(fsMountpointSelector)s} * 100 < %(fsSpaceAvailableWarningThreshold)d + and + node_filesystem_readonly{%(filteringSelector)s,%(fsSelector)s,%(fsMountpointSelector)s} == 0 + ) + ||| % this.config, + 'for': '30m', + labels: { + severity: 'warning', + }, + annotations: { + summary: 'Filesystem has less than %(fsSpaceAvailableWarningThreshold)d%% space left.' % this.config, + description: 'Filesystem on {{ $labels.device }}, mounted on {{ $labels.mountpoint }}, at {{ $labels.instance }} has only {{ printf "%.2f" $value }}% available space left.', + }, + }, + { + alert: 'NodeFilesystemAlmostOutOfSpace', + expr: ||| + ( + node_filesystem_avail_bytes{%(filteringSelector)s,%(fsSelector)s,%(fsMountpointSelector)s} / node_filesystem_size_bytes{%(filteringSelector)s,%(fsSelector)s,%(fsMountpointSelector)s} * 100 < %(fsSpaceAvailableCriticalThreshold)d + and + node_filesystem_readonly{%(filteringSelector)s,%(fsSelector)s,%(fsMountpointSelector)s} == 0 + ) + ||| % this.config, + 'for': '30m', + labels: { + severity: '%(nodeCriticalSeverity)s' % this.config, + }, + annotations: { + summary: 'Filesystem has less than %(fsSpaceAvailableCriticalThreshold)d%% space left.' % this.config, + description: 'Filesystem on {{ $labels.device }}, mounted on {{ $labels.mountpoint }}, at {{ $labels.instance }} has only {{ printf "%.2f" $value }}% available space left.', + }, + }, + { + alert: 'NodeFilesystemFilesFillingUp', + expr: ||| + ( + node_filesystem_files_free{%(filteringSelector)s,%(fsSelector)s,%(fsMountpointSelector)s} / node_filesystem_files{%(filteringSelector)s,%(fsSelector)s,%(fsMountpointSelector)s} * 100 < 40 + and + predict_linear(node_filesystem_files_free{%(filteringSelector)s,%(fsSelector)s,%(fsMountpointSelector)s}[6h], 24*60*60) < 0 + and + node_filesystem_readonly{%(filteringSelector)s,%(fsSelector)s,%(fsMountpointSelector)s} == 0 + ) + ||| % this.config, + 'for': '1h', + labels: { + severity: 'warning', + }, + annotations: { + summary: 'Filesystem is predicted to run out of inodes within the next 24 hours.', + description: 'Filesystem on {{ $labels.device }}, mounted on {{ $labels.mountpoint }}, at {{ $labels.instance }} has only {{ printf "%.2f" $value }}% available inodes left and is filling up.', + }, + }, + { + alert: 'NodeFilesystemFilesFillingUp', + expr: ||| + ( + node_filesystem_files_free{%(filteringSelector)s,%(fsSelector)s,%(fsMountpointSelector)s} / node_filesystem_files{%(filteringSelector)s,%(fsSelector)s,%(fsMountpointSelector)s} * 100 < 20 + and + predict_linear(node_filesystem_files_free{%(filteringSelector)s,%(fsSelector)s,%(fsMountpointSelector)s}[6h], 4*60*60) < 0 + and + node_filesystem_readonly{%(filteringSelector)s,%(fsSelector)s,%(fsMountpointSelector)s} == 0 + ) + ||| % this.config, + 'for': '1h', + labels: { + severity: '%(nodeCriticalSeverity)s' % this.config, + }, + annotations: { + summary: 'Filesystem is predicted to run out of inodes within the next 4 hours.', + description: 'Filesystem on {{ $labels.device }}, mounted on {{ $labels.mountpoint }}, at {{ $labels.instance }} has only {{ printf "%.2f" $value }}% available inodes left and is filling up fast.', + }, + }, + { + alert: 'NodeFilesystemAlmostOutOfFiles', + expr: ||| + ( + node_filesystem_files_free{%(filteringSelector)s,%(fsSelector)s,%(fsMountpointSelector)s} / node_filesystem_files{%(filteringSelector)s,%(fsSelector)s,%(fsMountpointSelector)s} * 100 < 5 + and + node_filesystem_readonly{%(filteringSelector)s,%(fsSelector)s,%(fsMountpointSelector)s} == 0 + ) + ||| % this.config, + 'for': '1h', + labels: { + severity: 'warning', + }, + annotations: { + summary: 'Filesystem has less than 5% inodes left.', + description: 'Filesystem on {{ $labels.device }}, mounted on {{ $labels.mountpoint }}, at {{ $labels.instance }} has only {{ printf "%.2f" $value }}% available inodes left.', + }, + }, + { + alert: 'NodeFilesystemAlmostOutOfFiles', + expr: ||| + ( + node_filesystem_files_free{%(filteringSelector)s,%(fsSelector)s,%(fsMountpointSelector)s} / node_filesystem_files{%(filteringSelector)s,%(fsSelector)s,%(fsMountpointSelector)s} * 100 < 3 + and + node_filesystem_readonly{%(filteringSelector)s,%(fsSelector)s,%(fsMountpointSelector)s} == 0 + ) + ||| % this.config, + 'for': '1h', + labels: { + severity: '%(nodeCriticalSeverity)s' % this.config, + }, + annotations: { + summary: 'Filesystem has less than 3% inodes left.', + description: 'Filesystem on {{ $labels.device }}, mounted on {{ $labels.mountpoint }}, at {{ $labels.instance }} has only {{ printf "%.2f" $value }}% available inodes left.', + }, + }, + ], + }, + { + // defaults to 'node-exporter for backward compatibility with old node-mixin + name: if this.config.uid == 'node' then 'node-exporter' else this.config.uid + '-linux-alerts', + rules: [ + { + alert: 'NodeNetworkReceiveErrs', + expr: ||| + rate(node_network_receive_errs_total{%(filteringSelector)s}[2m]) / rate(node_network_receive_packets_total{%(filteringSelector)s}[2m]) > 0.01 + ||| % this.config, + 'for': '1h', + labels: { + severity: 'warning', + }, + annotations: { + summary: 'Network interface is reporting many receive errors.', + description: '{{ $labels.instance }} interface {{ $labels.device }} has encountered {{ printf "%.0f" $value }} receive errors in the last two minutes.', + }, + }, + { + alert: 'NodeNetworkTransmitErrs', + expr: ||| + rate(node_network_transmit_errs_total{%(filteringSelector)s}[2m]) / rate(node_network_transmit_packets_total{%(filteringSelector)s}[2m]) > 0.01 + ||| % this.config, + 'for': '1h', + labels: { + severity: 'warning', + }, + annotations: { + summary: 'Network interface is reporting many transmit errors.', + description: '{{ $labels.instance }} interface {{ $labels.device }} has encountered {{ printf "%.0f" $value }} transmit errors in the last two minutes.', + }, + }, + { + alert: 'NodeHighNumberConntrackEntriesUsed', + expr: ||| + (node_nf_conntrack_entries{%(filteringSelector)s} / node_nf_conntrack_entries_limit) > 0.75 + ||| % this.config, + annotations: { + summary: 'Number of conntrack are getting close to the limit.', + description: '{{ $value | humanizePercentage }} of conntrack entries are used.', + }, + labels: { + severity: 'warning', + }, + }, + { + alert: 'NodeTextFileCollectorScrapeError', + expr: ||| + node_textfile_scrape_error{%(filteringSelector)s} == 1 + ||| % this.config, + annotations: { + summary: 'Node Exporter text file collector failed to scrape.', + description: 'Node Exporter text file collector on {{ $labels.instance }} failed to scrape.', + }, + labels: { + severity: 'warning', + }, + }, + { + alert: 'NodeClockSkewDetected', + expr: ||| + ( + node_timex_offset_seconds{%(filteringSelector)s} > 0.05 + and + deriv(node_timex_offset_seconds{%(filteringSelector)s}[5m]) >= 0 + ) + or + ( + node_timex_offset_seconds{%(filteringSelector)s} < -0.05 + and + deriv(node_timex_offset_seconds{%(filteringSelector)s}[5m]) <= 0 + ) + ||| % this.config, + 'for': '10m', + labels: { + severity: 'warning', + }, + annotations: { + summary: 'Clock skew detected.', + description: 'Clock at {{ $labels.instance }} is out of sync by more than 0.05s. Ensure NTP is configured correctly on this host.', + }, + }, + { + alert: 'NodeClockNotSynchronising', + expr: ||| + min_over_time(node_timex_sync_status{%(filteringSelector)s}[5m]) == 0 + and + node_timex_maxerror_seconds{%(filteringSelector)s} >= 16 + ||| % this.config, + 'for': '10m', + labels: { + severity: 'warning', + }, + annotations: { + summary: 'Clock not synchronising.', + description: 'Clock at {{ $labels.instance }} is not synchronising. Ensure NTP is configured on this host.', + }, + }, + { + alert: 'NodeRAIDDegraded', + expr: ||| + node_md_disks_required{%(filteringSelector)s,%(diskDeviceSelector)s} - ignoring (state) (node_md_disks{state="active",%(filteringSelector)s,%(diskDeviceSelector)s}) > 0 + ||| % this.config, + 'for': '15m', + labels: { + severity: 'critical', + }, + annotations: { + summary: 'RAID Array is degraded.', + description: "RAID array '{{ $labels.device }}' at {{ $labels.instance }} is in degraded state due to one or more disks failures. Number of spare drives is insufficient to fix issue automatically.", + }, + }, + { + alert: 'NodeRAIDDiskFailure', + expr: ||| + node_md_disks{state="failed",%(filteringSelector)s,%(diskDeviceSelector)s} > 0 + ||| % this.config, + labels: { + severity: 'warning', + }, + annotations: { + summary: 'Failed device in RAID array.', + description: "At least one device in RAID array at {{ $labels.instance }} failed. Array '{{ $labels.device }}' needs attention and possibly a disk swap.", + }, + }, + { + alert: 'NodeFileDescriptorLimit', + expr: ||| + ( + node_filefd_allocated{%(filteringSelector)s} * 100 / node_filefd_maximum{%(filteringSelector)s} > 70 + ) + ||| % this.config, + 'for': '15m', + labels: { + severity: 'warning', + }, + annotations: { + summary: 'Kernel is predicted to exhaust file descriptors limit soon.', + description: 'File descriptors limit at {{ $labels.instance }} is currently at {{ printf "%.2f" $value }}%.', + }, + }, + { + alert: 'NodeFileDescriptorLimit', + expr: ||| + ( + node_filefd_allocated{%(filteringSelector)s} * 100 / node_filefd_maximum{%(filteringSelector)s} > 90 + ) + ||| % this.config, + 'for': '15m', + labels: { + severity: 'critical', + }, + annotations: { + summary: 'Kernel is predicted to exhaust file descriptors limit soon.', + description: 'File descriptors limit at {{ $labels.instance }} is currently at {{ printf "%.2f" $value }}%.', + }, + }, + { + alert: 'NodeCPUHighUsage', + expr: ||| + sum without(mode) (avg without (cpu) (rate(node_cpu_seconds_total{%(filteringSelector)s, mode!="idle"}[2m]))) * 100 > %(cpuHighUsageThreshold)d + ||| % this.config, + 'for': '15m', + labels: { + severity: 'info', + }, + annotations: { + summary: 'High CPU usage.', + description: ||| + CPU usage at {{ $labels.instance }} has been above %(cpuHighUsageThreshold)d%% for the last 15 minutes, is currently at {{ printf "%%.2f" $value }}%%. + ||| % this.config, + }, + }, + { + alert: 'NodeSystemSaturation', + expr: ||| + node_load1{%(filteringSelector)s} + / count without (cpu, mode) (node_cpu_seconds_total{%(filteringSelector)s, mode="idle"}) > %(systemSaturationPerCoreThreshold)d + ||| % this.config, + 'for': '15m', + labels: { + severity: 'warning', + }, + annotations: { + summary: 'System saturated, load per core is very high.', + description: ||| + System load per core at {{ $labels.instance }} has been above %(systemSaturationPerCoreThreshold)d for the last 15 minutes, is currently at {{ printf "%%.2f" $value }}. + This might indicate this instance resources saturation and can cause it becoming unresponsive. + ||| % this.config, + }, + }, + { + alert: 'NodeMemoryMajorPagesFaults', + expr: ||| + rate(node_vmstat_pgmajfault{%(filteringSelector)s}[5m]) > %(memoryMajorPagesFaultsThreshold)d + ||| % this.config, + 'for': '15m', + labels: { + severity: 'warning', + }, + annotations: { + summary: 'Memory major page faults are occurring at very high rate.', + description: ||| + Memory major pages are occurring at very high rate at {{ $labels.instance }}, %(memoryMajorPagesFaultsThreshold)d major page faults per second for the last 15 minutes, is currently at {{ printf "%%.2f" $value }}. + Please check that there is enough memory available at this instance. + ||| % this.config, + }, + }, + { + alert: 'NodeMemoryHighUtilization', + expr: ||| + 100 - (node_memory_MemAvailable_bytes{%(filteringSelector)s} / node_memory_MemTotal_bytes{%(filteringSelector)s} * 100) > %(memoryHighUtilizationThreshold)d + ||| % this.config, + 'for': '15m', + labels: { + severity: 'warning', + }, + annotations: { + summary: 'Host is running out of memory.', + description: ||| + Memory is filling up at {{ $labels.instance }}, has been above %(memoryHighUtilizationThreshold)d%% for the last 15 minutes, is currently at {{ printf "%%.2f" $value }}%%. + ||| % this.config, + }, + }, + { + alert: 'NodeDiskIOSaturation', + expr: ||| + rate(node_disk_io_time_weighted_seconds_total{%(filteringSelector)s, %(diskDeviceSelector)s}[5m]) > %(diskIOSaturationThreshold)d + ||| % this.config, + 'for': '30m', + labels: { + severity: 'warning', + }, + annotations: { + summary: 'Disk IO queue is high.', + description: ||| + Disk IO queue (aqu-sq) is high on {{ $labels.device }} at {{ $labels.instance }}, has been above %(diskIOSaturationThreshold)d for the last 15 minutes, is currently at {{ printf "%%.2f" $value }}. + This symptom might indicate disk saturation. + ||| % this.config, + }, + }, + { + alert: 'NodeSystemdServiceFailed', + expr: ||| + node_systemd_unit_state{%(filteringSelector)s, state="failed"} == 1 + ||| % this.config, + 'for': '5m', + labels: { + severity: 'warning', + }, + annotations: { + summary: 'Systemd service has entered failed state.', + description: 'Systemd service {{ $labels.name }} has entered failed state at {{ $labels.instance }}', + }, + }, + ], + }, + ], + }, +} diff --git a/docs/node-observ-lib/annotations.libsonnet b/docs/node-observ-lib/annotations.libsonnet new file mode 100644 index 0000000000..3d1f58b771 --- /dev/null +++ b/docs/node-observ-lib/annotations.libsonnet @@ -0,0 +1,69 @@ +local g = import './g.libsonnet'; +local commonlib = import 'common-lib/common/main.libsonnet'; +{ + new(this): + { + reboot: + commonlib.annotations.reboot.new( + title='Reboot', + target=this.grafana.targets.reboot, + instanceLabels=std.join(',', this.config.instanceLabels), + ) + + commonlib.annotations.base.withTagKeys(std.join(',', this.config.groupLabels + this.config.instanceLabels)), + memoryOOM: + commonlib.annotations.base.new( + 'OOMkill', + this.grafana.targets.memoryOOMkiller + ) + + commonlib.annotations.base.withTagKeys(std.join(',', this.config.groupLabels + this.config.instanceLabels)) + + commonlib.annotations.base.withTextFormat('') + { + hide: true, + iconColor: 'light-purple', + }, + kernelUpdate: + commonlib.annotations.base.new( + 'Kernel update', + this.grafana.targets.kernelUpdate + ) + + commonlib.annotations.base.withTagKeys(std.join(',', this.config.groupLabels + this.config.instanceLabels)) + + commonlib.annotations.base.withTextFormat('') + { + hide: true, + iconColor: 'light-blue', + step: '5m', + }, + } + + + if + this.config.enableLokiLogs + then + { + serviceFailed: commonlib.annotations.serviceFailed.new( + title='Service failed', + target=this.grafana.targets.serviceFailed, + ) + + commonlib.annotations.base.withTagKeys(std.join(',', this.config.groupLabels + this.config.instanceLabels + ['level'])), + criticalEvents: commonlib.annotations.fatal.new( + title='Critical system event', + target=this.grafana.targets.criticalEvents, + ) + + commonlib.annotations.base.withTagKeys(std.join(',', this.config.groupLabels + this.config.instanceLabels + ['level'])), + sessionOpened: + commonlib.annotations.base.new( + title='Session opened', + target=this.grafana.targets.sessionOpened, + ) + + commonlib.annotations.base.withTagKeys(std.join(',', this.config.groupLabels + this.config.instanceLabels + ['level'])) + { hide: true }, + sessionClosed: + commonlib.annotations.base.new( + title='Session closed', + target=this.grafana.targets.sessionOpened, + ) + + commonlib.annotations.base.withTagKeys(std.join(',', this.config.groupLabels + this.config.instanceLabels + ['level'])) + { hide: true }, + } + else + {}, +} diff --git a/docs/node-observ-lib/config.libsonnet b/docs/node-observ-lib/config.libsonnet new file mode 100644 index 0000000000..b136c492ef --- /dev/null +++ b/docs/node-observ-lib/config.libsonnet @@ -0,0 +1,104 @@ +{ + + // any modular observability library should inlcude as inputs: + // 'dashboardNamePrefix' - Use as prefix for all Dashboards and (optional) rule groups + // 'filteringSelector' - Static selector to apply to ALL dashboard variables of type query, panel queries, alerts and recording rules. + // 'groupLabels' - one or more labels that can be used to identify 'group' of instances. In simple cases, can be 'job' or 'cluster'. + // 'instanceLabels' - one or more labels that can be used to identify single entity of instances. In simple cases, can be 'instance' or 'pod'. + // 'uid' - UID to prefix all dashboards original uids + + filteringSelector: std.get(self, 'nodeExporterSelector', default='"job="node"'), + groupLabels: ['job'], + instanceLabels: ['instance'], + dashboardNamePrefix: 'Node exporter / ', + uid: 'node', + + dashboardTags: [self.uid], + + // Select the fstype for filesystem-related queries. If left + // empty, all filesystems are selected. If you have unusual + // filesystem you don't want to include in dashboards and + // alerting, you can exclude them here, e.g. 'fstype!="tmpfs"'. + fsSelector: 'fstype!=""', + + // Select the mountpoint for filesystem-related queries. If left + // empty, all mountpoints are selected. For example if you have a + // special purpose tmpfs instance that has a fixed size and will + // always be 100% full, but you still want alerts and dashboards for + // other tmpfs instances, you can exclude those by mountpoint prefix + // like so: 'mountpoint!~"/var/lib/foo.*"'. + fsMountpointSelector: 'mountpoint!=""', + + // Select the device for disk-related queries. If left empty, all + // devices are selected. If you have unusual devices you don't + // want to include in dashboards and alerting, you can exclude + // them here, e.g. 'device!="tmpfs"'. + diskDeviceSelector: 'device!=""', + + // Some of the alerts are meant to fire if a criticadiskDeviceSelector failure of a + // node is imminent (e.g. the disk is about to run full). In a + // true “cloud native” setup, failures of a single node should be + // tolerated. Hence, even imminent failure of a single node is no + // reason to create a paging alert. However, in practice there are + // still many situations where operators like to get paged in time + // before a node runs out of disk space. nodeCriticalSeverity can + // be set to the desired severity for this kind of alerts. This + // can even be templated to depend on labels of the node, e.g. you + // could make this critical for traditional database masters but + // just a warning for K8s nodes. + nodeCriticalSeverity: 'critical', + + // CPU utilization (%) on which to trigger the + // 'NodeCPUHighUsage' alert. + cpuHighUsageThreshold: 90, + // Load average 1m (per core) on which to trigger the + // 'NodeSystemSaturation' alert. + systemSaturationPerCoreThreshold: 2, + + // Available disk space (%) thresholds on which to trigger the + // 'NodeFilesystemSpaceFillingUp' alerts. These alerts fire if the disk + // usage grows in a way that it is predicted to run out in 4h or 1d + // and if the provided thresholds have been reached right now. + // In some cases you'll want to adjust these, e.g. by default Kubernetes + // runs the image garbage collection when the disk usage reaches 85% + // of its available space. In that case, you'll want to reduce the + // critical threshold below to something like 14 or 15, otherwise + // the alert could fire under normal node usage. + fsSpaceFillingUpWarningThreshold: 40, + fsSpaceFillingUpCriticalThreshold: 20, + + // Available disk space (%) thresholds on which to trigger the + // 'NodeFilesystemAlmostOutOfSpace' alerts. + fsSpaceAvailableWarningThreshold: 5, + fsSpaceAvailableCriticalThreshold: 3, + + // Memory utilzation (%) level on which to trigger the + // 'NodeMemoryHighUtilization' alert. + memoryHighUtilizationThreshold: 90, + + // Threshold for the rate of memory major page faults to trigger + // 'NodeMemoryMajorPagesFaults' alert. + memoryMajorPagesFaultsThreshold: 500, + + // Disk IO queue level above which to trigger + // 'NodeDiskIOSaturation' alert. + diskIOSaturationThreshold: 10, + + rateInterval: '5m', + + dashboardPeriod: 'now-1h', + dashboardTimezone: 'default', + dashboardRefresh: '1m', + + // logs lib related + enableLokiLogs: false, + extraLogLabels: ['transport', 'unit', 'level'], + logsVolumeGroupBy: 'level', + showLogsVolume: true, + logsFilteringSelector: self.filteringSelector, + logsExtraFilters: + ||| + | label_format timestamp="{{__timestamp__}}" + | line_format `{{ if eq "[[instance]]" ".*" }}{{alignLeft 25 .instance}}|{{alignLeft 25 .unit}}|{{else}}{{alignLeft 25 .unit}}|{{end}} {{__line__}}` + |||, +} diff --git a/docs/node-observ-lib/dashboards.libsonnet b/docs/node-observ-lib/dashboards.libsonnet new file mode 100644 index 0000000000..933e421c80 --- /dev/null +++ b/docs/node-observ-lib/dashboards.libsonnet @@ -0,0 +1,225 @@ +local g = import './g.libsonnet'; +local logslib = import 'github.com/grafana/jsonnet-libs/logs-lib/logs/main.libsonnet'; +{ + local root = self, + new(this): + local prefix = this.config.dashboardNamePrefix; + local links = this.grafana.links; + local tags = this.config.dashboardTags; + local uid = g.util.string.slugify(this.config.uid); + local vars = this.grafana.variables; + local annotations = this.grafana.annotations; + local refresh = this.config.dashboardRefresh; + local period = this.config.dashboardPeriod; + local timezone = this.config.dashboardTimezone; + local panels = this.grafana.panels; + local stat = g.panel.stat; + { + fleet: + local title = prefix + 'fleet overview'; + g.dashboard.new(title) + + g.dashboard.withPanels( + g.util.grid.wrapPanels( + [ + // g.panel.row.new("Overview"), + panels.fleetOverviewTable { gridPos+: { w: 24, h: 16 } }, + panels.cpuUsageTopk { gridPos+: { w: 24 } }, + panels.memotyUsageTopKPercent { gridPos+: { w: 24 } }, + panels.diskIOutilPercentTopK { gridPos+: { w: 12 } }, + panels.diskUsagePercentTopK { gridPos+: { w: 12 } }, + panels.networkErrorsAndDroppedPerSecTopK { gridPos+: { w: 24 } }, + ], 12, 7 + ) + ) + // hide link to self + + root.applyCommon(vars.multiInstance, uid + '-fleet', tags, links { backToFleet+:: {}, backToOverview+:: {} }, annotations, timezone, refresh, period), + overview: + g.dashboard.new(prefix + 'overview') + + g.dashboard.withPanels( + g.util.grid.wrapPanels( + [ + g.panel.row.new('Overview'), + panels.uptime, + panels.hostname, + panels.kernelVersion, + panels.osInfo, + panels.cpuCount, + panels.memoryTotalBytes, + panels.memorySwapTotalBytes, + panels.diskTotalRoot, + g.panel.row.new('CPU'), + panels.cpuUsageStat { gridPos+: { w: 6, h: 6 } }, + panels.cpuUsageTsPerCore { gridPos+: { w: 12, h: 6 } }, + panels.systemLoad { gridPos+: { w: 6, h: 6 } }, + g.panel.row.new('Memory'), + panels.memoryUsageStatPercent { gridPos+: { w: 6, h: 6 } }, + panels.memoryUsageTsBytes { gridPos+: { w: 18, h: 6 } }, + g.panel.row.new('Disk'), + panels.diskIOBytesPerSec { gridPos+: { w: 12, h: 8 } }, + panels.diskUsage { gridPos+: { w: 12, h: 8 } }, + g.panel.row.new('Network'), + panels.networkUsagePerSec { gridPos+: { w: 12, h: 8 } }, + panels.networkErrorsPerSec { gridPos+: { w: 12, h: 8 } }, + ], 6, 2 + ) + ) + // defaults to uid=nodes for backward compatibility with old node-mixins + + root.applyCommon(vars.singleInstance, (if uid == 'node' then 'nodes' else uid + '-overview'), tags, links { backToOverview+:: {} }, annotations, timezone, refresh, period), + network: + g.dashboard.new(prefix + 'network') + + g.dashboard.withPanels( + g.util.grid.wrapPanels( + [ + g.panel.row.new('Network'), + panels.networkOverviewTable { gridPos: { w: 24 } }, + panels.networkUsagePerSec, + panels.networkOperStatus, + panels.networkErrorsPerSec, + panels.networkDroppedPerSec, + panels.networkPacketsPerSec, + panels.networkMulticastPerSec, + panels.networkFifo, + panels.networkCompressedPerSec, + panels.networkNFConntrack, + panels.networkSoftnet, + panels.networkSoftnetSqueeze, + g.panel.row.new('Network sockets'), + panels.networkSockstatAll { gridPos: { w: 24 } }, + panels.networkSockstatTCP, + panels.networkSockstatUDP, + panels.networkSockstatMemory, + panels.networkSockstatOther, + g.panel.row.new('Network netstat'), + panels.networkNetstatIP { gridPos: { w: 24 } }, + panels.networkNetstatTCP, + panels.networkNetstatTCPerrors, + panels.networkNetstatUDP, + panels.networkNetstatUDPerrors, + panels.networkNetstatICMP, + panels.networkNetstatICMPerrors, + ], 12, 8 + ) + ) + + root.applyCommon(vars.singleInstance, uid + '-network', tags, links, annotations, timezone, refresh, period), + memory: + g.dashboard.new(prefix + 'memory') + + g.dashboard.withPanels( + g.util.grid.wrapPanels( + [ + panels.memoryUsageStatPercent { gridPos+: { w: 6, h: 6 } }, + panels.memoryUsageTsBytes { gridPos+: { w: 18, h: 6 } }, + g.panel.row.new('Vmstat'), + panels.memoryPagesInOut, + panels.memoryPagesSwapInOut, + panels.memoryPagesFaults, + panels.memoryOOMkiller, + g.panel.row.new('Memstat'), + panels.memoryActiveInactive, + panels.memoryActiveInactiveDetail, + panels.memoryCommited, + panels.memorySharedAndMapped, + panels.memoryWriteAndDirty, + panels.memoryVmalloc, + panels.memorySlab, + panels.memoryAnonymous, + panels.memoryHugePagesCounter, + panels.memoryHugePagesSize, + panels.memoryDirectMap, + panels.memoryBounce, + ], 12, 8 + ) + ) + + root.applyCommon(vars.singleInstance, uid + '-memory', tags, links, annotations, timezone, refresh, period), + + system: + g.dashboard.new(prefix + 'CPU and system') + + g.dashboard.withPanels( + g.util.grid.wrapPanels( + [ + g.panel.row.new('System'), + panels.cpuUsageStat { gridPos+: { w: 6, h: 6 } }, + panels.cpuUsageTsPerCore { gridPos+: { w: 9, h: 6 } }, + panels.cpuUsageByMode { gridPos+: { w: 9, h: 6 } }, + panels.systemLoad, + panels.systemContextSwitchesAndInterrupts, + g.panel.row.new('Time'), + panels.osTimezone { gridPos+: { w: 3, h: 4 } }, + panels.timeNtpStatus { gridPos+: { x: 0, y: 0, w: 21, h: 4 } }, + panels.timeSyncDrift { gridPos+: { w: 24, h: 7 } }, + ], 12, 7 + ) + ) + + root.applyCommon(vars.singleInstance, uid + '-system', tags, links, annotations, timezone, refresh, period), + + disks: + g.dashboard.new(prefix + 'filesystem and disks') + + g.dashboard.withPanels( + g.util.grid.wrapPanels( + [ + g.panel.row.new('Filesystem'), + panels.diskFreeTs, + panels.diskUsage, + panels.diskInodesFree, + panels.diskInodesTotal, + panels.diskErrorsandRO, + panels.fileDescriptors, + g.panel.row.new('Disk'), + panels.diskIOBytesPerSec, + panels.diskIOps, + panels.diskIOWaitTime, + panels.diskQueue, + ], 12, 8 + ) + ) + + root.applyCommon(vars.singleInstance, uid + '-disk', tags, links, annotations, timezone, refresh, period), + } + + + if this.config.enableLokiLogs + then + { + logs: + logslib.new( + prefix + 'logs', + datasourceName=this.grafana.variables.datasources.loki.name, + datasourceRegex=this.grafana.variables.datasources.loki.regex, + filterSelector=this.config.logsFilteringSelector, + labels=this.config.groupLabels + this.config.instanceLabels + this.config.extraLogLabels, + formatParser=null, + showLogsVolume=this.config.showLogsVolume, + logsVolumeGroupBy=this.config.logsVolumeGroupBy, + extraFilters=this.config.logsExtraFilters + ) + { + dashboards+: + { + logs+: + // reference to self, already generated variables, to keep them, but apply other common data in applyCommon + root.applyCommon(super.logs.templating.list, uid=uid + '-logs', tags=tags, links=links, annotations=annotations, timezone=timezone, refresh=refresh, period=period), + }, + panels+: + { + // modify log panel + logs+: + g.panel.logs.options.withEnableLogDetails(true) + + g.panel.logs.options.withShowTime(false) + + g.panel.logs.options.withWrapLogMessage(false), + }, + variables+: { + // add prometheus datasource for annotations processing + toArray+: [ + this.grafana.variables.datasources.prometheus { hide: 2 }, + ], + }, + }.dashboards.logs, + } + else {}, + applyCommon(vars, uid, tags, links, annotations, timezone, refresh, period): + g.dashboard.withTags(tags) + + g.dashboard.withUid(uid) + + g.dashboard.withLinks(std.objectValues(links)) + + g.dashboard.withTimezone(timezone) + + g.dashboard.withRefresh(refresh) + + g.dashboard.time.withFrom(period) + + g.dashboard.withVariables(vars) + + g.dashboard.withAnnotations(std.objectValues(annotations)), +} diff --git a/docs/node-observ-lib/g.libsonnet b/docs/node-observ-lib/g.libsonnet new file mode 100644 index 0000000000..6da9f4eef9 --- /dev/null +++ b/docs/node-observ-lib/g.libsonnet @@ -0,0 +1 @@ +import 'github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/main.libsonnet' diff --git a/docs/node-observ-lib/jsonnetfile.json b/docs/node-observ-lib/jsonnetfile.json new file mode 100644 index 0000000000..69b58cc74b --- /dev/null +++ b/docs/node-observ-lib/jsonnetfile.json @@ -0,0 +1,33 @@ +{ + "version": 1, + "dependencies": [ + { + "source": { + "git": { + "remote": "https://github.com/grafana/jsonnet-libs.git", + "subdir": "common-lib" + } + }, + "version": "master" + }, + { + "source": { + "git": { + "remote": "https://github.com/grafana/grafonnet.git", + "subdir": "gen/grafonnet-v10.0.0" + } + }, + "version": "main" + }, + { + "source": { + "git": { + "remote": "https://github.com/grafana/jsonnet-libs.git", + "subdir": "logs-lib" + } + }, + "version": "master" + } + ], + "legacyImports": true +} \ No newline at end of file diff --git a/docs/node-observ-lib/jsonnetfile.lock.json b/docs/node-observ-lib/jsonnetfile.lock.json new file mode 100644 index 0000000000..5853fd6180 --- /dev/null +++ b/docs/node-observ-lib/jsonnetfile.lock.json @@ -0,0 +1,56 @@ +{ + "version": 1, + "dependencies": [ + { + "source": { + "git": { + "remote": "https://github.com/grafana/grafonnet.git", + "subdir": "gen/grafonnet-v10.0.0" + } + }, + "version": "9e217263ac4b922ca2e00bc5cc36ada2311bb5a6", + "sum": "gj/20VIGucG2vDGjG7YdHLC4yUUfrpuaneUYaRmymOM=" + }, + { + "source": { + "git": { + "remote": "https://github.com/grafana/jsonnet-libs.git", + "subdir": "common-lib" + } + }, + "version": "a7647832fd3eaae70411bc9f697fa7504b04796c", + "sum": "XTZ4WevbwUlziv53i4HY9ndaW+VNMHiT6NpSDvTyYyA=" + }, + { + "source": { + "git": { + "remote": "https://github.com/grafana/jsonnet-libs.git", + "subdir": "logs-lib" + } + }, + "version": "a7647832fd3eaae70411bc9f697fa7504b04796c", + "sum": "IkBo9nj0Qt1eC9w80dO5SI4yvHzmmXcKx5BK8H8U0Mk=" + }, + { + "source": { + "git": { + "remote": "https://github.com/jsonnet-libs/docsonnet.git", + "subdir": "doc-util" + } + }, + "version": "503e5c8fe96d6b55775037713ac10b184709ad93", + "sum": "BY4u0kLF3Qf/4IB4HnX9S5kEQIpHb4MUrppp6WLDtlU=" + }, + { + "source": { + "git": { + "remote": "https://github.com/jsonnet-libs/xtd.git", + "subdir": "" + } + }, + "version": "c1a315a7dbead0335a5e0486acc5583395b22a24", + "sum": "UVdL+uuFI8BSQgLfMJEJk2WDKsQXNT3dRHcr2Ti9rLI=" + } + ], + "legacyImports": false +} diff --git a/docs/node-observ-lib/links.libsonnet b/docs/node-observ-lib/links.libsonnet new file mode 100644 index 0000000000..ac61ad7ad5 --- /dev/null +++ b/docs/node-observ-lib/links.libsonnet @@ -0,0 +1,19 @@ +local g = import './g.libsonnet'; +local commonlib = import 'common-lib/common/main.libsonnet'; +{ + new(this): + { + local link = g.dashboard.link, + backToFleet: + link.link.new('Back to ' + this.config.dashboardNamePrefix + 'fleet', '/d/' + this.grafana.dashboards.fleet.uid) + + link.link.options.withKeepTime(true), + backToOverview: + link.link.new('Back to ' + this.config.dashboardNamePrefix + 'overview', '/d/' + this.grafana.dashboards.overview.uid) + + link.link.options.withKeepTime(true), + otherDashboards: + link.dashboards.new('All ' + this.config.dashboardNamePrefix + ' dashboards', this.config.dashboardTags) + + link.dashboards.options.withIncludeVars(true) + + link.dashboards.options.withKeepTime(true) + + link.dashboards.options.withAsDropdown(true), + }, +} diff --git a/docs/node-observ-lib/main.libsonnet b/docs/node-observ-lib/main.libsonnet new file mode 100644 index 0000000000..0fb13f70d2 --- /dev/null +++ b/docs/node-observ-lib/main.libsonnet @@ -0,0 +1,39 @@ +local alerts = import './alerts.libsonnet'; +local annotations = import './annotations.libsonnet'; +local config = import './config.libsonnet'; +local dashboards = import './dashboards.libsonnet'; +local datasources = import './datasources.libsonnet'; +local g = import './g.libsonnet'; +local links = import './links.libsonnet'; +local panels = import './panels.libsonnet'; +local rules = import './rules.libsonnet'; +local targets = import './targets.libsonnet'; +local variables = import './variables.libsonnet'; +local commonlib = import 'common-lib/common/main.libsonnet'; + +{ + withConfigMixin(config): { + config+: config, + }, + + new(): { + + local this = self, + config: config, + grafana: { + variables: variables.new(this), + targets: targets.new(this), + panels: panels.new(this), + annotations: annotations.new(this), + // common links here used across all dashboards + links: links.new(this), + dashboards: dashboards.new(this), + }, + + prometheus: { + alerts: alerts.new(this), + recordingRules: rules.new(this), + }, + + }, +} diff --git a/docs/node-observ-lib/mixin.libsonnet b/docs/node-observ-lib/mixin.libsonnet new file mode 100644 index 0000000000..f902699f3e --- /dev/null +++ b/docs/node-observ-lib/mixin.libsonnet @@ -0,0 +1,20 @@ +local g = import './g.libsonnet'; +local nodelib = import './main.libsonnet'; + + +local linux = + nodelib.new() + + nodelib.withConfigMixin({ + filteringSelector: 'job=~".*node.*"', + groupLabels: ['job'], + instanceLabels: ['instance'], + dashboardNamePrefix: 'Node exporter / ', + dashboardTags: ['node-exporter-mixin'], + uid: 'node', + }); + +{ + grafanaDashboards+:: linux.grafana.dashboards, + prometheusAlerts+:: linux.prometheus.alerts, + prometheusRules+:: linux.prometheus.recordingRules, +} diff --git a/docs/node-observ-lib/panels.libsonnet b/docs/node-observ-lib/panels.libsonnet new file mode 100644 index 0000000000..aa0269d34f --- /dev/null +++ b/docs/node-observ-lib/panels.libsonnet @@ -0,0 +1,1131 @@ +local g = import './g.libsonnet'; +local commonlib = import 'common-lib/common/main.libsonnet'; +local utils = commonlib.utils; +{ + new(this): + { + local t = this.grafana.targets, + local table = g.panel.table, + local fieldOverride = g.panel.table.fieldOverride, + local instanceLabel = this.config.instanceLabels[0], + fleetOverviewTable: + commonlib.panels.generic.table.base.new( + 'Fleet overview', + targets= + [ + t.osInfoCombined + + g.query.prometheus.withFormat('table') + + g.query.prometheus.withInstant(true) + + g.query.prometheus.withRefId('OS Info'), + t.uptime + + g.query.prometheus.withFormat('table') + + g.query.prometheus.withInstant(true) + + g.query.prometheus.withRefId('Uptime'), + t.systemLoad1 + + g.query.prometheus.withFormat('table') + + g.query.prometheus.withInstant(true) + + g.query.prometheus.withRefId('Load 1'), + t.cpuCount + + g.query.prometheus.withFormat('table') + + g.query.prometheus.withInstant(true) + + g.query.prometheus.withRefId('Cores'), + t.cpuUsage + + g.query.prometheus.withFormat('table') + + g.query.prometheus.withInstant(true) + + g.query.prometheus.withRefId('CPU usage'), + t.memoryTotalBytes + + g.query.prometheus.withFormat('table') + + g.query.prometheus.withInstant(true) + + g.query.prometheus.withRefId('Memory total'), + t.memoryUsagePercent + + g.query.prometheus.withFormat('table') + + g.query.prometheus.withInstant(true) + + g.query.prometheus.withRefId('Memory usage'), + t.diskTotalRoot + + g.query.prometheus.withFormat('table') + + g.query.prometheus.withInstant(true) + + g.query.prometheus.withRefId('Root mount size'), + t.diskUsageRootPercent + + g.query.prometheus.withFormat('table') + + g.query.prometheus.withInstant(true) + + g.query.prometheus.withRefId('Root mount used'), + t.alertsCritical + + g.query.prometheus.withFormat('table') + + g.query.prometheus.withInstant(true) + + g.query.prometheus.withRefId('CRITICAL'), + t.alertsWarning + + g.query.prometheus.withFormat('table') + + g.query.prometheus.withInstant(true) + + g.query.prometheus.withRefId('WARNING'), + ], + description="All nodes' perfomance at a glance." + ) + + g.panel.table.options.withFooter( + value={ + reducer: ['sum'], + show: true, + fields: [ + 'Value #Cores', + 'Value #Load 1', + 'Value #Memory total', + 'Value #Root mount size', + ], + } + ) + + commonlib.panels.system.table.uptime.stylizeByName('Uptime') + + table.standardOptions.withOverridesMixin([ + fieldOverride.byRegexp.new('Product|^Hostname$') + + fieldOverride.byRegexp.withProperty('custom.filterable', true), + fieldOverride.byName.new('Instance') + + fieldOverride.byName.withProperty('custom.filterable', true) + + fieldOverride.byName.withProperty('links', [ + { + targetBlank: false, + title: 'Drill down to ${__field.name} ${__value.text}', + url: 'd/%s?var-%s=${__data.fields.%s}&${__url_time_range}' % [this.grafana.dashboards.overview.uid, instanceLabel, instanceLabel], + }, + ]), + fieldOverride.byRegexp.new(std.join('|', std.map(utils.toSentenceCase, this.config.groupLabels))) + + fieldOverride.byRegexp.withProperty('custom.filterable', true) + + fieldOverride.byRegexp.withProperty('links', [ + { + targetBlank: false, + title: 'Filter by ${__field.name}', + url: 'd/%s?var-${__field.name}=${__value.text}&${__url_time_range}' % [this.grafana.dashboards.fleet.uid], + }, + ]), + fieldOverride.byName.new('Cores') + + fieldOverride.byName.withProperty('custom.width', '120'), + fieldOverride.byName.new('CPU usage') + + fieldOverride.byName.withProperty('custom.width', '120') + + fieldOverride.byName.withProperty('custom.displayMode', 'basic') + + fieldOverride.byName.withPropertiesFromOptions( + commonlib.panels.cpu.timeSeries.utilization.stylize() + ), + fieldOverride.byName.new('Memory total') + + fieldOverride.byName.withProperty('custom.width', '120') + + fieldOverride.byName.withPropertiesFromOptions( + table.standardOptions.withUnit('bytes') + ), + fieldOverride.byName.new('Memory usage') + + fieldOverride.byName.withProperty('custom.width', '120') + + fieldOverride.byName.withProperty('custom.displayMode', 'basic') + + fieldOverride.byName.withPropertiesFromOptions( + commonlib.panels.cpu.timeSeries.utilization.stylize() + ), + fieldOverride.byName.new('Root mount size') + + fieldOverride.byName.withProperty('custom.width', '120') + + fieldOverride.byName.withPropertiesFromOptions( + table.standardOptions.withUnit('bytes') + ), + fieldOverride.byName.new('Root mount used') + + fieldOverride.byName.withProperty('custom.width', '120') + + fieldOverride.byName.withProperty('custom.displayMode', 'basic') + + fieldOverride.byName.withPropertiesFromOptions( + table.standardOptions.withUnit('percent') + ) + + fieldOverride.byName.withPropertiesFromOptions( + commonlib.panels.cpu.timeSeries.utilization.stylize() + ), + ]) + + table.queryOptions.withTransformationsMixin( + [ + { + id: 'joinByField', + options: { + byField: instanceLabel, + mode: 'outer', + }, + }, + { + id: 'filterFieldsByName', + options: { + include: { + //' 1' - would only match first occurence of group label, so no duplicates + pattern: instanceLabel + '|' + + + std.join( + '|', + std.map( + function(x) '%s 1' % x, this.config.instanceLabels + ) + ) + + '|' + + std.join( + '|', + std.map( + function(x) '%s 1' % x, this.config.groupLabels + ) + ) + + '|product|^hostname$|^nodename$|^pretty_name$|Value.+', + }, + }, + }, + { + id: 'organize', + options: { + excludeByName: { + 'Value #OS Info': true, + }, + indexByName: + { + [instanceLabel]: 0, + nodename: 1, + hostname: 1, + pretty_name: 2, + product: 2, + } + + + // group labels are named as 'job 1' and so on. + { + [label]: 3 + for label in this.config.groupLabels + }, + renameByName: + { + [label + ' 1']: utils.toSentenceCase(label) + for label in this.config.instanceLabels + } + { + [instanceLabel]: utils.toSentenceCase(instanceLabel), + product: 'OS', // windows + pretty_name: 'OS', // linux + hostname: 'Hostname', // windows + nodename: 'Hostname', // Linux + } + + + // group labels are named as 'job 1' and so on. + { + [label + ' 1']: utils.toSentenceCase(label) + for label in this.config.groupLabels + }, + + }, + }, + { + id: 'renameByRegex', + options: { + regex: 'Value #(.*)', + renamePattern: '$1', + }, + }, + ] + ), + uptime: commonlib.panels.system.stat.uptime.new(targets=[t.uptime]), + + systemLoad: + commonlib.panels.system.timeSeries.loadAverage.new( + loadTargets=[t.systemLoad1, t.systemLoad5, t.systemLoad15], + cpuCountTarget=t.cpuCount, + ), + + systemContextSwitchesAndInterrupts: + commonlib.panels.generic.timeSeries.base.new( + 'Context switches/Interrupts', + targets=[ + t.systemContextSwitches, + t.systemInterrupts, + ], + description=||| + Context switches occur when the operating system switches from running one process to another. Interrupts are signals sent to the CPU by external devices to request its attention. + + A high number of context switches or interrupts can indicate that the system is overloaded or that there are problems with specific devices or processes. + ||| + ), + + timeNtpStatus: + commonlib.panels.system.statusHistory.ntp.new( + 'NTP status', + targets=[t.timeNtpStatus], + description='Status of time synchronization.' + ) + + g.panel.timeSeries.standardOptions.withNoValue('No data.') + + g.panel.statusHistory.options.withLegend(false), + timeSyncDrift: + commonlib.panels.generic.timeSeries.base.new( + 'Time synchronized drift', + targets=[ + t.timeEstimatedError, + t.timeOffset, + t.timeMaxError, + ], + description=||| + Time synchronization is essential to ensure accurate timekeeping, which is critical for many system operations such as logging, authentication, and network communication, as well as distributed systems or clusters where data consistency is important. + ||| + ) + + g.panel.timeSeries.standardOptions.withUnit('seconds') + + g.panel.timeSeries.standardOptions.withNoValue('No data.'), + cpuCount: commonlib.panels.cpu.stat.count.new(targets=[t.cpuCount]), + cpuUsageTsPerCore: commonlib.panels.cpu.timeSeries.utilization.new(targets=[t.cpuUsagePerCore]) + + g.panel.timeSeries.fieldConfig.defaults.custom.withStacking({ mode: 'normal' }), + + cpuUsageTopk: commonlib.panels.generic.timeSeries.topkPercentage.new( + title='CPU usage', + target=t.cpuUsage, + topk=25, + instanceLabels=this.config.instanceLabels, + drillDownDashboardUid=this.grafana.dashboards.overview.uid, + ), + cpuUsageStat: commonlib.panels.cpu.stat.usage.new(targets=[t.cpuUsage]), + cpuUsageByMode: commonlib.panels.cpu.timeSeries.utilizationByMode.new( + targets=[t.cpuUsageByMode], + description=||| + - System: Processes executing in kernel mode. + - User: Normal processes executing in user mode. + - Nice: Niced processes executing in user mode. + - Idle: Waiting for something to happen. + - Iowait: Waiting for I/O to complete. + - Irq: Servicing interrupts. + - Softirq: Servicing softirqs. + - Steal: Time spent in other operating systems when running in a virtualized environment. + ||| + ), + + memoryTotalBytes: commonlib.panels.memory.stat.total.new(targets=[t.memoryTotalBytes]), + memorySwapTotalBytes: + commonlib.panels.memory.stat.total.new( + 'Total swap', + targets=[t.memorySwapTotal], + description=||| + Total swap available. + + Swap is a space on a storage device (usually a dedicated swap partition or a swap file) + used as virtual memory when the physical RAM (random-access memory) is fully utilized. + Swap space helps prevent memory-related performance issues by temporarily transferring less-used data from RAM to disk, + freeing up physical memory for active processes and applications. + ||| + ), + memoryUsageStatPercent: commonlib.panels.memory.stat.usage.new(targets=[t.memoryUsagePercent]), + memotyUsageTopKPercent: commonlib.panels.generic.timeSeries.topkPercentage.new( + title='Memory usage', + target=t.memoryUsagePercent, + topk=25, + instanceLabels=this.config.instanceLabels, + drillDownDashboardUid=this.grafana.dashboards.overview.uid, + ), + memoryUsageTsBytes: + commonlib.panels.memory.timeSeries.usageBytes.new( + targets=[ + t.memoryUsedBytes, + t.memoryCachedBytes, + t.memoryAvailableBytes, + t.memoryBuffersBytes, + t.memoryFreeBytes, + t.memoryTotalBytes, + ], + description= + ||| + - Used: The amount of physical memory currently in use by the system. + - Cached: The amount of physical memory used for caching data from disk. The Linux kernel uses available memory to cache data that is read from or written to disk. This helps speed up disk access times. + - Free: The amount of physical memory that is currently not in use. + - Buffers: The amount of physical memory used for temporary storage of data being transferred between devices or applications. + - Available: The amount of physical memory that is available for use by applications. This takes into account memory that is currently being used for caching but can be freed up if needed. + ||| + ) + + g.panel.timeSeries.standardOptions.withOverridesMixin( + { + __systemRef: 'hideSeriesFrom', + matcher: { + id: 'byNames', + options: { + mode: 'exclude', + names: [ + t.memoryTotalBytes.legendFormat, + t.memoryUsedBytes.legendFormat, + ], + prefix: 'All except:', + readOnly: true, + }, + }, + properties: [ + { + id: 'custom.hideFrom', + value: { + viz: true, + legend: false, + tooltip: false, + }, + }, + ], + } + ), + + memoryPagesInOut: + commonlib.panels.memory.timeSeries.base.new( + 'Memory pages in / out', + targets=[t.memoryPagesIn, t.memoryPagesOut], + description=||| + Page-In - Return of pages to physical memory. This is a common and normal event. + + Page-Out - process of writing pages to disk. Unlike page-in, page-outs can indicate trouble. + When the kernel detects low memory, it attempts to free memory by paging out. + While occasional page-outs are normal, excessive and frequent page-outs can lead to thrashing. + Thrashing is a state in which the kernel spends more time managing paging activity than running applications, resulting in poor system performance. + ||| + ) + + commonlib.panels.network.timeSeries.base.withNegateOutPackets(), + + memoryPagesSwapInOut: + commonlib.panels.memory.timeSeries.base.new( + 'Memory pages swapping in / out', + targets=[t.memoryPagesSwapIn, t.memoryPagesSwapOut], + description=||| + Compared to the speed of the CPU and main memory, writing pages out to disk is relatively slow. + Nonetheless, it is a preferable option to crashing or killing off processes. + + The process of writing pages out to disk to free memory is known as swapping-out. + If a page fault occurs because the page is on disk, in the swap area, rather than in memory, + the kernel will read the page back in from the disk to satisfy the page fault. + This is known as swapping-in. + ||| + ) + + commonlib.panels.network.timeSeries.base.withNegateOutPackets(), + + memoryPagesFaults: + commonlib.panels.memory.timeSeries.base.new( + 'Memory page faults', + targets=[t.memoryPageMajorFaults, t.memoryPageMinorFaults], + description=||| + A page fault is an exception raised by the memory when a process accesses a memory page without the necessary preparations, + requiring a mapping to be added to the process's virtual address space. + + The page contents may also need to be loaded from a backing store such as a disk. + While the MMU detects the page fault, the operating system's kernel handles the exception by either making the required page accessible in physical memory or denying an illegal memory access. + Valid page faults are common and necessary to increase memory availability in any operating system that uses virtual memory, including Windows, macOS, and the Linux kernel. + |||, + ), + + memoryOOMkiller: + commonlib.panels.memory.timeSeries.base.new( + 'OOM Killer', + targets=[t.memoryOOMkiller], + description=||| + Out Of Memory killer is a process used by the Linux kernel when the system is running critically low on memory. + + This can happen when the kernel has allocated more memory than is available for its processes. + ||| + ), + + memoryActiveInactive: + commonlib.panels.memory.timeSeries.usageBytes.new( + 'Memory active / inactive', + targets=[t.memoryActiveBytes, t.memoryInactiveBytes], + description=||| + - Inactive: Memory which has been less recently used. It is more eligible to be reclaimed for other purposes. + - Active: Memory that has been used more recently and usually not reclaimed unless absolutely necessary. + |||, + ), + + memoryActiveInactiveDetail: + commonlib.panels.memory.timeSeries.usageBytes.new( + 'Memory active / inactive details', + targets=[t.memoryInactiveFile, t.memoryInactiveAnon, t.memoryActiveFile, t.memoryActiveAnon], + description=||| + - Inactive_file: File-backed memory on inactive LRU list. + - Inactive_anon: Anonymous and swap cache on inactive LRU list, including tmpfs (shmem). + - Active_file: File-backed memory on active LRU list. + - Active_anon: Anonymous and swap cache on active least-recently-used (LRU) list, including tmpfs. + |||, + ), + + memoryCommited: + commonlib.panels.memory.timeSeries.usageBytes.new( + 'Memory commited', + targets=[t.memoryCommitedAs, t.memoryCommitedLimit], + description=||| + - Committed_AS - Amount of memory presently allocated on the system. + - CommitLimit - Amount of memory currently available to be allocated on the system. + ||| + ), + + memorySharedAndMapped: + commonlib.panels.memory.timeSeries.usageBytes.new( + 'Memory shared and mapped', + targets=[t.memoryMappedBytes, t.memoryShmemBytes, t.memoryShmemBytes, t.memoryShmemHugePagesBytes], + description=||| + - Mapped: This refers to the memory used in mapped page files that have been memory mapped, such as libraries. + - Shmem: This is the memory used by shared memory, which is shared between multiple processes, including RAM disks. + - ShmemHugePages: This is the memory used by shared memory and tmpfs allocated with huge pages. + - ShmemPmdMapped: This is the amount of shared memory (shmem/tmpfs) backed by huge pages. + ||| + ), + memoryWriteAndDirty: + commonlib.panels.memory.timeSeries.usageBytes.new( + 'Memory writeback and dirty', + targets=[t.memoryWriteback, t.memoryWritebackTmp, t.memoryDirty], + description=||| + - Writeback: This refers to the memory that is currently being actively written back to the disk. + - WritebackTmp: This is the memory used by FUSE for temporary writeback buffers. + - Dirty: This type of memory is waiting to be written back to the disk. + ||| + ), + memoryVmalloc: + commonlib.panels.memory.timeSeries.usageBytes.new( + 'Memory Vmalloc', + targets=[t.memoryVmallocChunk, t.memoryVmallocTotal, t.memoryVmallocUsed], + description=||| + Virtual Memory Allocation is a type of memory allocation in Linux that allows a process to request a contiguous block of memory larger than the amount of physically available memory. This is achieved by mapping the requested memory to virtual addresses that are backed by a combination of physical memory and swap space on disk. + + - VmallocChunk: Largest contiguous block of vmalloc area which is free. + - VmallocTotal: Total size of vmalloc memory area. + - VmallocUsed: Amount of vmalloc area which is used. + ||| + ), + memorySlab: + commonlib.panels.memory.timeSeries.usageBytes.new( + 'Memory slab', + targets=[t.memorySlabSUnreclaim, t.memorySlabSReclaimable], + description=||| + Slab Allocation is a type of memory allocation in Linux that allows the kernel to efficiently manage the allocation and deallocation of small and frequently used data structures, such as network packets, file system objects, and process descriptors. + + The Slab Allocator maintains a cache of pre-allocated objects of a fixed size and type, called slabs. When an application requests an object of a particular size and type, the Slab Allocator checks if a pre-allocated object of that size and type is available in the cache. If an object is available, it is returned to the application; if not, a new slab of objects is allocated and added to the cache. + + - SUnreclaim: Part of Slab, that cannot be reclaimed on memory pressure. + - SReclaimable: Part of Slab, that might be reclaimed, such as caches. + ||| + ), + memoryAnonymous: + commonlib.panels.memory.timeSeries.usageBytes.new( + 'Memory slab', + targets=[t.memoryAnonHugePages, t.memoryAnonPages], + description=||| + Memory Anonymous refers to the portion of the virtual memory that is used by a process for dynamically allocated memory that is not backed by any file or device. + + This type of memory is commonly used for heap memory allocation, which is used by programs to allocate and free memory dynamically during runtime. + + Memory Anonymous is different from Memory Mapped files, which refer to portions of the virtual memory space that are backed by a file or device, + and from Memory Shared with other processes, + which refers to memory regions that can be accessed and modified by multiple processes. + + - AnonHugePages: Memory in anonymous huge pages. + - AnonPages: Memory in user pages not backed by files. + ||| + ), + + memoryHugePagesCounter: + commonlib.panels.memory.timeSeries.base.new( + 'Memory HugePages counter', + targets=[t.memoryHugePages_Free, t.memoryHugePages_Rsvd, t.memoryHugePages_Surp], + description= + ||| + Huge Pages are a feature that allows for the allocation of larger memory pages than the standard 4KB page size. By using larger page sizes, the kernel can reduce the overhead associated with managing a large number of smaller pages, which can improve system performance for certain workloads. + + - HugePages_Free: Huge pages in the pool that are not yet allocated. + - HugePages_Rsvd: Huge pages for which a commitment to allocate from the pool has been made, but no allocation has yet been made. + - HugePages_Surp: Huge pages in the pool above the value in /proc/sys/vm/nr_hugepages. + ||| + ), + memoryHugePagesSize: + commonlib.panels.memory.timeSeries.usageBytes.new( + 'Memory HugePages size', + targets=[t.memoryHugePagesTotalSize, t.memoryHugePagesSize], + + description=||| + Huge Pages are a feature that allows for the allocation of larger memory pages than the standard 4KB page size. By using larger page sizes, the kernel can reduce the overhead associated with managing a large number of smaller pages, which can improve system performance for certain workloads. + ||| + ), + + memoryDirectMap: + commonlib.panels.memory.timeSeries.usageBytes.new( + 'Memory direct map', + targets=[t.memoryDirectMap1G, t.memoryDirectMap2M, t.memoryDirectMap4k], + + description=||| + Direct Map memory refers to the portion of the kernel's virtual address space that is directly mapped to physical memory. This mapping is set up by the kernel during boot time and is used to provide fast access to certain critical kernel data structures, such as page tables and interrupt descriptor tables. + ||| + ), + memoryBounce: + commonlib.panels.memory.timeSeries.usageBytes.new( + 'Memory bounce', + targets=[t.memoryBounce], + description=||| + Memory bounce is a technique used in the Linux kernel to handle situations where direct memory access (DMA) is required but the physical memory being accessed is not contiguous. This can happen when a device, such as a network interface card or a disk controller, requires access to a large amount of memory that is not available as a single contiguous block. + + To handle this situation, the kernel uses a technique called memory bouncing. In memory bouncing, the kernel sets up a temporary buffer in physical memory that is large enough to hold the entire data block being transferred by the device. The data is then copied from the non-contiguous source memory to the temporary buffer, which is physically contiguous. + + - Bounce: Memory used for block device bounce buffers. + ||| + ), + diskTotalRoot: + commonlib.panels.disk.stat.total.new( + 'Root mount size', + targets=[t.diskTotalRoot], + description=||| + Total capacity on the primary mount point /. + ||| + ), + diskUsage: + commonlib.panels.disk.table.usage.new( + totalTarget= + ( + t.diskTotal + + g.query.prometheus.withFormat('table') + + g.query.prometheus.withInstant(true) + ), + freeTarget= + t.diskFree + + g.query.prometheus.withFormat('table') + + g.query.prometheus.withInstant(true), + groupLabel='mountpoint' + , + description='Disk utilisation in percent, by mountpoint. Some duplication can occur if the same filesystem is mounted in multiple locations.' + ), + diskFreeTs: + commonlib.panels.disk.timeSeries.available.new( + 'Filesystem space availabe', + targets=[ + t.diskFree, + ], + description='Filesystem space utilisation in bytes, by mountpoint.' + ), + diskInodesFree: + commonlib.panels.disk.timeSeries.base.new( + 'Free inodes', + targets=[t.diskInodesFree], + description='The inode is a data structure in a Unix-style file system that describes a file-system object such as a file or a directory.' + ) + + g.panel.timeSeries.standardOptions.withUnit('short'), + diskInodesTotal: + commonlib.panels.disk.timeSeries.base.new( + 'Total inodes', + targets=[t.diskInodesTotal], + description='The inode is a data structure in a Unix-style file system that describes a file-system object such as a file or a directory.', + ) + + g.panel.timeSeries.standardOptions.withUnit('short'), + diskErrorsandRO: + commonlib.panels.disk.timeSeries.base.new( + 'Filesystems with errors / read-only', + targets=[ + t.diskDeviceError, + t.diskReadOnly, + ], + description='', + ) + + g.panel.timeSeries.standardOptions.withMax(1), + fileDescriptors: + commonlib.panels.disk.timeSeries.base.new( + 'File descriptors', + targets=[ + t.processMaxFds, + t.processOpenFds, + ], + description=||| + File descriptor is a handle to an open file or input/output (I/O) resource, such as a network socket or a pipe. + The operating system uses file descriptors to keep track of open files and I/O resources, and provides a way for programs to read from and write to them. + ||| + ), + diskUsagePercentTopK: commonlib.panels.generic.timeSeries.topkPercentage.new( + title='Disk space usage', + target=t.diskUsagePercent, + topk=25, + instanceLabels=this.config.instanceLabels + ['volume'], + drillDownDashboardUid=this.grafana.dashboards.overview.uid, + ), + diskIOBytesPerSec: commonlib.panels.disk.timeSeries.ioBytesPerSec.new( + targets=[t.diskIOreadBytesPerSec, t.diskIOwriteBytesPerSec, t.diskIOutilization] + ), + diskIOutilPercentTopK: + commonlib.panels.generic.timeSeries.topkPercentage.new( + title='Disk IO', + target=t.diskIOutilization, + topk=25, + instanceLabels=this.config.instanceLabels + ['volume'], + drillDownDashboardUid=this.grafana.dashboards.overview.uid, + ), + diskIOps: + commonlib.panels.disk.timeSeries.iops.new( + targets=[ + t.diskIOReads, + t.diskIOWrites, + ] + ), + + diskQueue: + commonlib.panels.disk.timeSeries.ioQueue.new( + 'Disk average queue', + targets= + [ + t.diskAvgQueueSize, + ] + ), + diskIOWaitTime: commonlib.panels.disk.timeSeries.ioWaitTime.new( + targets=[ + t.diskIOWaitReadTime, + t.diskIOWaitWriteTime, + ] + ), + osInfo: commonlib.panels.generic.stat.info.new( + 'OS', + targets=[t.osInfo], + description='Operating system' + ) + { options+: { reduceOptions+: { fields: '/^pretty_name$/' } } }, + kernelVersion: + commonlib.panels.generic.stat.info.new('Kernel version', + targets=[t.unameInfo], + description='Kernel version of linux host.') + { options+: { reduceOptions+: { fields: '/^release$/' } } }, + osTimezone: + commonlib.panels.generic.stat.info.new( + 'Timezone', targets=[t.osTimezone], description='Current system timezone.' + ) + { options+: { reduceOptions+: { fields: '/^time_zone$/' } } }, + hostname: + commonlib.panels.generic.stat.info.new( + 'Hostname', + targets=[t.unameInfo], + description="System's hostname." + ) + { options+: { reduceOptions+: { fields: '/^nodename$/' } } }, + networkErrorsAndDroppedPerSec: + commonlib.panels.network.timeSeries.errors.new( + 'Network errors and dropped packets', + targets=[ + t.networkOutErrorsPerSec, + t.networkInErrorsPerSec, + t.networkOutDroppedPerSec, + t.networkInDroppedPerSec, + ], + description=||| + **Network errors**: + + Network errors refer to issues that occur during the transmission of data across a network. + + These errors can result from various factors, including physical issues, jitter, collisions, noise and interference. + + Monitoring network errors is essential for diagnosing and resolving issues, as they can indicate problems with network hardware or environmental factors affecting network quality. + + **Dropped packets**: + + Dropped packets occur when data packets traveling through a network are intentionally discarded or lost due to congestion, resource limitations, or network configuration issues. + + Common causes include network congestion, buffer overflows, QoS settings, and network errors, as corrupted or incomplete packets may be discarded by receiving devices. + + Dropped packets can impact network performance and lead to issues such as degraded voice or video quality in real-time applications. + ||| + ) + + commonlib.panels.network.timeSeries.errors.withNegateOutPackets(), + networkErrorsAndDroppedPerSecTopK: + commonlib.panels.network.timeSeries.errors.new( + 'Network errors and dropped packets', + targets=std.map( + function(t) t + { + expr: 'topk(25, ' + t.expr + ')>0.5', + legendFormat: '{{' + this.config.instanceLabels[0] + '}}: ' + std.get(t, 'legendFormat', '{{ nic }}'), + }, + [ + t.networkOutErrorsPerSec, + t.networkInErrorsPerSec, + t.networkOutDroppedPerSec, + t.networkInDroppedPerSec, + ] + ), + description=||| + Top 25. + + **Network errors**: + + Network errors refer to issues that occur during the transmission of data across a network. + + These errors can result from various factors, including physical issues, jitter, collisions, noise and interference. + + Monitoring network errors is essential for diagnosing and resolving issues, as they can indicate problems with network hardware or environmental factors affecting network quality. + + **Dropped packets**: + + Dropped packets occur when data packets traveling through a network are intentionally discarded or lost due to congestion, resource limitations, or network configuration issues. + + Common causes include network congestion, buffer overflows, QoS settings, and network errors, as corrupted or incomplete packets may be discarded by receiving devices. + + Dropped packets can impact network performance and lead to issues such as degraded voice or video quality in real-time applications. + ||| + ) + + g.panel.timeSeries.fieldConfig.defaults.custom.withDrawStyle('points') + + g.panel.timeSeries.fieldConfig.defaults.custom.withPointSize(5), + + networkErrorsPerSec: + commonlib.panels.network.timeSeries.errors.new( + 'Network errors', + targets=[t.networkInErrorsPerSec, t.networkOutErrorsPerSec] + ) + + commonlib.panels.network.timeSeries.errors.withNegateOutPackets(), + networkDroppedPerSec: + commonlib.panels.network.timeSeries.dropped.new( + targets=[t.networkInDroppedPerSec, t.networkOutDroppedPerSec] + ) + + commonlib.panels.network.timeSeries.errors.withNegateOutPackets(), + networkUsagePerSec: + commonlib.panels.network.timeSeries.traffic.new( + targets=[t.networkInBitPerSec, t.networkOutBitPerSec] + ) + + commonlib.panels.network.timeSeries.traffic.withNegateOutPackets(), + networkPacketsPerSec: + commonlib.panels.network.timeSeries.packets.new( + targets=[t.networkInPacketsPerSec, t.networkOutPacketsPerSec] + ) + + commonlib.panels.network.timeSeries.traffic.withNegateOutPackets(), + networkMulticastPerSec: + commonlib.panels.network.timeSeries.multicast.new( + 'Multicast packets', + targets=[t.networkInMulticastPacketsPerSec, t.networkOutMulticastPacketsPerSec], + description='Multicast packets received and transmitted.' + ) + + commonlib.panels.network.timeSeries.traffic.withNegateOutPackets(), + + networkFifo: + commonlib.panels.network.timeSeries.packets.new( + 'Network FIFO', + targets=[t.networkFifoInPerSec, t.networkFifoOutPerSec], + description=||| + Network FIFO (First-In, First-Out) refers to a buffer used by the network stack to store packets in a queue. + It is a mechanism used to manage network traffic and ensure that packets are delivered to their destination in the order they were received. + Packets are stored in the FIFO buffer until they can be transmitted or processed further. + ||| + ) + + commonlib.panels.network.timeSeries.traffic.withNegateOutPackets(), + networkCompressedPerSec: + commonlib.panels.network.timeSeries.packets.new( + 'Compressed packets', + targets=[t.networkCompressedInPerSec, t.networkCompressedOutPerSec], + description=||| + - Compressed received: + Number of correctly received compressed packets. This counters is only meaningful for interfaces which support packet compression (e.g. CSLIP, PPP). + + - Compressed transmitted: + Number of transmitted compressed packets. This counters is only meaningful for interfaces which support packet compression (e.g. CSLIP, PPP). + + https://docs.kernel.org/networking/statistics.html + |||, + ) + + commonlib.panels.network.timeSeries.traffic.withNegateOutPackets(), + networkNFConntrack: + commonlib.panels.generic.timeSeries.base.new( + 'NF conntrack', + targets=[t.networkNFConntrackEntries, t.networkNFConntrackLimits], + description=||| + NF Conntrack is a component of the Linux kernel's netfilter framework that provides stateful packet inspection to track and manage network connections, + enforce firewall rules, perform NAT, and manage network address/port translation. + ||| + ) + + g.panel.timeSeries.fieldConfig.defaults.custom.withFillOpacity(0), + + networkSoftnet: + commonlib.panels.network.timeSeries.packets.new( + 'Softnet packets', + targets=[t.networkSoftnetProcessedPerSec, t.networkSoftnetDroppedPerSec], + description=||| + Softnet packets are received by the network and queued for processing by the kernel's networking stack. + Softnet packets are usually generated by network traffic that is directed to the local host, and they are typically processed by the kernel's networking subsystem before being passed on to the relevant application. + ||| + ) + + commonlib.panels.network.timeSeries.traffic.withNegateOutPackets('/dropped/') + + g.panel.timeSeries.fieldConfig.defaults.custom.withAxisLabel('Dropped(-) | Processed(+)'), + networkSoftnetSqueeze: + commonlib.panels.network.timeSeries.packets.new( + 'Softnet out of quota', + targets=[t.networkSoftnetSqueezedPerSec], + description=||| + "Softnet out of quota" is a network-related metric in Linux that measures the number of times the kernel's softirq processing was unable to handle incoming network traffic due to insufficient softirq processing capacity. + This means that the kernel has reached its processing capacity limit for incoming packets, and any additional packets will be dropped or deferred. + ||| + ), + networkOperStatus: + commonlib.panels.network.statusHistory.interfaceStatus.new( + 'Network interfaces carrier status', + targets=[t.networkCarrier], + description='Network interfaces carrier status', + ), + networkOverviewTable: + commonlib.panels.generic.table.base.new( + 'Network interfaces overview', + targets= + [ + t.networkUp + + g.query.prometheus.withFormat('table') + + g.query.prometheus.withInstant(true) + + g.query.prometheus.withRefId('Up'), + t.networkCarrier + + g.query.prometheus.withFormat('table') + + g.query.prometheus.withInstant(true) + + g.query.prometheus.withRefId('Carrier'), + t.networkOutBitPerSec + + g.query.prometheus.withFormat('table') + + g.query.prometheus.withInstant(false) + + g.query.prometheus.withRefId('Transmitted'), + t.networkInBitPerSec + + g.query.prometheus.withFormat('table') + + g.query.prometheus.withInstant(false) + + g.query.prometheus.withRefId('Received'), + t.networkArpEntries + + g.query.prometheus.withFormat('table') + + g.query.prometheus.withInstant(true) + + g.query.prometheus.withRefId('ARP entries'), + t.networkMtuBytes + + g.query.prometheus.withFormat('table') + + g.query.prometheus.withInstant(true) + + g.query.prometheus.withRefId('MTU'), + t.networkSpeedBitsPerSec + + g.query.prometheus.withFormat('table') + + g.query.prometheus.withInstant(true) + + g.query.prometheus.withRefId('Speed'), + t.networkTransmitQueueLength + + g.query.prometheus.withFormat('table') + + g.query.prometheus.withInstant(true) + + g.query.prometheus.withRefId('Queue length'), + t.networkInfo + + g.query.prometheus.withFormat('table') + + g.query.prometheus.withInstant(true) + + g.query.prometheus.withRefId('Info'), + ], + description='Network interfaces overview.' + ) + + g.panel.table.standardOptions.withOverridesMixin([ + fieldOverride.byName.new('Speed') + + fieldOverride.byName.withPropertiesFromOptions( + table.standardOptions.withUnit('bps') + ), + ]) + + g.panel.table.standardOptions.withOverridesMixin([ + fieldOverride.byRegexp.new('Transmitted|Received') + + fieldOverride.byRegexp.withProperty('custom.displayMode', 'gradient-gauge') + + fieldOverride.byRegexp.withPropertiesFromOptions( + table.standardOptions.withUnit('bps') + + table.standardOptions.color.withMode('continuous-BlYlRd') + + table.standardOptions.withMax(1000 * 1000 * 100) + ), + ]) + + g.panel.table.standardOptions.withOverridesMixin([ + fieldOverride.byRegexp.new('Carrier|Up') + + fieldOverride.byRegexp.withProperty('custom.displayMode', 'color-text') + + fieldOverride.byRegexp.withPropertiesFromOptions( + table.standardOptions.withMappings( + { + type: 'value', + options: { + '0': { + text: 'Down', + color: 'light-red', + index: 0, + }, + '1': { + text: 'Up', + color: 'light-green', + index: 1, + }, + }, + } + ), + ), + ]) + + table.queryOptions.withTransformationsMixin( + [ + { + id: 'joinByField', + options: { + byField: 'device', + mode: 'outer', + }, + }, + { + id: 'filterFieldsByName', + options: { + include: { + pattern: 'device|duplex|address|Value.+', + }, + }, + }, + { + id: 'renameByRegex', + options: { + regex: '(Value) #(.*)', + renamePattern: '$2', + }, + }, + { + id: 'organize', + options: { + excludeByName: { + Info: true, + }, + renameByName: + { + device: 'Interface', + duplex: 'Duplex', + address: 'Address', + }, + }, + }, + { + id: 'organize', + options: { + indexByName: { + Interface: 0, + Up: 1, + Carrier: 2, + Received: 3, + Transmitted: 4, + }, + }, + }, + ] + ), + networkSockstatAll: + commonlib.panels.generic.timeSeries.base.new( + 'Sockets in use', + targets=[t.networkSocketsUsed], + description='Number of sockets currently in use.', + ), + + networkSockstatTCP: + commonlib.panels.generic.timeSeries.base.new( + 'Sockets TCP', + targets=[t.networkSocketsTCPAllocated, t.networkSocketsTCPIPv4, t.networkSocketsTCPIPv6, t.networkSocketsTCPOrphans, t.networkSocketsTCPTimeWait], + description=||| + TCP sockets are used for establishing and managing network connections between two endpoints over the TCP/IP protocol. + + Orphan sockets: If a process terminates unexpectedly or is terminated without closing its sockets properly, the sockets may become orphaned. + ||| + ), + networkSockstatUDP: + commonlib.panels.generic.timeSeries.base.new( + 'Sockets UDP', + targets=[t.networkSocketsUDPLiteInUse, t.networkSocketsUDPInUse, t.networkSocketsUDPLiteIPv6InUse, t.networkSocketsUDPIPv6InUse], + description=||| + UDP (User Datagram Protocol) and UDPlite (UDP-Lite) sockets are used for transmitting and receiving data over the UDP and UDPlite protocols, respectively. + Both UDP and UDPlite are connectionless protocols that do not provide a reliable data delivery mechanism. + ||| + ), + networkSockstatOther: + commonlib.panels.generic.timeSeries.base.new( + 'Sockets other', + targets=[t.networkSocketsFragInUse, t.networkSocketsFragIPv6InUse, t.networkSocketsRawInUse, t.networkSocketsIPv6RawInUse], + description=||| + FRAG (IP fragment) sockets: Used to receive and process fragmented IP packets. FRAG sockets are useful in network monitoring and analysis. + + RAW sockets: Allow applications to send and receive raw IP packets directly without the need for a transport protocol like TCP or UDP. + ||| + ), + networkSockstatMemory: + local panel = g.panel.timeSeries; + local override = g.panel.timeSeries.standardOptions.override; + commonlib.panels.generic.timeSeries.base.new( + title='Sockets memory', + targets=[t.networkSocketsTCPMemoryPages, t.networkSocketsUDPMemoryPages, t.networkSocketsTCPMemoryBytes, t.networkSocketsUDPMemoryBytes], + description=||| + Memory currently in use for sockets. + |||, + ) + + panel.queryOptions.withMaxDataPoints(100) + + panel.fieldConfig.defaults.custom.withAxisLabel('Pages') + + panel.standardOptions.withOverridesMixin( + panel.standardOptions.override.byRegexp.new('/bytes/') + + override.byType.withPropertiesFromOptions( + panel.standardOptions.withDecimals(2) + + panel.standardOptions.withUnit('bytes') + + panel.fieldConfig.defaults.custom.withDrawStyle('bars') + + panel.fieldConfig.defaults.custom.withStacking(value={ mode: 'normal', group: 'A' }) + + panel.fieldConfig.defaults.custom.withAxisLabel('Bytes') + ) + ), + + networkNetstatIP: + local panel = g.panel.timeSeries; + local override = g.panel.timeSeries.standardOptions.override; + commonlib.panels.network.timeSeries.packets.new( + 'IP octets', + targets=[t.networkNetstatIPInOctetsPerSec, t.networkNetstatIPOutOctetsPerSec], + description='Rate of IP octets received and transmitted.' + ) + + commonlib.panels.network.timeSeries.traffic.withNegateOutPackets() + + panel.standardOptions.withUnit('oct/s'), + + networkNetstatTCP: + local panel = g.panel.timeSeries; + local override = g.panel.timeSeries.standardOptions.override; + commonlib.panels.network.timeSeries.packets.new( + 'TCP segments', + targets=[t.networkNetstatTCPInSegmentsPerSec, t.networkNetstatTCPOutSegmentsPerSec], + description='Rate of TCP segments received and transmitted.' + ) + + commonlib.panels.network.timeSeries.traffic.withNegateOutPackets() + + panel.standardOptions.withUnit('seg/s'), + + networkNetstatTCPerrors: + local panel = g.panel.timeSeries; + local override = g.panel.timeSeries.standardOptions.override; + commonlib.panels.network.timeSeries.errors.new( + title='TCP errors rate', + targets=[ + t.networkNetstatTCPOverflowPerSec, + t.networkNetstatTCPListenDropsPerSec, + t.networkNetstatTCPRetransPerSec, + t.networkNetstatTCPRetransSegPerSec, + t.networkNetstatTCPInWithErrorsPerSec, + t.networkNetstatTCPOutWithRstPerSec, + ], + description='Rate of TCP errors.' + ) + + panel.standardOptions.withUnit('err/s'), + + networkNetstatUDP: + local panel = g.panel.timeSeries; + local override = g.panel.timeSeries.standardOptions.override; + commonlib.panels.network.timeSeries.packets.new( + 'UDP datagrams', + targets=[t.networkNetstatIPInUDPPerSec, t.networkNetstatIPOutUDPPerSec], + description='Rate of UDP datagrams received and transmitted.' + ) + + commonlib.panels.network.timeSeries.traffic.withNegateOutPackets() + + panel.standardOptions.withUnit('dat/s'), + + networkNetstatUDPerrors: + local panel = g.panel.timeSeries; + local override = g.panel.timeSeries.standardOptions.override; + commonlib.panels.network.timeSeries.errors.new( + title='UDP errors rate', + targets=[ + t.networkNetstatUDPLiteInErrorsPerSec, + t.networkNetstatUDPInErrorsPerSec, + t.networkNetstatUDP6InErrorsPerSec, + t.networkNetstatUDPNoPortsPerSec, + t.networkNetstatUDP6NoPortsPerSec, + t.networkNetstatUDPRcvBufErrsPerSec, + t.networkNetstatUDP6RcvBufErrsPerSec, + t.networkNetstatUDPSndBufErrsPerSec, + t.networkNetstatUDP6SndBufErrsPerSec, + ], + description='Rate of UDP errors.' + ) + + panel.standardOptions.withUnit('err/s'), + + networkNetstatICMP: + local panel = g.panel.timeSeries; + local override = g.panel.timeSeries.standardOptions.override; + commonlib.panels.network.timeSeries.packets.new( + 'ICMP messages', + targets=[ + t.networkNetstatICMPInPerSec, + t.networkNetstatICMPOutPerSec, + t.networkNetstatICMP6InPerSec, + t.networkNetstatICMP6OutPerSec, + ], + description="Rate of ICMP messages, like 'ping', received and transmitted." + ) + + commonlib.panels.network.timeSeries.traffic.withNegateOutPackets() + + panel.standardOptions.withUnit('msg/s'), + + networkNetstatICMPerrors: + local panel = g.panel.timeSeries; + local override = g.panel.timeSeries.standardOptions.override; + commonlib.panels.network.timeSeries.errors.new( + title='ICMP errors rate', + targets=[ + t.networkNetstatICMPInErrorsPerSec, + t.networkNetstatICM6PInErrorsPerSec, + ], + description='Rate of ICMP messages received and transmitted with errors.' + ) + + panel.standardOptions.withUnit('err/s'), + }, +} diff --git a/docs/node-observ-lib/rules.libsonnet b/docs/node-observ-lib/rules.libsonnet new file mode 100644 index 0000000000..97ed548de3 --- /dev/null +++ b/docs/node-observ-lib/rules.libsonnet @@ -0,0 +1,119 @@ +{ + new(this): { + groups+: [ + { + name: if this.config.uid == 'node' then 'node-exporter.rules' else this.config.uid + '-linux-rules', + rules: [ + { + // This rule gives the number of CPUs per node. + record: 'instance:node_num_cpu:sum', + expr: ||| + count without (cpu, mode) ( + node_cpu_seconds_total{%(filteringSelector)s,mode="idle"} + ) + ||| % this.config, + }, + { + // CPU utilisation is % CPU without {idle,iowait,steal}. + record: 'instance:node_cpu_utilisation:rate%(rateInterval)s' % this.config, + expr: ||| + 1 - avg without (cpu) ( + sum without (mode) (rate(node_cpu_seconds_total{%(filteringSelector)s, mode=~"idle|iowait|steal"}[%(rateInterval)s])) + ) + ||| % this.config, + }, + { + // This is CPU saturation: 1min avg run queue length / number of CPUs. + // Can go over 1. + // TODO: There are situation where a run queue >1/core is just normal and fine. + // We need to clarify how to read this metric and if its usage is helpful at all. + record: 'instance:node_load1_per_cpu:ratio', + expr: ||| + ( + node_load1{%(filteringSelector)s} + / + instance:node_num_cpu:sum{%(filteringSelector)s} + ) + ||| % this.config, + }, + { + // Memory utilisation (ratio of used memory per instance). + record: 'instance:node_memory_utilisation:ratio', + expr: ||| + 1 - ( + ( + node_memory_MemAvailable_bytes{%(filteringSelector)s} + or + ( + node_memory_Buffers_bytes{%(filteringSelector)s} + + + node_memory_Cached_bytes{%(filteringSelector)s} + + + node_memory_MemFree_bytes{%(filteringSelector)s} + + + node_memory_Slab_bytes{%(filteringSelector)s} + ) + ) + / + node_memory_MemTotal_bytes{%(filteringSelector)s} + ) + ||| % this.config, + }, + { + record: 'instance:node_vmstat_pgmajfault:rate%(rateInterval)s' % this.config, + expr: ||| + rate(node_vmstat_pgmajfault{%(filteringSelector)s}[%(rateInterval)s]) + ||| % this.config, + }, + { + // Disk utilisation (seconds spent, 1 second rate). + record: 'instance_device:node_disk_io_time_seconds:rate%(rateInterval)s' % this.config, + expr: ||| + rate(node_disk_io_time_seconds_total{%(filteringSelector)s, %(diskDeviceSelector)s}[%(rateInterval)s]) + ||| % this.config, + }, + { + // Disk saturation (weighted seconds spent, 1 second rate). + record: 'instance_device:node_disk_io_time_weighted_seconds:rate%(rateInterval)s' % this.config, + expr: ||| + rate(node_disk_io_time_weighted_seconds_total{%(filteringSelector)s, %(diskDeviceSelector)s}[%(rateInterval)s]) + ||| % this.config, + }, + { + record: 'instance:node_network_receive_bytes_excluding_lo:rate%(rateInterval)s' % this.config, + expr: ||| + sum without (device) ( + rate(node_network_receive_bytes_total{%(filteringSelector)s, device!="lo"}[%(rateInterval)s]) + ) + ||| % this.config, + }, + { + record: 'instance:node_network_transmit_bytes_excluding_lo:rate%(rateInterval)s' % this.config, + expr: ||| + sum without (device) ( + rate(node_network_transmit_bytes_total{%(filteringSelector)s, device!="lo"}[%(rateInterval)s]) + ) + ||| % this.config, + }, + // TODO: Find out if those drops ever happen on modern switched networks. + { + record: 'instance:node_network_receive_drop_excluding_lo:rate%(rateInterval)s' % this.config, + expr: ||| + sum without (device) ( + rate(node_network_receive_drop_total{%(filteringSelector)s, device!="lo"}[%(rateInterval)s]) + ) + ||| % this.config, + }, + { + record: 'instance:node_network_transmit_drop_excluding_lo:rate%(rateInterval)s' % this.config, + expr: ||| + sum without (device) ( + rate(node_network_transmit_drop_total{%(filteringSelector)s, device!="lo"}[%(rateInterval)s]) + ) + ||| % this.config, + }, + ], + }, + ], + }, +} diff --git a/docs/node-observ-lib/targets.libsonnet b/docs/node-observ-lib/targets.libsonnet new file mode 100644 index 0000000000..34629934ac --- /dev/null +++ b/docs/node-observ-lib/targets.libsonnet @@ -0,0 +1,1097 @@ +local g = import './g.libsonnet'; +local prometheusQuery = g.query.prometheus; +local lokiQuery = g.query.loki; + +{ + new(this): { + local variables = this.grafana.variables, + local config = this.config, + local prometheusDatasource = '${' + variables.datasources.prometheus.name + '}', + local lokiDatasource = '${' + variables.datasources.loki.name + '}', + uptimeQuery:: 'node_boot_time_seconds', + + reboot: + prometheusQuery.new( + prometheusDatasource, + self.uptimeQuery + '{%(queriesSelector)s}*1000 > $__from < $__to' % variables, + ), + + serviceFailed: + lokiQuery.new( + lokiDatasource, + '{%(queriesSelector)s, unit="init.scope"} |= "code=exited, status=1/FAILURE"' % variables + ), + // those events should be rare, so can be shown as annotations + criticalEvents: + lokiQuery.new( + lokiDatasource, + '{%(queriesSelector)s, transport="kernel", level="emerg"}' % variables + ), + memoryOOMkiller: + prometheusQuery.new( + prometheusDatasource, + 'increase(node_vmstat_oom_kill{%(queriesSelector)s}[$__interval])' % variables, + ) + + prometheusQuery.withLegendFormat('OOM killer invocations'), + + kernelUpdate: + prometheusQuery.new( + prometheusDatasource, + expr=||| + changes( + sum by (%(instanceLabels)s) ( + group by (%(instanceLabels)s,release) (node_uname_info{%(queriesSelector)s}) + ) + [$__interval:1m] offset -$__interval) > 1 + ||| % variables { instanceLabels: std.join(',', this.config.instanceLabels) }, + ), + + // new interactive session in logs: + sessionOpened: + lokiQuery.new( + lokiDatasource, + '{%(queriesSelector)s, unit="systemd-logind.service"}|= "New session"' % variables + ), + sessionClosed: + lokiQuery.new( + lokiDatasource, + '{%(queriesSelector)s, unit="systemd-logind.service"} |= "logged out"' % variables + ), + + alertsCritical: + prometheusQuery.new( + prometheusDatasource, + 'count by (%(instanceLabels)s) (max_over_time(ALERTS{%(queriesSelector)s, alertstate="firing", severity="critical"}[1m])) * group by (%(instanceLabels)s) (node_uname_info{%(queriesSelector)s})' % variables { instanceLabels: std.join(',', this.config.instanceLabels) }, + ), + alertsWarning: + prometheusQuery.new( + prometheusDatasource, + 'count by (%(instanceLabels)s) (max_over_time(ALERTS{%(queriesSelector)s, alertstate="firing", severity="warning"}[1m])) * group by (%(instanceLabels)s) (node_uname_info{%(queriesSelector)s})' % variables { instanceLabels: std.join(',', this.config.instanceLabels) }, + ), + + uptime: + prometheusQuery.new( + prometheusDatasource, + 'time() - ' + self.uptimeQuery + '{%(queriesSelector)s}' % variables + ), + cpuCount: + prometheusQuery.new( + prometheusDatasource, + 'count without (cpu) (node_cpu_seconds_total{%(queriesSelector)s, mode="idle"})' % variables + ) + + prometheusQuery.withLegendFormat('Cores'), + cpuUsage: + prometheusQuery.new( + prometheusDatasource, + ||| + (((count by (%(instanceLabels)s) (count(node_cpu_seconds_total{%(queriesSelector)s}) by (cpu, %(instanceLabels)s))) + - + avg by (%(instanceLabels)s) (sum by (%(instanceLabels)s, mode)(irate(node_cpu_seconds_total{mode='idle',%(queriesSelector)s}[$__rate_interval])))) * 100) + / + count by(%(instanceLabels)s) (count(node_cpu_seconds_total{%(queriesSelector)s}) by (cpu, %(instanceLabels)s)) + ||| % variables { instanceLabels: std.join(',', this.config.instanceLabels) }, + ) + + prometheusQuery.withLegendFormat('CPU usage'), + cpuUsagePerCore: + prometheusQuery.new( + prometheusDatasource, + ||| + ( + (1 - sum without (mode) (rate(node_cpu_seconds_total{%(queriesSelector)s, mode=~"idle|iowait|steal"}[$__rate_interval]))) + / ignoring(cpu) group_left + count without (cpu, mode) (node_cpu_seconds_total{%(queriesSelector)s, mode="idle"}) + ) * 100 + ||| % variables, + ) + + prometheusQuery.withLegendFormat('CPU {{cpu}}'), + cpuUsageByMode: + prometheusQuery.new( + prometheusDatasource, + ||| + sum by(%(instanceLabels)s, mode) (irate(node_cpu_seconds_total{%(queriesSelector)s}[$__rate_interval])) + / on(%(instanceLabels)s) + group_left sum by (%(instanceLabels)s)((irate(node_cpu_seconds_total{%(queriesSelector)s}[$__rate_interval]))) * 100 + ||| % variables { instanceLabels: std.join(',', this.config.instanceLabels) }, + ) + + prometheusQuery.withLegendFormat('{{ mode }}'), + memoryTotalBytes: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_MemTotal_bytes{%(queriesSelector)s}' % variables + ) + + prometheusQuery.withLegendFormat('Memory total'), + memoryFreeBytes: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_MemFree_bytes{%(queriesSelector)s}' % variables + ) + + prometheusQuery.withLegendFormat('Memory free'), + memoryAvailableBytes: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_MemAvailable_bytes{%(queriesSelector)s}' % variables + ) + + prometheusQuery.withLegendFormat('Memory available'), + memoryBuffersBytes: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_Cached_bytes{%(queriesSelector)s}' % variables + ) + + prometheusQuery.withLegendFormat('Memory buffers'), + memoryCachedBytes: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_Buffers_bytes{%(queriesSelector)s}' % variables + ) + + prometheusQuery.withLegendFormat('Memory buffers'), + memoryUsedBytes: + prometheusQuery.new( + prometheusDatasource, + ||| + ( + node_memory_MemTotal_bytes{%(queriesSelector)s} + - + node_memory_MemFree_bytes{%(queriesSelector)s} + - + node_memory_Buffers_bytes{%(queriesSelector)s} + - + node_memory_Cached_bytes{%(queriesSelector)s} + ) + ||| % variables + ) + + prometheusQuery.withLegendFormat('Memory used'), + memoryUsagePercent: + prometheusQuery.new( + prometheusDatasource, + ||| + 100 - + ( + avg by (%(instanceLabels)s) (node_memory_MemAvailable_bytes{%(queriesSelector)s}) / + avg by (%(instanceLabels)s) (node_memory_MemTotal_bytes{%(queriesSelector)s}) + * 100 + ) + ||| + % variables { instanceLabels: std.join(',', this.config.instanceLabels) }, + ), + memorySwapTotal: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_SwapTotal_bytes{%(queriesSelector)s}' % variables + ), + memoryPagesIn: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_vmstat_pgpgin{%(queriesSelector)s}[$__rate_interval])' % variables, + ) + + prometheusQuery.withLegendFormat('Page-In'), + memoryPagesOut: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_vmstat_pgpgout{%(queriesSelector)s}[$__rate_interval])' % variables, + ) + + prometheusQuery.withLegendFormat('Page-Out'), + + memoryPagesSwapIn: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_vmstat_pswpin{%(queriesSelector)s}[$__rate_interval])' % variables, + ) + + prometheusQuery.withLegendFormat('Pages swapped in'), + memoryPagesSwapOut: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_vmstat_pswpout{%(queriesSelector)s}[$__rate_interval])' % variables, + ) + + prometheusQuery.withLegendFormat('Pages swapped out'), + + memoryPageMajorFaults: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_vmstat_pgmajfault{%(queriesSelector)s}[$__rate_interval])' % variables, + ) + + prometheusQuery.withLegendFormat('Major page fault operations'), + memoryPageMinorFaults: + prometheusQuery.new( + prometheusDatasource, + ||| + irate(node_vmstat_pgfault{%(queriesSelector)s}[$__rate_interval]) + - + irate(node_vmstat_pgmajfault{%(queriesSelector)s}[$__rate_interval]) + ||| % variables, + ) + + prometheusQuery.withLegendFormat('Minor page fault operations'), + + memoryInactiveBytes: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_Inactive_bytes{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('Inactive'), + memoryActiveBytes: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_Active_bytes{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('Active'), + + memoryInactiveFile: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_Inactive_file_bytes{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('Inactive_file'), + + memoryInactiveAnon: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_Inactive_anon_bytes{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('Inactive_anon'), + + memoryActiveFile: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_Active_file_bytes{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('Active_file'), + + memoryActiveAnon: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_Active_anon_bytes{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('Active_anon'), + + memoryCommitedAs: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_Committed_AS_bytes{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('Commited_AS'), + memoryCommitedLimit: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_CommitLimit_bytes{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('CommitLimit'), + + memoryMappedBytes: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_Mapped_bytes{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('Mapped'), + memoryShmemBytes: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_Shmem_bytes{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('Shmem'), + memoryShmemHugePagesBytes: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_ShmemHugePages_bytes{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('ShmemHugePages'), + memoryShmemPmdMappedBytes: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_ShmemPmdMapped_bytes{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('ShmemPmdMapped'), + memoryWriteback: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_Writeback_bytes{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('Writeback'), + memoryWritebackTmp: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_WritebackTmp_bytes{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('WritebackTmp'), + memoryDirty: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_Dirty_bytes{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('Dirty'), + + memoryVmallocChunk: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_VmallocChunk_bytes{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('VmallocChunk'), + memoryVmallocTotal: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_VmallocTotal_bytes{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('VmallocTotal'), + memoryVmallocUsed: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_VmallocUsed_bytes{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('VmallocUsed'), + memorySlabSUnreclaim: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_SUnreclaim_bytes{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('SUnreclaim'), + memorySlabSReclaimable: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_SReclaimable_bytes{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('SReclaimable'), + + memoryAnonHugePages: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_AnonHugePages_bytes{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('AnonHugePages'), + memoryAnonPages: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_AnonPages_bytes{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('AnonPages'), + + memoryHugePages_Free: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_HugePages_Free{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('HugePages_Free'), + memoryHugePages_Rsvd: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_HugePages_Rsvd{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('HugePages_Rsvd'), + memoryHugePages_Surp: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_HugePages_Surp{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('HugePages_Surp'), + memoryHugePagesTotalSize: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_HugePages_Total{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('Huge pages total size'), + memoryHugePagesSize: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_Hugepagesize_bytes{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('Huge page size'), + memoryDirectMap1G: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_DirectMap1G_bytes{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('DirectMap1G'), + memoryDirectMap2M: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_DirectMap2M_bytes{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('DirectMap2M'), + memoryDirectMap4k: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_DirectMap4k_bytes{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('DirectMap4k'), + memoryBounce: + prometheusQuery.new( + prometheusDatasource, + 'node_memory_Bounce_bytes{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('Bounce'), + + diskTotal: + prometheusQuery.new( + prometheusDatasource, + 'node_filesystem_size_bytes{%(fsSelector)s, %(fsMountpointSelector)s, %(queriesSelector)s}' % variables { fsMountpointSelector: config.fsMountpointSelector, fsSelector: config.fsSelector } + ), + diskTotalRoot: + prometheusQuery.new( + prometheusDatasource, + 'node_filesystem_size_bytes{%(queriesSelector)s, mountpoint="/", fstype!="rootfs"}' % variables, + ), + diskUsageRoot: + prometheusQuery.new( + prometheusDatasource, + 'node_filesystem_avail_bytes{%(queriesSelector)s, mountpoint="/",fstype!="rootfs"}' % variables + ), + diskUsageRootPercent: + prometheusQuery.new( + prometheusDatasource, + '100 - node_filesystem_avail_bytes{mountpoint="/",fstype!="rootfs", %(queriesSelector)s}/node_filesystem_size_bytes{mountpoint="/",fstype!="rootfs", %(queriesSelector)s}*100' % variables + ), + diskFree: + prometheusQuery.new( + prometheusDatasource, + 'node_filesystem_avail_bytes{%(fsSelector)s, %(fsMountpointSelector)s, %(queriesSelector)s}' % variables { fsMountpointSelector: config.fsMountpointSelector, fsSelector: config.fsSelector } + ) + + prometheusQuery.withLegendFormat('{{ mountpoint }} free'), + diskUsagePercent: + prometheusQuery.new( + prometheusDatasource, + '100 - node_filesystem_avail_bytes{%(fsSelector)s, %(fsMountpointSelector)s, %(queriesSelector)s}/node_filesystem_size_bytes{%(fsSelector)s, %(fsMountpointSelector)s, %(queriesSelector)s}*100' % variables { fsMountpointSelector: config.fsMountpointSelector, fsSelector: config.fsSelector } + ) + + prometheusQuery.withLegendFormat('{{ mountpoint }} used, %'), + + diskInodesFree: + prometheusQuery.new( + prometheusDatasource, + 'node_filesystem_files_free{%(queriesSelector)s, %(fsSelector)s, %(fsMountpointSelector)s}' % variables { fsMountpointSelector: config.fsMountpointSelector, fsSelector: config.fsSelector }, + ) + + prometheusQuery.withLegendFormat('{{ mountpoint }} inodes free'), + diskInodesTotal: + prometheusQuery.new( + prometheusDatasource, + 'node_filesystem_files{%(queriesSelector)s, %(fsSelector)s, %(fsMountpointSelector)s}' % variables { fsMountpointSelector: config.fsMountpointSelector, fsSelector: config.fsSelector } + ) + prometheusQuery.withLegendFormat('{{ mountpoint }} inodes total'), + diskReadOnly: + prometheusQuery.new( + prometheusDatasource, + 'node_filesystem_readonly{%(queriesSelector)s, %(fsSelector)s, %(fsMountpointSelector)s}' % variables { fsMountpointSelector: config.fsMountpointSelector, fsSelector: config.fsSelector } + ) + + prometheusQuery.withLegendFormat('{{ mountpoint }} read-only'), + diskDeviceError: + prometheusQuery.new( + prometheusDatasource, + 'node_filesystem_device_error{%(queriesSelector)s, %(fsSelector)s, %(fsMountpointSelector)s}' % variables { fsMountpointSelector: config.fsMountpointSelector, fsSelector: config.fsSelector } + ) + + prometheusQuery.withLegendFormat('{{ mountpoint }} device error'), + // descriptors + processMaxFds: + prometheusQuery.new( + prometheusDatasource, + 'process_max_fds{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('Maximum open file descriptors'), + processOpenFds: + prometheusQuery.new( + prometheusDatasource, + 'process_open_fds{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('Open file descriptors'), + + // disk(device) + diskIOreadBytesPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_disk_reads_completed_total{%(queriesSelector)s, %(diskDeviceSelector)s}[$__rate_interval])' % variables { diskDeviceSelector: config.diskDeviceSelector }, + ) + + prometheusQuery.withLegendFormat('{{ device }} read'), + diskIOwriteBytesPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_disk_writes_completed_total{%(queriesSelector)s, %(diskDeviceSelector)s}[$__rate_interval])' % variables { diskDeviceSelector: config.diskDeviceSelector }, + ) + + prometheusQuery.withLegendFormat('{{ device }} written'), + diskIOutilization: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_disk_io_time_seconds_total{%(queriesSelector)s, %(diskDeviceSelector)s}[$__rate_interval])' % variables { diskDeviceSelector: config.diskDeviceSelector }, + ) + + prometheusQuery.withLegendFormat('{{ device }} io util'), + diskAvgQueueSize: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_disk_io_time_weighted_seconds_total{%(queriesSelector)s, %(diskDeviceSelector)s}[$__rate_interval])' % variables { diskDeviceSelector: config.diskDeviceSelector }, + ) + + prometheusQuery.withLegendFormat('{{ device }} avg queue'), + + diskIOWaitWriteTime: + prometheusQuery.new( + prometheusDatasource, + ||| + irate(node_disk_write_time_seconds_total{%(queriesSelector)s, %(diskDeviceSelector)s}[$__rate_interval]) + / + irate(node_disk_writes_completed_total{%(queriesSelector)s, %(diskDeviceSelector)s}[$__rate_interval]) + ||| % variables { diskDeviceSelector: config.diskDeviceSelector } + ) + + prometheusQuery.withLegendFormat('{{ device }} avg write time'), + diskIOWaitReadTime: + prometheusQuery.new( + prometheusDatasource, + ||| + irate(node_disk_read_time_seconds_total{%(queriesSelector)s, %(diskDeviceSelector)s}[$__rate_interval]) + / + irate(node_disk_reads_completed_total{%(queriesSelector)s, %(diskDeviceSelector)s}[$__rate_interval]) + ||| % variables { diskDeviceSelector: config.diskDeviceSelector } + ) + + prometheusQuery.withLegendFormat('{{ device }} avg read time'), + diskIOReads: + prometheusQuery.new( + prometheusDatasource, + ||| + irate(node_disk_reads_completed_total{%(queriesSelector)s, %(diskDeviceSelector)s}[$__rate_interval]) + ||| % variables { diskDeviceSelector: config.diskDeviceSelector } + ) + + prometheusQuery.withLegendFormat('{{ device }} reads'), + diskIOWrites: + prometheusQuery.new( + prometheusDatasource, + ||| + irate(node_disk_writes_completed_total{%(queriesSelector)s, %(diskDeviceSelector)s}[$__rate_interval]) + ||| % variables { diskDeviceSelector: config.diskDeviceSelector } + ) + + prometheusQuery.withLegendFormat('{{ device }} writes'), + + unameInfo: + prometheusQuery.new( + prometheusDatasource, + 'node_uname_info{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withFormat('table'), + osInfo: + prometheusQuery.new( + prometheusDatasource, + ||| + node_os_info{%(queriesSelector)s} + ||| % variables, + ) + + prometheusQuery.withFormat('table'), + osInfoCombined: + prometheusQuery.new( + prometheusDatasource, + ||| + node_uname_info{%(queriesSelector)s} + * on (%(groupLabels)s,%(instanceLabels)s) + group_left(pretty_name) + node_os_info{%(queriesSelector)s} + ||| % variables { + instanceLabels: std.join(',', this.config.instanceLabels), + groupLabels: std.join(',', this.config.groupLabels), + }, + ) + + prometheusQuery.withFormat('table'), + + osTimezone: //timezone label + prometheusQuery.new( + prometheusDatasource, + 'node_time_zone_offset_seconds{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withFormat('table'), + + systemLoad1: + prometheusQuery.new( + prometheusDatasource, + 'node_load1{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('1m'), + systemLoad5: + prometheusQuery.new( + prometheusDatasource, + 'node_load5{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('5m'), + systemLoad15: + prometheusQuery.new( + prometheusDatasource, + 'node_load15{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('15m'), + + systemContextSwitches: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_context_switches_total{%(queriesSelector)s}[$__rate_interval])' % variables, + ) + + prometheusQuery.withLegendFormat('Context switches'), + + systemInterrupts: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_intr_total{%(queriesSelector)s}[$__rate_interval])' % variables, + ) + + prometheusQuery.withLegendFormat('Interrupts'), + + timeNtpStatus: + prometheusQuery.new( + prometheusDatasource, + 'node_timex_sync_status{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('NTP status'), + + timeOffset: + prometheusQuery.new( + prometheusDatasource, + 'node_timex_offset_seconds{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('Time offset'), + + timeEstimatedError: + prometheusQuery.new( + prometheusDatasource, + 'node_timex_estimated_error_seconds{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('Estimated error in seconds'), + timeMaxError: + prometheusQuery.new( + prometheusDatasource, + 'node_timex_maxerror_seconds{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('Maximum error in seconds'), + + networkUp: + prometheusQuery.new( + prometheusDatasource, + 'node_network_up{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('{{device}}'), + networkCarrier: + prometheusQuery.new( + prometheusDatasource, + 'node_network_carrier{%(queriesSelector)s}' % variables, + ) + + prometheusQuery.withLegendFormat('{{device}}'), + networkArpEntries: + prometheusQuery.new( + prometheusDatasource, + 'node_network_arp{%(queriesSelector)s}' % variables, + ), + networkMtuBytes: + prometheusQuery.new( + prometheusDatasource, + 'node_network_mtu_bytes{%(queriesSelector)s}' % variables, + ), + networkSpeedBitsPerSec: + prometheusQuery.new( + prometheusDatasource, + 'node_network_speed_bytes{%(queriesSelector)s} * 8' % variables, + ), + networkTransmitQueueLength: + prometheusQuery.new( + prometheusDatasource, + 'node_network_transmit_queue_length{%(queriesSelector)s}' % variables, + ), + networkInfo: + prometheusQuery.new( + prometheusDatasource, + 'node_network_info{%(queriesSelector)s}' % variables, + ), + + networkOutBitPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_network_transmit_bytes_total{%(queriesSelector)s}[$__rate_interval])*8' % variables + ) + + prometheusQuery.withLegendFormat('{{ device }} transmitted'), + networkInBitPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_network_receive_bytes_total{%(queriesSelector)s}[$__rate_interval])*8' % variables + ) + + prometheusQuery.withLegendFormat('{{ device }} received'), + networkOutErrorsPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_network_transmit_errs_total{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('{{ device }} errors transmitted'), + networkInErrorsPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_network_receive_errs_total{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('{{ device }} errors received'), + networkOutDroppedPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_network_transmit_drop_total{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('{{ device }} transmitted dropped'), + networkInDroppedPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_network_receive_drop_total{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('{{ device }} received dropped'), + + networkInPacketsPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_network_receive_packets_total{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('{{ device }} received'), + networkOutPacketsPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_network_transmit_packets_total{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('{{ device }} transmitted'), + + networkInMulticastPacketsPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_network_receive_multicast_total{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('{{ device }} received'), + networkOutMulticastPacketsPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_network_transmit_multicast_total{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('{{ device }} transmitted'), + networkFifoInPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_network_receive_fifo_total{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('{{ device }} received'), + networkFifoOutPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_network_transmit_fifo_total{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('{{ device }} transmitted'), + + networkCompressedInPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_network_receive_compressed_total{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('{{ device }} received'), + networkCompressedOutPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_network_transmit_compressed_total{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('{{ device }} transmitted'), + + networkNFConntrackEntries: + prometheusQuery.new( + prometheusDatasource, + 'node_nf_conntrack_entries{%(queriesSelector)s}' % variables + ) + + prometheusQuery.withLegendFormat('NF conntrack entries'), + networkNFConntrackLimits: + prometheusQuery.new( + prometheusDatasource, + 'node_nf_conntrack_entries_limit{%(queriesSelector)s}' % variables + ) + + prometheusQuery.withLegendFormat('NF conntrack limits'), + + networkSoftnetProcessedPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_softnet_processed_total{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('CPU {{ cpu }} processed'), + networkSoftnetDroppedPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_softnet_dropped_total{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('CPU {{ cpu }} dropped'), + networkSoftnetSqueezedPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_softnet_times_squeezed_total{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('CPU {{ cpu }} out of quota'), + + networkSocketsUsed: + prometheusQuery.new( + prometheusDatasource, + 'node_sockstat_sockets_used{%(queriesSelector)s}' % variables + ) + + prometheusQuery.withLegendFormat('IPv4 sockets in use'), + networkSocketsTCPAllocated: + prometheusQuery.new( + prometheusDatasource, + 'node_sockstat_TCP_alloc{%(queriesSelector)s}' % variables + ) + + prometheusQuery.withLegendFormat('Allocated'), + networkSocketsTCPIPv6: + prometheusQuery.new( + prometheusDatasource, + 'node_sockstat_TCP6_inuse{%(queriesSelector)s}' % variables + ) + + prometheusQuery.withLegendFormat('IPv6 in use'), + networkSocketsTCPIPv4: + prometheusQuery.new( + prometheusDatasource, + 'node_sockstat_TCP_inuse{%(queriesSelector)s}' % variables + ) + + prometheusQuery.withLegendFormat('IPv4 in use'), + networkSocketsTCPOrphans: + prometheusQuery.new( + prometheusDatasource, + 'node_sockstat_TCP_orphan{%(queriesSelector)s}' % variables + ) + + prometheusQuery.withLegendFormat('Orphan sockets'), + networkSocketsTCPTimeWait: + prometheusQuery.new( + prometheusDatasource, + 'node_sockstat_TCP_tw{%(queriesSelector)s}' % variables + ) + + prometheusQuery.withLegendFormat('Time wait'), + + networkSocketsUDPLiteInUse: + prometheusQuery.new( + prometheusDatasource, + 'node_sockstat_UDPLITE_inuse{%(queriesSelector)s}' % variables + ) + + prometheusQuery.withLegendFormat('IPv4 UDPLITE in use'), + networkSocketsUDPInUse: + prometheusQuery.new( + prometheusDatasource, + 'node_sockstat_UDP_inuse{%(queriesSelector)s}' % variables + ) + + prometheusQuery.withLegendFormat('IPv4 UDP in use'), + networkSocketsUDPLiteIPv6InUse: + prometheusQuery.new( + prometheusDatasource, + 'node_sockstat_UDPLITE6_inuse{%(queriesSelector)s}' % variables + ) + + prometheusQuery.withLegendFormat('IPv6 UDPLITE in use'), + networkSocketsUDPIPv6InUse: + prometheusQuery.new( + prometheusDatasource, + 'node_sockstat_UDP6_inuse{%(queriesSelector)s}' % variables + ) + + prometheusQuery.withLegendFormat('IPv6 UDP in use'), + + networkSocketsFragInUse: + prometheusQuery.new( + prometheusDatasource, + 'node_sockstat_FRAG_inuse{%(queriesSelector)s}' % variables + ) + + prometheusQuery.withLegendFormat('IPv4 Frag sockets in use'), + networkSocketsFragIPv6InUse: + prometheusQuery.new( + prometheusDatasource, + 'node_sockstat_FRAG6_inuse{%(queriesSelector)s}' % variables + ) + + prometheusQuery.withLegendFormat('IPv6 Frag sockets in use'), + networkSocketsRawInUse: + prometheusQuery.new( + prometheusDatasource, + 'node_sockstat_RAW_inuse{%(queriesSelector)s}' % variables + ) + + prometheusQuery.withLegendFormat('IPv4 Raw sockets in use'), + networkSocketsIPv6RawInUse: + prometheusQuery.new( + prometheusDatasource, + 'node_sockstat_RAW6_inuse{%(queriesSelector)s}' % variables + ) + + prometheusQuery.withLegendFormat('IPv6 Raw sockets in use'), + + networkSocketsTCPMemoryPages: + prometheusQuery.new( + prometheusDatasource, + 'node_sockstat_TCP_mem{%(queriesSelector)s}' % variables + ) + + prometheusQuery.withLegendFormat('Memory pages allocated for TCP sockets'), + networkSocketsUDPMemoryPages: + prometheusQuery.new( + prometheusDatasource, + 'node_sockstat_UDP_mem{%(queriesSelector)s}' % variables + ) + + prometheusQuery.withLegendFormat('Memory pages allocated for UDP sockets'), + + networkSocketsTCPMemoryBytes: + prometheusQuery.new( + prometheusDatasource, + 'node_sockstat_TCP_mem_bytes{%(queriesSelector)s}' % variables + ) + + prometheusQuery.withLegendFormat('Memory bytes allocated for TCP sockets'), + networkSocketsUDPMemoryBytes: + prometheusQuery.new( + prometheusDatasource, + 'node_sockstat_UDP_mem_bytes{%(queriesSelector)s}' % variables + ) + + prometheusQuery.withLegendFormat('Memory bytes allocated for UDP sockets'), + + networkNetstatIPInOctetsPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_netstat_IpExt_InOctets{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('Octets received'), + networkNetstatIPOutOctetsPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_netstat_IpExt_OutOctets{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('Octets transmitted'), + + networkNetstatTCPInSegmentsPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_netstat_Tcp_InSegs{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('TCP received'), + networkNetstatTCPOutSegmentsPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_netstat_Tcp_OutSegs{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('TCP transmitted'), + + networkNetstatTCPOverflowPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_netstat_TcpExt_ListenOverflows{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('TCP overflow'), + + networkNetstatTCPListenDropsPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_netstat_TcpExt_ListenDrops{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('TCP ListenDrops - SYNs to LISTEN sockets ignored'), + + networkNetstatTCPRetransPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_netstat_TcpExt_TCPSynRetrans{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('TCP SYN rentransmits'), + + networkNetstatTCPRetransSegPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_netstat_Tcp_RetransSegs{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('TCP retransmitted segments, containing one or more previously transmitted octets'), + networkNetstatTCPInWithErrorsPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_netstat_Tcp_InErrs{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('TCP received with errors'), + + networkNetstatTCPOutWithRstPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_netstat_Tcp_OutRsts{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('TCP segments sent with RST flag'), + + networkNetstatIPInUDPPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_netstat_Udp_InDatagrams{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('UDP received'), + + networkNetstatIPOutUDPPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_netstat_Udp_OutDatagrams{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('UDP transmitted'), + + //UDP errors + networkNetstatUDPLiteInErrorsPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_netstat_UdpLite_InErrors{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('UDPLite InErrors'), + + networkNetstatUDPInErrorsPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_netstat_Udp_InErrors{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('UDP InErrors'), + networkNetstatUDP6InErrorsPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_netstat_Udp6_InErrors{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('UDP6 InErrors'), + networkNetstatUDPNoPortsPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_netstat_Udp_NoPorts{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('UDP NoPorts'), + networkNetstatUDP6NoPortsPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_netstat_Udp6_NoPorts{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('UDP6 NoPorts'), + networkNetstatUDPRcvBufErrsPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_netstat_Udp_RcvbufErrors{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('UDP receive buffer errors'), + networkNetstatUDP6RcvBufErrsPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_netstat_Udp6_RcvbufErrors{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('UDP6 receive buffer errors'), + networkNetstatUDPSndBufErrsPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_netstat_Udp_SndbufErrors{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('UDP transmit buffer errors'), + networkNetstatUDP6SndBufErrsPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_netstat_Udp6_SndbufErrors{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('UDP6 transmit buffer errors'), + + //ICMP + networkNetstatICMPInPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_netstat_Icmp_InMsgs{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('ICMP received'), + networkNetstatICMPOutPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_netstat_Icmp_OutMsgs{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('ICMP transmitted'), + networkNetstatICMP6InPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_netstat_Icmp6_InMsgs{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('ICMP6 received'), + networkNetstatICMP6OutPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_netstat_Icmp6_OutMsgs{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('ICMP6 transmitted'), + + networkNetstatICMPInErrorsPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_netstat_Icmp_InErrors{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('ICMP6 errors'), + networkNetstatICM6PInErrorsPerSec: + prometheusQuery.new( + prometheusDatasource, + 'irate(node_netstat_Icmp6_InErrors{%(queriesSelector)s}[$__rate_interval])' % variables + ) + + prometheusQuery.withLegendFormat('ICMP6 errors'), + }, +} diff --git a/docs/node-observ-lib/variables.libsonnet b/docs/node-observ-lib/variables.libsonnet new file mode 100644 index 0000000000..c9b2cb3ad4 --- /dev/null +++ b/docs/node-observ-lib/variables.libsonnet @@ -0,0 +1,71 @@ +// variables.libsonnet +local g = import './g.libsonnet'; +local var = g.dashboard.variable; +local commonlib = import 'common-lib/common/main.libsonnet'; +local utils = commonlib.utils; + +{ + new( + this + ): { + local filteringSelector = this.config.filteringSelector, + local groupLabels = this.config.groupLabels, + local instanceLabels = this.config.instanceLabels, + local root = self, + local varMetric = 'node_uname_info', + local variablesFromLabels(groupLabels, instanceLabels, filteringSelector, multiInstance=true) = + local chainVarProto(index, chainVar) = + var.query.new(chainVar.label) + + var.query.withDatasourceFromVariable(root.datasources.prometheus) + + var.query.queryTypes.withLabelValues( + chainVar.label, + '%s{%s}' % [varMetric, chainVar.chainSelector], + ) + + var.query.generalOptions.withLabel(utils.toSentenceCase(chainVar.label)) + + var.query.selectionOptions.withIncludeAll( + value=if (!multiInstance && std.member(instanceLabels, chainVar.label)) then false else true, + customAllValue='.+' + ) + + var.query.selectionOptions.withMulti( + if (!multiInstance && std.member(instanceLabels, chainVar.label)) then false else true, + ) + + var.query.refresh.onTime() + + var.query.withSort( + i=1, + type='alphabetical', + asc=true, + caseInsensitive=false + ); + std.mapWithIndex(chainVarProto, utils.chainLabels(groupLabels + instanceLabels, [filteringSelector])), + datasources: { + prometheus: + var.datasource.new('datasource', 'prometheus') + + var.datasource.generalOptions.withLabel('Data source') + + var.datasource.withRegex(''), + loki: + var.datasource.new('loki_datasource', 'loki') + + var.datasource.generalOptions.withLabel('Loki data source') + + var.datasource.withRegex('') + + var.datasource.generalOptions.showOnDashboard.withNothing(), + }, + // Use on dashboards where multiple entities can be selected, like fleet dashboards + multiInstance: + [root.datasources.prometheus] + + variablesFromLabels(groupLabels, instanceLabels, filteringSelector), + // Use on dashboards where only single entity can be selected + singleInstance: + [root.datasources.prometheus] + + variablesFromLabels(groupLabels, instanceLabels, filteringSelector, multiInstance=false), + + queriesSelector: + '%s,%s' % [ + filteringSelector, + utils.labelsToPromQLSelector(groupLabels + instanceLabels), + ], + } + + if this.config.enableLokiLogs then self.withLokiLogs(this) else {}, + withLokiLogs(this): { + multiInstance+: [this.grafana.variables.datasources.loki], + singleInstance+: [this.grafana.variables.datasources.loki], + }, +} diff --git a/docs/node-observ-lib/vendor/common-lib b/docs/node-observ-lib/vendor/common-lib new file mode 120000 index 0000000000..5d4320e59f --- /dev/null +++ b/docs/node-observ-lib/vendor/common-lib @@ -0,0 +1 @@ +github.com/grafana/jsonnet-libs/common-lib \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/doc-util b/docs/node-observ-lib/vendor/doc-util new file mode 120000 index 0000000000..dcfde67cf6 --- /dev/null +++ b/docs/node-observ-lib/vendor/doc-util @@ -0,0 +1 @@ +github.com/jsonnet-libs/docsonnet/doc-util \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/alerting.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/alerting.libsonnet new file mode 100644 index 0000000000..621020b723 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/alerting.libsonnet @@ -0,0 +1,9 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.alerting', name: 'alerting' }, + contactPoint: import 'clean/alerting/contactPoint.libsonnet', + notificationPolicy: import 'clean/alerting/notificationPolicy.libsonnet', + muteTiming: import 'clean/alerting/muteTiming.libsonnet', + ruleGroup: import 'clean/alerting/ruleGroup.libsonnet', + messageTemplate: import 'clean/alerting/messageTemplate.libsonnet', +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/alerting/contactPoint.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/alerting/contactPoint.libsonnet new file mode 100644 index 0000000000..a984205e75 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/alerting/contactPoint.libsonnet @@ -0,0 +1,19 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.alerting.contactPoint', name: 'contactPoint' }, + '#withDisableResolveMessage': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withDisableResolveMessage(value=true): { disableResolveMessage: value }, + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Name is used as grouping key in the UI. Contact points with the\nsame name will be grouped in the UI.' } }, + withName(value): { name: value }, + '#withProvenance': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withProvenance(value): { provenance: value }, + '#withSettings': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettings(value): { settings: value }, + '#withSettingsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettingsMixin(value): { settings+: value }, + '#withType': { 'function': { args: [{ default: null, enums: ['alertmanager', ' dingding', ' discord', ' email', ' googlechat', ' kafka', ' line', ' opsgenie', ' pagerduty', ' pushover', ' sensugo', ' slack', ' teams', ' telegram', ' threema', ' victorops', ' webhook', ' wecom'], name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + '#withUid': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'UID is the unique identifier of the contact point. The UID can be\nset by the user.' } }, + withUid(value): { uid: value }, +} ++ (import '../../custom/alerting/contactPoint.libsonnet') diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/alerting/messageTemplate.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/alerting/messageTemplate.libsonnet new file mode 100644 index 0000000000..92c0a424db --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/alerting/messageTemplate.libsonnet @@ -0,0 +1,8 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.alerting.messageTemplate', name: 'messageTemplate' }, + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withName(value): { name: value }, + '#withTemplate': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withTemplate(value): { template: value }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/alerting/muteTiming.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/alerting/muteTiming.libsonnet new file mode 100644 index 0000000000..d59987d2fb --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/alerting/muteTiming.libsonnet @@ -0,0 +1,69 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.alerting.muteTiming', name: 'muteTiming' }, + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withName(value): { name: value }, + '#withTimeIntervals': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTimeIntervals(value): { time_intervals: (if std.isArray(value) + then value + else [value]) }, + '#withTimeIntervalsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTimeIntervalsMixin(value): { time_intervals+: (if std.isArray(value) + then value + else [value]) }, + interval+: + { + '#': { help: '', name: 'interval' }, + '#withDaysOfMonth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withDaysOfMonth(value): { days_of_month: (if std.isArray(value) + then value + else [value]) }, + '#withDaysOfMonthMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withDaysOfMonthMixin(value): { days_of_month+: (if std.isArray(value) + then value + else [value]) }, + '#withLocation': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withLocation(value): { location: value }, + '#withMonths': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withMonths(value): { months: (if std.isArray(value) + then value + else [value]) }, + '#withMonthsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withMonthsMixin(value): { months+: (if std.isArray(value) + then value + else [value]) }, + '#withTimes': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTimes(value): { times: (if std.isArray(value) + then value + else [value]) }, + '#withTimesMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTimesMixin(value): { times+: (if std.isArray(value) + then value + else [value]) }, + times+: + { + '#': { help: '', name: 'times' }, + '#withFrom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withFrom(value): { from: value }, + '#withTo': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withTo(value): { to: value }, + }, + '#withWeekdays': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withWeekdays(value): { weekdays: (if std.isArray(value) + then value + else [value]) }, + '#withWeekdaysMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withWeekdaysMixin(value): { weekdays+: (if std.isArray(value) + then value + else [value]) }, + '#withYears': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withYears(value): { years: (if std.isArray(value) + then value + else [value]) }, + '#withYearsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withYearsMixin(value): { years+: (if std.isArray(value) + then value + else [value]) }, + }, +} ++ (import '../../custom/alerting/muteTiming.libsonnet') diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/alerting/notificationPolicy.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/alerting/notificationPolicy.libsonnet new file mode 100644 index 0000000000..f2c8c79dc7 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/alerting/notificationPolicy.libsonnet @@ -0,0 +1,57 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.alerting.notificationPolicy', name: 'notificationPolicy' }, + '#withContinue': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withContinue(value=true): { continue: value }, + '#withGroupInterval': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withGroupInterval(value): { group_interval: value }, + '#withGroupWait': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withGroupWait(value): { group_wait: value }, + '#withRepeatInterval': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withRepeatInterval(value): { repeat_interval: value }, + '#withGroupBy': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withGroupBy(value): { group_by: (if std.isArray(value) + then value + else [value]) }, + '#withGroupByMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withGroupByMixin(value): { group_by+: (if std.isArray(value) + then value + else [value]) }, + '#withMatchers': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Matchers is a slice of Matchers that is sortable, implements Stringer, and\nprovides a Matches method to match a LabelSet against all Matchers in the\nslice. Note that some users of Matchers might require it to be sorted.' } }, + withMatchers(value): { matchers: (if std.isArray(value) + then value + else [value]) }, + '#withMatchersMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Matchers is a slice of Matchers that is sortable, implements Stringer, and\nprovides a Matches method to match a LabelSet against all Matchers in the\nslice. Note that some users of Matchers might require it to be sorted.' } }, + withMatchersMixin(value): { matchers+: (if std.isArray(value) + then value + else [value]) }, + '#withMuteTimeIntervals': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withMuteTimeIntervals(value): { mute_time_intervals: (if std.isArray(value) + then value + else [value]) }, + '#withMuteTimeIntervalsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withMuteTimeIntervalsMixin(value): { mute_time_intervals+: (if std.isArray(value) + then value + else [value]) }, + '#withReceiver': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withReceiver(value): { receiver: value }, + '#withRoutes': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withRoutes(value): { routes: (if std.isArray(value) + then value + else [value]) }, + '#withRoutesMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withRoutesMixin(value): { routes+: (if std.isArray(value) + then value + else [value]) }, + matcher+: + { + '#': { help: '', name: 'matcher' }, + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withName(value): { Name: value }, + '#withType': { 'function': { args: [{ default: null, enums: ['=', '!=', '=~', '!~'], name: 'value', type: 'string' }], help: 'MatchType is an enum for label matching types.' } }, + withType(value): { Type: value }, + '#withValue': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withValue(value): { Value: value }, + }, +} ++ (import '../../custom/alerting/notificationPolicy.libsonnet') diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/alerting/ruleGroup.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/alerting/ruleGroup.libsonnet new file mode 100644 index 0000000000..2f31e7b0e1 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/alerting/ruleGroup.libsonnet @@ -0,0 +1,75 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.alerting.ruleGroup', name: 'ruleGroup' }, + '#withFolderUid': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withFolderUid(value): { folderUid: value }, + '#withInterval': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withInterval(value): { interval: value }, + '#withRules': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withRules(value): { rules: (if std.isArray(value) + then value + else [value]) }, + '#withRulesMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withRulesMixin(value): { rules+: (if std.isArray(value) + then value + else [value]) }, + '#withTitle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withTitle(value): { title: value }, + rule+: + { + '#withAnnotations': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withAnnotations(value): { annotations: value }, + '#withAnnotationsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withAnnotationsMixin(value): { annotations+: value }, + '#withCondition': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withCondition(value): { condition: value }, + '#withData': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withData(value): { data: (if std.isArray(value) + then value + else [value]) }, + '#withDataMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withDataMixin(value): { data+: (if std.isArray(value) + then value + else [value]) }, + '#withExecErrState': { 'function': { args: [{ default: null, enums: ['OK', 'Alerting', 'Error'], name: 'value', type: 'string' }], help: '' } }, + withExecErrState(value): { execErrState: value }, + '#withFor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'A Duration represents the elapsed time between two instants\nas an int64 nanosecond count. The representation limits the\nlargest representable duration to approximately 290 years.' } }, + withFor(value): { 'for': value }, + '#withIsPaused': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withIsPaused(value=true): { isPaused: value }, + '#withLabels': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withLabels(value): { labels: value }, + '#withLabelsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withLabelsMixin(value): { labels+: value }, + '#withNoDataState': { 'function': { args: [{ default: null, enums: ['Alerting', 'NoData', 'OK'], name: 'value', type: 'string' }], help: '' } }, + withNoDataState(value): { noDataState: value }, + '#withTitle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withTitle(value): { title: value }, + data+: + { + '#': { help: '', name: 'data' }, + '#withDatasourceUid': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: "Grafana data source unique identifier; it should be '__expr__' for a Server Side Expression operation." } }, + withDatasourceUid(value): { datasourceUid: value }, + '#withModel': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'JSON is the raw JSON query and includes the above properties as well as custom properties.' } }, + withModel(value): { model: value }, + '#withModelMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'JSON is the raw JSON query and includes the above properties as well as custom properties.' } }, + withModelMixin(value): { model+: value }, + '#withQueryType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'QueryType is an optional identifier for the type of query.\nIt can be used to distinguish different types of queries.' } }, + withQueryType(value): { queryType: value }, + '#withRefId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'RefID is the unique identifier of the query, set by the frontend call.' } }, + withRefId(value): { refId: value }, + '#withRelativeTimeRange': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'RelativeTimeRange is the per query start and end time\nfor requests.' } }, + withRelativeTimeRange(value): { relativeTimeRange: value }, + '#withRelativeTimeRangeMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'RelativeTimeRange is the per query start and end time\nfor requests.' } }, + withRelativeTimeRangeMixin(value): { relativeTimeRange+: value }, + relativeTimeRange+: + { + '#withFrom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'A Duration represents the elapsed time between two instants\nas an int64 nanosecond count. The representation limits the\nlargest representable duration to approximately 290 years.' } }, + withFrom(value): { relativeTimeRange+: { from: value } }, + '#withTo': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'A Duration represents the elapsed time between two instants\nas an int64 nanosecond count. The representation limits the\nlargest representable duration to approximately 290 years.' } }, + withTo(value): { relativeTimeRange+: { to: value } }, + }, + }, + }, +} ++ (import '../../custom/alerting/ruleGroup.libsonnet') diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/dashboard.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/dashboard.libsonnet new file mode 100644 index 0000000000..4ab41af824 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/dashboard.libsonnet @@ -0,0 +1,268 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.dashboard', name: 'dashboard' }, + '#withDescription': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Description of dashboard.' } }, + withDescription(value): { description: value }, + '#withEditable': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Whether a dashboard is editable or not.' } }, + withEditable(value=true): { editable: value }, + '#withFiscalYearStartMonth': { 'function': { args: [{ default: 0, enums: null, name: 'value', type: 'integer' }], help: 'The month that the fiscal year starts on. 0 = January, 11 = December' } }, + withFiscalYearStartMonth(value=0): { fiscalYearStartMonth: value }, + '#withLinks': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'TODO docs' } }, + withLinks(value): { links: (if std.isArray(value) + then value + else [value]) }, + '#withLinksMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'TODO docs' } }, + withLinksMixin(value): { links+: (if std.isArray(value) + then value + else [value]) }, + '#withLiveNow': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'When set to true, the dashboard will redraw panels at an interval matching the pixel width.\nThis will keep data "moving left" regardless of the query refresh rate. This setting helps\navoid dashboards presenting stale live data' } }, + withLiveNow(value=true): { liveNow: value }, + '#withPanels': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withPanels(value): { panels: (if std.isArray(value) + then value + else [value]) }, + '#withPanelsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withPanelsMixin(value): { panels+: (if std.isArray(value) + then value + else [value]) }, + '#withRefresh': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Refresh rate of dashboard. Represented via interval string, e.g. "5s", "1m", "1h", "1d".' } }, + withRefresh(value): { refresh: value }, + '#withRefreshMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Refresh rate of dashboard. Represented via interval string, e.g. "5s", "1m", "1h", "1d".' } }, + withRefreshMixin(value): { refresh+: value }, + '#withSchemaVersion': { 'function': { args: [{ default: 36, enums: null, name: 'value', type: 'integer' }], help: "Version of the JSON schema, incremented each time a Grafana update brings\nchanges to said schema.\nTODO this is the existing schema numbering system. It will be replaced by Thema's themaVersion" } }, + withSchemaVersion(value=36): { schemaVersion: value }, + '#withStyle': { 'function': { args: [{ default: 'dark', enums: ['dark', 'light'], name: 'value', type: 'string' }], help: 'Theme of dashboard.' } }, + withStyle(value='dark'): { style: value }, + '#withTags': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Tags associated with dashboard.' } }, + withTags(value): { tags: (if std.isArray(value) + then value + else [value]) }, + '#withTagsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Tags associated with dashboard.' } }, + withTagsMixin(value): { tags+: (if std.isArray(value) + then value + else [value]) }, + '#withTemplating': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTemplating(value): { templating: value }, + '#withTemplatingMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTemplatingMixin(value): { templating+: value }, + '#withTimezone': { 'function': { args: [{ default: 'browser', enums: null, name: 'value', type: 'string' }], help: 'Timezone of dashboard. Accepts IANA TZDB zone ID or "browser" or "utc".' } }, + withTimezone(value='browser'): { timezone: value }, + '#withTitle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Title of dashboard.' } }, + withTitle(value): { title: value }, + '#withUid': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Unique dashboard identifier that can be generated by anyone. string (8-40)' } }, + withUid(value): { uid: value }, + '#withWeekStart': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'TODO docs' } }, + withWeekStart(value): { weekStart: value }, + time+: + { + '#withFrom': { 'function': { args: [{ default: 'now-6h', enums: null, name: 'value', type: 'string' }], help: '' } }, + withFrom(value='now-6h'): { time+: { from: value } }, + '#withTo': { 'function': { args: [{ default: 'now', enums: null, name: 'value', type: 'string' }], help: '' } }, + withTo(value='now'): { time+: { to: value } }, + }, + timepicker+: + { + '#withCollapse': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Whether timepicker is collapsed or not.' } }, + withCollapse(value=true): { timepicker+: { collapse: value } }, + '#withEnable': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Whether timepicker is enabled or not.' } }, + withEnable(value=true): { timepicker+: { enable: value } }, + '#withHidden': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Whether timepicker is visible or not.' } }, + withHidden(value=true): { timepicker+: { hidden: value } }, + '#withRefreshIntervals': { 'function': { args: [{ default: ['5s', '10s', '30s', '1m', '5m', '15m', '30m', '1h', '2h', '1d'], enums: null, name: 'value', type: 'array' }], help: 'Selectable intervals for auto-refresh.' } }, + withRefreshIntervals(value): { timepicker+: { refresh_intervals: (if std.isArray(value) + then value + else [value]) } }, + '#withRefreshIntervalsMixin': { 'function': { args: [{ default: ['5s', '10s', '30s', '1m', '5m', '15m', '30m', '1h', '2h', '1d'], enums: null, name: 'value', type: 'array' }], help: 'Selectable intervals for auto-refresh.' } }, + withRefreshIntervalsMixin(value): { timepicker+: { refresh_intervals+: (if std.isArray(value) + then value + else [value]) } }, + '#withTimeOptions': { 'function': { args: [{ default: ['5m', '15m', '1h', '6h', '12h', '24h', '2d', '7d', '30d'], enums: null, name: 'value', type: 'array' }], help: 'TODO docs' } }, + withTimeOptions(value): { timepicker+: { time_options: (if std.isArray(value) + then value + else [value]) } }, + '#withTimeOptionsMixin': { 'function': { args: [{ default: ['5m', '15m', '1h', '6h', '12h', '24h', '2d', '7d', '30d'], enums: null, name: 'value', type: 'array' }], help: 'TODO docs' } }, + withTimeOptionsMixin(value): { timepicker+: { time_options+: (if std.isArray(value) + then value + else [value]) } }, + }, + link+: + { + dashboards+: + { + '#withTitle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withTitle(value): { title: value }, + '#withType': { 'function': { args: [{ default: null, enums: ['link', 'dashboards'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withType(value): { type: value }, + '#withTags': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTags(value): { tags: (if std.isArray(value) + then value + else [value]) }, + options+: + { + '#withAsDropdown': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAsDropdown(value=true): { asDropdown: value }, + '#withKeepTime': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withKeepTime(value=true): { keepTime: value }, + '#withIncludeVars': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withIncludeVars(value=true): { includeVars: value }, + '#withTargetBlank': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withTargetBlank(value=true): { targetBlank: value }, + }, + }, + link+: + { + '#withTitle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withTitle(value): { title: value }, + '#withType': { 'function': { args: [{ default: null, enums: ['link', 'dashboards'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withType(value): { type: value }, + '#withUrl': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withUrl(value): { url: value }, + '#withTooltip': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withTooltip(value): { tooltip: value }, + '#withIcon': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withIcon(value): { icon: value }, + options+: + { + '#withAsDropdown': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAsDropdown(value=true): { asDropdown: value }, + '#withKeepTime': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withKeepTime(value=true): { keepTime: value }, + '#withIncludeVars': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withIncludeVars(value=true): { includeVars: value }, + '#withTargetBlank': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withTargetBlank(value=true): { targetBlank: value }, + }, + }, + }, + annotation+: + { + '#withList': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withList(value): { annotations+: { list: (if std.isArray(value) + then value + else [value]) } }, + '#withListMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withListMixin(value): { annotations+: { list+: (if std.isArray(value) + then value + else [value]) } }, + list+: + { + '#': { help: '', name: 'list' }, + '#withDatasource': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO: Should be DataSourceRef' } }, + withDatasource(value): { datasource: value }, + '#withDatasourceMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO: Should be DataSourceRef' } }, + withDatasourceMixin(value): { datasource+: value }, + datasource+: + { + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { datasource+: { type: value } }, + '#withUid': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withUid(value): { datasource+: { uid: value } }, + }, + '#withEnable': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'When enabled the annotation query is issued with every dashboard refresh' } }, + withEnable(value=true): { enable: value }, + '#withFilter': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withFilter(value): { filter: value }, + '#withFilterMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withFilterMixin(value): { filter+: value }, + filter+: + { + '#withExclude': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Should the specified panels be included or excluded' } }, + withExclude(value=true): { filter+: { exclude: value } }, + '#withIds': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Panel IDs that should be included or excluded' } }, + withIds(value): { filter+: { ids: (if std.isArray(value) + then value + else [value]) } }, + '#withIdsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Panel IDs that should be included or excluded' } }, + withIdsMixin(value): { filter+: { ids+: (if std.isArray(value) + then value + else [value]) } }, + }, + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Annotation queries can be toggled on or off at the top of the dashboard.\nWhen hide is true, the toggle is not shown in the dashboard.' } }, + withHide(value=true): { hide: value }, + '#withIconColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Color to use for the annotation event markers' } }, + withIconColor(value): { iconColor: value }, + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Name of annotation.' } }, + withName(value): { name: value }, + '#withTarget': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO: this should be a regular DataQuery that depends on the selected dashboard\nthese match the properties of the "grafana" datasouce that is default in most dashboards' } }, + withTarget(value): { target: value }, + '#withTargetMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO: this should be a regular DataQuery that depends on the selected dashboard\nthese match the properties of the "grafana" datasouce that is default in most dashboards' } }, + withTargetMixin(value): { target+: value }, + target+: + { + '#withLimit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'Only required/valid for the grafana datasource...\nbut code+tests is already depending on it so hard to change' } }, + withLimit(value): { target+: { limit: value } }, + '#withMatchAny': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Only required/valid for the grafana datasource...\nbut code+tests is already depending on it so hard to change' } }, + withMatchAny(value=true): { target+: { matchAny: value } }, + '#withTags': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Only required/valid for the grafana datasource...\nbut code+tests is already depending on it so hard to change' } }, + withTags(value): { target+: { tags: (if std.isArray(value) + then value + else [value]) } }, + '#withTagsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Only required/valid for the grafana datasource...\nbut code+tests is already depending on it so hard to change' } }, + withTagsMixin(value): { target+: { tags+: (if std.isArray(value) + then value + else [value]) } }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Only required/valid for the grafana datasource...\nbut code+tests is already depending on it so hard to change' } }, + withType(value): { target+: { type: value } }, + }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'TODO -- this should not exist here, it is based on the --grafana-- datasource' } }, + withType(value): { type: value }, + }, + }, + variable+: + { + '#withList': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withList(value): { templating+: { list: (if std.isArray(value) + then value + else [value]) } }, + '#withListMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withListMixin(value): { templating+: { list+: (if std.isArray(value) + then value + else [value]) } }, + list+: + { + '#': { help: '', name: 'list' }, + '#withDatasource': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Ref to a DataSource instance' } }, + withDatasource(value): { datasource: value }, + '#withDatasourceMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Ref to a DataSource instance' } }, + withDatasourceMixin(value): { datasource+: value }, + datasource+: + { + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The plugin type-id' } }, + withType(value): { datasource+: { type: value } }, + '#withUid': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Specific datasource instance' } }, + withUid(value): { datasource+: { uid: value } }, + }, + '#withDescription': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withDescription(value): { description: value }, + '#withError': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withError(value): { 'error': value }, + '#withErrorMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withErrorMixin(value): { 'error'+: value }, + '#withGlobal': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withGlobal(value=true): { global: value }, + '#withHide': { 'function': { args: [{ default: null, enums: [0, 1, 2], name: 'value', type: 'integer' }], help: '' } }, + withHide(value): { hide: value }, + '#withId': { 'function': { args: [{ default: '00000000-0000-0000-0000-000000000000', enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value='00000000-0000-0000-0000-000000000000'): { id: value }, + '#withIndex': { 'function': { args: [{ default: -1, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withIndex(value=-1): { index: value }, + '#withLabel': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withLabel(value): { label: value }, + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withName(value): { name: value }, + '#withQuery': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'TODO: Move this into a separated QueryVariableModel type' } }, + withQuery(value): { query: value }, + '#withQueryMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'TODO: Move this into a separated QueryVariableModel type' } }, + withQueryMixin(value): { query+: value }, + '#withRootStateKey': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withRootStateKey(value): { rootStateKey: value }, + '#withSkipUrlSync': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withSkipUrlSync(value=true): { skipUrlSync: value }, + '#withState': { 'function': { args: [{ default: null, enums: ['NotStarted', 'Loading', 'Streaming', 'Done', 'Error'], name: 'value', type: 'string' }], help: '' } }, + withState(value): { state: value }, + '#withType': { 'function': { args: [{ default: null, enums: ['query', 'adhoc', 'constant', 'datasource', 'interval', 'textbox', 'custom', 'system'], name: 'value', type: 'string' }], help: 'FROM: packages/grafana-data/src/types/templateVars.ts\nTODO docs\nTODO this implies some wider pattern/discriminated union, probably?' } }, + withType(value): { type: value }, + }, + }, +} ++ (import '../custom/dashboard.libsonnet') diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel.libsonnet new file mode 100644 index 0000000000..0c7b7c95c1 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel.libsonnet @@ -0,0 +1,354 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.panel', name: 'panel' }, + panelOptions+: + { + '#withTitle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Panel title.' } }, + withTitle(value): { title: value }, + '#withDescription': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Description.' } }, + withDescription(value): { description: value }, + '#withTransparent': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Whether to display the panel without a background.' } }, + withTransparent(value=true): { transparent: value }, + '#withLinks': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Panel links.\nTODO fill this out - seems there are a couple variants?' } }, + withLinks(value): { links: (if std.isArray(value) + then value + else [value]) }, + '#withLinksMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Panel links.\nTODO fill this out - seems there are a couple variants?' } }, + withLinksMixin(value): { links+: (if std.isArray(value) + then value + else [value]) }, + '#withRepeat': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Name of template variable to repeat for.' } }, + withRepeat(value): { repeat: value }, + '#withRepeatDirection': { 'function': { args: [{ default: 'h', enums: ['h', 'v'], name: 'value', type: 'string' }], help: "Direction to repeat in if 'repeat' is set.\n\"h\" for horizontal, \"v\" for vertical.\nTODO this is probably optional" } }, + withRepeatDirection(value='h'): { repeatDirection: value }, + '#withPluginVersion': { 'function': { args: [], help: '' } }, + withPluginVersion(): { pluginVersion: 'v10.0.0' }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The panel plugin type id. May not be empty.' } }, + withType(value): { type: value }, + link+: + { + '#': { help: '', name: 'link' }, + '#withAsDropdown': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAsDropdown(value=true): { asDropdown: value }, + '#withIcon': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withIcon(value): { icon: value }, + '#withIncludeVars': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withIncludeVars(value=true): { includeVars: value }, + '#withKeepTime': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withKeepTime(value=true): { keepTime: value }, + '#withTags': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTags(value): { tags: (if std.isArray(value) + then value + else [value]) }, + '#withTagsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTagsMixin(value): { tags+: (if std.isArray(value) + then value + else [value]) }, + '#withTargetBlank': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withTargetBlank(value=true): { targetBlank: value }, + '#withTitle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withTitle(value): { title: value }, + '#withTooltip': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withTooltip(value): { tooltip: value }, + '#withType': { 'function': { args: [{ default: null, enums: ['link', 'dashboards'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withType(value): { type: value }, + '#withUrl': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withUrl(value): { url: value }, + }, + }, + queryOptions+: + { + '#withDatasource': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'The datasource used in all targets.' } }, + withDatasource(value): { datasource: value }, + '#withDatasourceMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'The datasource used in all targets.' } }, + withDatasourceMixin(value): { datasource+: value }, + '#withMaxDataPoints': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'TODO docs' } }, + withMaxDataPoints(value): { maxDataPoints: value }, + '#withInterval': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'TODO docs\nTODO tighter constraint' } }, + withInterval(value): { interval: value }, + '#withTimeFrom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'TODO docs\nTODO tighter constraint' } }, + withTimeFrom(value): { timeFrom: value }, + '#withTimeShift': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'TODO docs\nTODO tighter constraint' } }, + withTimeShift(value): { timeShift: value }, + '#withTargets': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'TODO docs' } }, + withTargets(value): { targets: (if std.isArray(value) + then value + else [value]) }, + '#withTargetsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'TODO docs' } }, + withTargetsMixin(value): { targets+: (if std.isArray(value) + then value + else [value]) }, + '#withTransformations': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTransformations(value): { transformations: (if std.isArray(value) + then value + else [value]) }, + '#withTransformationsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTransformationsMixin(value): { transformations+: (if std.isArray(value) + then value + else [value]) }, + transformation+: + { + '#': { help: '', name: 'transformation' }, + '#withDisabled': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Disabled transformations are skipped' } }, + withDisabled(value=true): { disabled: value }, + '#withFilter': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withFilter(value): { filter: value }, + '#withFilterMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withFilterMixin(value): { filter+: value }, + filter+: + { + '#withId': { 'function': { args: [{ default: '', enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value=''): { filter+: { id: value } }, + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withOptions(value): { filter+: { options: value } }, + }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Unique identifier of transformer' } }, + withId(value): { id: value }, + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Options to be passed to the transformer\nValid options depend on the transformer id' } }, + withOptions(value): { options: value }, + }, + }, + standardOptions+: + { + '#withUnit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Numeric Options' } }, + withUnit(value): { fieldConfig+: { defaults+: { unit: value } } }, + '#withMin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withMin(value): { fieldConfig+: { defaults+: { min: value } } }, + '#withMax': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withMax(value): { fieldConfig+: { defaults+: { max: value } } }, + '#withDecimals': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Significant digits (for display)' } }, + withDecimals(value): { fieldConfig+: { defaults+: { decimals: value } } }, + '#withDisplayName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The display value for this field. This supports template variables blank is auto' } }, + withDisplayName(value): { fieldConfig+: { defaults+: { displayName: value } } }, + color+: + { + '#withFixedColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Stores the fixed color value if mode is fixed' } }, + withFixedColor(value): { fieldConfig+: { defaults+: { color+: { fixedColor: value } } } }, + '#withMode': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The main color scheme mode' } }, + withMode(value): { fieldConfig+: { defaults+: { color+: { mode: value } } } }, + '#withSeriesBy': { 'function': { args: [{ default: null, enums: ['min', 'max', 'last'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withSeriesBy(value): { fieldConfig+: { defaults+: { color+: { seriesBy: value } } } }, + }, + '#withNoValue': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Alternative to empty string' } }, + withNoValue(value): { fieldConfig+: { defaults+: { noValue: value } } }, + '#withLinks': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'The behavior when clicking on a result' } }, + withLinks(value): { fieldConfig+: { defaults+: { links: (if std.isArray(value) + then value + else [value]) } } }, + '#withLinksMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'The behavior when clicking on a result' } }, + withLinksMixin(value): { fieldConfig+: { defaults+: { links+: (if std.isArray(value) + then value + else [value]) } } }, + '#withMappings': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Convert input values into a display string' } }, + withMappings(value): { fieldConfig+: { defaults+: { mappings: (if std.isArray(value) + then value + else [value]) } } }, + '#withMappingsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Convert input values into a display string' } }, + withMappingsMixin(value): { fieldConfig+: { defaults+: { mappings+: (if std.isArray(value) + then value + else [value]) } } }, + '#withOverrides': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withOverrides(value): { fieldConfig+: { overrides: (if std.isArray(value) + then value + else [value]) } }, + '#withOverridesMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withOverridesMixin(value): { fieldConfig+: { overrides+: (if std.isArray(value) + then value + else [value]) } }, + '#withFilterable': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'True if data source field supports ad-hoc filters' } }, + withFilterable(value=true): { fieldConfig+: { defaults+: { filterable: value } } }, + '#withPath': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'An explicit path to the field in the datasource. When the frame meta includes a path,\nThis will default to `${frame.meta.path}/${field.name}\n\nWhen defined, this value can be used as an identifier within the datasource scope, and\nmay be used to update the results' } }, + withPath(value): { fieldConfig+: { defaults+: { path: value } } }, + thresholds+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['absolute', 'percentage'], name: 'value', type: 'string' }], help: '' } }, + withMode(value): { fieldConfig+: { defaults+: { thresholds+: { mode: value } } } }, + '#withSteps': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: "Must be sorted by 'value', first value is always -Infinity" } }, + withSteps(value): { fieldConfig+: { defaults+: { thresholds+: { steps: (if std.isArray(value) + then value + else [value]) } } } }, + '#withStepsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: "Must be sorted by 'value', first value is always -Infinity" } }, + withStepsMixin(value): { fieldConfig+: { defaults+: { thresholds+: { steps+: (if std.isArray(value) + then value + else [value]) } } } }, + }, + mapping+: + { + '#': { help: '', name: 'mapping' }, + ValueMap+: + { + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptions(value): { options: value }, + '#withOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptionsMixin(value): { options+: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + }, + RangeMap+: + { + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptions(value): { options: value }, + '#withOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptionsMixin(value): { options+: value }, + options+: + { + '#withFrom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'to and from are `number | null` in current ts, really not sure what to do' } }, + withFrom(value): { options+: { from: value } }, + '#withResult': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withResult(value): { options+: { result: value } }, + '#withResultMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withResultMixin(value): { options+: { result+: value } }, + result+: + { + '#withColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withColor(value): { options+: { result+: { color: value } } }, + '#withIcon': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withIcon(value): { options+: { result+: { icon: value } } }, + '#withIndex': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withIndex(value): { options+: { result+: { index: value } } }, + '#withText': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withText(value): { options+: { result+: { text: value } } }, + }, + '#withTo': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withTo(value): { options+: { to: value } }, + }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + }, + RegexMap+: + { + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptions(value): { options: value }, + '#withOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptionsMixin(value): { options+: value }, + options+: + { + '#withPattern': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withPattern(value): { options+: { pattern: value } }, + '#withResult': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withResult(value): { options+: { result: value } }, + '#withResultMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withResultMixin(value): { options+: { result+: value } }, + result+: + { + '#withColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withColor(value): { options+: { result+: { color: value } } }, + '#withIcon': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withIcon(value): { options+: { result+: { icon: value } } }, + '#withIndex': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withIndex(value): { options+: { result+: { index: value } } }, + '#withText': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withText(value): { options+: { result+: { text: value } } }, + }, + }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + }, + SpecialValueMap+: + { + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptions(value): { options: value }, + '#withOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptionsMixin(value): { options+: value }, + options+: + { + '#withMatch': { 'function': { args: [{ default: null, enums: ['true', 'false'], name: 'value', type: 'string' }], help: '' } }, + withMatch(value): { options+: { match: value } }, + '#withPattern': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withPattern(value): { options+: { pattern: value } }, + '#withResult': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withResult(value): { options+: { result: value } }, + '#withResultMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withResultMixin(value): { options+: { result+: value } }, + result+: + { + '#withColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withColor(value): { options+: { result+: { color: value } } }, + '#withIcon': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withIcon(value): { options+: { result+: { icon: value } } }, + '#withIndex': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withIndex(value): { options+: { result+: { index: value } } }, + '#withText': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withText(value): { options+: { result+: { text: value } } }, + }, + }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + }, + }, + threshold+: + { + step+: + { + '#': { help: '', name: 'step' }, + '#withColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'TODO docs' } }, + withColor(value): { color: value }, + '#withIndex': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'Threshold index, an old property that is not needed an should only appear in older dashboards' } }, + withIndex(value): { index: value }, + '#withState': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'TODO docs\nTODO are the values here enumerable into a disjunction?\nSome seem to be listed in typescript comment' } }, + withState(value): { state: value }, + '#withValue': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'TODO docs\nFIXME the corresponding typescript field is required/non-optional, but nulls currently appear here when serializing -Infinity to JSON' } }, + withValue(value): { value: value }, + }, + }, + override+: + { + '#': { help: '', name: 'override' }, + '#withMatcher': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withMatcher(value): { matcher: value }, + '#withMatcherMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withMatcherMixin(value): { matcher+: value }, + matcher+: + { + '#withId': { 'function': { args: [{ default: '', enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value=''): { matcher+: { id: value } }, + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withOptions(value): { matcher+: { options: value } }, + }, + '#withProperties': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withProperties(value): { properties: (if std.isArray(value) + then value + else [value]) }, + '#withPropertiesMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withPropertiesMixin(value): { properties+: (if std.isArray(value) + then value + else [value]) }, + properties+: + { + '#': { help: '', name: 'properties' }, + '#withId': { 'function': { args: [{ default: '', enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value=''): { id: value }, + '#withValue': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withValue(value): { value: value }, + }, + }, + }, + datasource+: + { + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { datasource+: { type: value } }, + '#withUid': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withUid(value): { datasource+: { uid: value } }, + }, + libraryPanel+: + { + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withName(value): { libraryPanel+: { name: value } }, + '#withUid': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withUid(value): { libraryPanel+: { uid: value } }, + }, + gridPos+: + { + '#withH': { 'function': { args: [{ default: 9, enums: null, name: 'value', type: 'integer' }], help: 'Panel' } }, + withH(value=9): { gridPos+: { h: value } }, + '#withStatic': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'true if fixed' } }, + withStatic(value=true): { gridPos+: { static: value } }, + '#withW': { 'function': { args: [{ default: 12, enums: null, name: 'value', type: 'integer' }], help: 'Panel' } }, + withW(value=12): { gridPos+: { w: value } }, + '#withX': { 'function': { args: [{ default: 0, enums: null, name: 'value', type: 'integer' }], help: 'Panel x' } }, + withX(value=0): { gridPos+: { x: value } }, + '#withY': { 'function': { args: [{ default: 0, enums: null, name: 'value', type: 'integer' }], help: 'Panel y' } }, + withY(value=0): { gridPos+: { y: value } }, + }, +} ++ (import '../custom/panel.libsonnet') diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/alertGroups.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/alertGroups.libsonnet new file mode 100644 index 0000000000..09fe4624e1 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/alertGroups.libsonnet @@ -0,0 +1,20 @@ +// This file is generated, do not manually edit. +(import '../../clean/panel.libsonnet') ++ { + '#': { help: 'grafonnet.panel.alertGroups', name: 'alertGroups' }, + panelOptions+: + { + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'alertGroups' }, + }, + options+: + { + '#withAlertmanager': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Name of the alertmanager used as a source for alerts' } }, + withAlertmanager(value): { options+: { alertmanager: value } }, + '#withExpandAll': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Expand all alert groups by default' } }, + withExpandAll(value=true): { options+: { expandAll: value } }, + '#withLabels': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Comma-separated list of values used to filter alert results' } }, + withLabels(value): { options+: { labels: value } }, + }, +} ++ { panelOptions+: { '#withType':: {} } } diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/alertList.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/alertList.libsonnet new file mode 100644 index 0000000000..d719bd4a36 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/alertList.libsonnet @@ -0,0 +1,125 @@ +// This file is generated, do not manually edit. +(import '../../clean/panel.libsonnet') ++ { + '#': { help: 'grafonnet.panel.alertList', name: 'alertList' }, + panelOptions+: + { + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'alertlist' }, + }, + options+: + { + '#withAlertListOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withAlertListOptions(value): { options+: { AlertListOptions: value } }, + '#withAlertListOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withAlertListOptionsMixin(value): { options+: { AlertListOptions+: value } }, + AlertListOptions+: + { + '#withAlertName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withAlertName(value): { options+: { alertName: value } }, + '#withDashboardAlerts': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withDashboardAlerts(value=true): { options+: { dashboardAlerts: value } }, + '#withDashboardTitle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withDashboardTitle(value): { options+: { dashboardTitle: value } }, + '#withFolderId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withFolderId(value): { options+: { folderId: value } }, + '#withMaxItems': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withMaxItems(value): { options+: { maxItems: value } }, + '#withShowOptions': { 'function': { args: [{ default: null, enums: ['current', 'changes'], name: 'value', type: 'string' }], help: '' } }, + withShowOptions(value): { options+: { showOptions: value } }, + '#withSortOrder': { 'function': { args: [{ default: null, enums: [1, 2, 3, 4, 5], name: 'value', type: 'number' }], help: '' } }, + withSortOrder(value): { options+: { sortOrder: value } }, + '#withStateFilter': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withStateFilter(value): { options+: { stateFilter: value } }, + '#withStateFilterMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withStateFilterMixin(value): { options+: { stateFilter+: value } }, + stateFilter+: + { + '#withAlerting': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAlerting(value=true): { options+: { stateFilter+: { alerting: value } } }, + '#withExecutionError': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withExecutionError(value=true): { options+: { stateFilter+: { execution_error: value } } }, + '#withNoData': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withNoData(value=true): { options+: { stateFilter+: { no_data: value } } }, + '#withOk': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withOk(value=true): { options+: { stateFilter+: { ok: value } } }, + '#withPaused': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withPaused(value=true): { options+: { stateFilter+: { paused: value } } }, + '#withPending': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withPending(value=true): { options+: { stateFilter+: { pending: value } } }, + }, + '#withTags': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTags(value): { options+: { tags: (if std.isArray(value) + then value + else [value]) } }, + '#withTagsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTagsMixin(value): { options+: { tags+: (if std.isArray(value) + then value + else [value]) } }, + }, + '#withUnifiedAlertListOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withUnifiedAlertListOptions(value): { options+: { UnifiedAlertListOptions: value } }, + '#withUnifiedAlertListOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withUnifiedAlertListOptionsMixin(value): { options+: { UnifiedAlertListOptions+: value } }, + UnifiedAlertListOptions+: + { + '#withAlertInstanceLabelFilter': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withAlertInstanceLabelFilter(value): { options+: { alertInstanceLabelFilter: value } }, + '#withAlertName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withAlertName(value): { options+: { alertName: value } }, + '#withDashboardAlerts': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withDashboardAlerts(value=true): { options+: { dashboardAlerts: value } }, + '#withDatasource': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withDatasource(value): { options+: { datasource: value } }, + '#withFolder': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withFolder(value): { options+: { folder: value } }, + '#withFolderMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withFolderMixin(value): { options+: { folder+: value } }, + folder+: + { + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withId(value): { options+: { folder+: { id: value } } }, + '#withTitle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withTitle(value): { options+: { folder+: { title: value } } }, + }, + '#withGroupBy': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withGroupBy(value): { options+: { groupBy: (if std.isArray(value) + then value + else [value]) } }, + '#withGroupByMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withGroupByMixin(value): { options+: { groupBy+: (if std.isArray(value) + then value + else [value]) } }, + '#withGroupMode': { 'function': { args: [{ default: null, enums: ['default', 'custom'], name: 'value', type: 'string' }], help: '' } }, + withGroupMode(value): { options+: { groupMode: value } }, + '#withMaxItems': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withMaxItems(value): { options+: { maxItems: value } }, + '#withShowInstances': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowInstances(value=true): { options+: { showInstances: value } }, + '#withSortOrder': { 'function': { args: [{ default: null, enums: [1, 2, 3, 4, 5], name: 'value', type: 'number' }], help: '' } }, + withSortOrder(value): { options+: { sortOrder: value } }, + '#withStateFilter': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withStateFilter(value): { options+: { stateFilter: value } }, + '#withStateFilterMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withStateFilterMixin(value): { options+: { stateFilter+: value } }, + stateFilter+: + { + '#withError': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withError(value=true): { options+: { stateFilter+: { 'error': value } } }, + '#withFiring': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withFiring(value=true): { options+: { stateFilter+: { firing: value } } }, + '#withInactive': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withInactive(value=true): { options+: { stateFilter+: { inactive: value } } }, + '#withNoData': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withNoData(value=true): { options+: { stateFilter+: { noData: value } } }, + '#withNormal': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withNormal(value=true): { options+: { stateFilter+: { normal: value } } }, + '#withPending': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withPending(value=true): { options+: { stateFilter+: { pending: value } } }, + }, + '#withViewMode': { 'function': { args: [{ default: null, enums: ['list', 'stat'], name: 'value', type: 'string' }], help: '' } }, + withViewMode(value): { options+: { viewMode: value } }, + }, + }, +} ++ { panelOptions+: { '#withType':: {} } } diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/annotationsList.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/annotationsList.libsonnet new file mode 100644 index 0000000000..f434c32f0b --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/annotationsList.libsonnet @@ -0,0 +1,40 @@ +// This file is generated, do not manually edit. +(import '../../clean/panel.libsonnet') ++ { + '#': { help: 'grafonnet.panel.annotationsList', name: 'annotationsList' }, + panelOptions+: + { + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'annolist' }, + }, + options+: + { + '#withLimit': { 'function': { args: [{ default: 10, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withLimit(value=10): { options+: { limit: value } }, + '#withNavigateAfter': { 'function': { args: [{ default: '10m', enums: null, name: 'value', type: 'string' }], help: '' } }, + withNavigateAfter(value='10m'): { options+: { navigateAfter: value } }, + '#withNavigateBefore': { 'function': { args: [{ default: '10m', enums: null, name: 'value', type: 'string' }], help: '' } }, + withNavigateBefore(value='10m'): { options+: { navigateBefore: value } }, + '#withNavigateToPanel': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withNavigateToPanel(value=true): { options+: { navigateToPanel: value } }, + '#withOnlyFromThisDashboard': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withOnlyFromThisDashboard(value=true): { options+: { onlyFromThisDashboard: value } }, + '#withOnlyInTimeRange': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withOnlyInTimeRange(value=true): { options+: { onlyInTimeRange: value } }, + '#withShowTags': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowTags(value=true): { options+: { showTags: value } }, + '#withShowTime': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowTime(value=true): { options+: { showTime: value } }, + '#withShowUser': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowUser(value=true): { options+: { showUser: value } }, + '#withTags': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTags(value): { options+: { tags: (if std.isArray(value) + then value + else [value]) } }, + '#withTagsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTagsMixin(value): { options+: { tags+: (if std.isArray(value) + then value + else [value]) } }, + }, +} ++ { panelOptions+: { '#withType':: {} } } diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/barChart.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/barChart.libsonnet new file mode 100644 index 0000000000..ceef0efe2b --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/barChart.libsonnet @@ -0,0 +1,157 @@ +// This file is generated, do not manually edit. +(import '../../clean/panel.libsonnet') ++ { + '#': { help: 'grafonnet.panel.barChart', name: 'barChart' }, + panelOptions+: + { + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'barchart' }, + }, + fieldConfig+: + { + defaults+: + { + custom+: + { + '#withAxisCenteredZero': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAxisCenteredZero(value=true): { fieldConfig+: { defaults+: { custom+: { axisCenteredZero: value } } } }, + '#withAxisColorMode': { 'function': { args: [{ default: null, enums: ['text', 'series'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withAxisColorMode(value): { fieldConfig+: { defaults+: { custom+: { axisColorMode: value } } } }, + '#withAxisGridShow': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAxisGridShow(value=true): { fieldConfig+: { defaults+: { custom+: { axisGridShow: value } } } }, + '#withAxisLabel': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withAxisLabel(value): { fieldConfig+: { defaults+: { custom+: { axisLabel: value } } } }, + '#withAxisPlacement': { 'function': { args: [{ default: null, enums: ['auto', 'top', 'right', 'bottom', 'left', 'hidden'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withAxisPlacement(value): { fieldConfig+: { defaults+: { custom+: { axisPlacement: value } } } }, + '#withAxisSoftMax': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisSoftMax(value): { fieldConfig+: { defaults+: { custom+: { axisSoftMax: value } } } }, + '#withAxisSoftMin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisSoftMin(value): { fieldConfig+: { defaults+: { custom+: { axisSoftMin: value } } } }, + '#withAxisWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisWidth(value): { fieldConfig+: { defaults+: { custom+: { axisWidth: value } } } }, + '#withScaleDistribution': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistribution(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution: value } } } }, + '#withScaleDistributionMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistributionMixin(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: value } } } }, + scaleDistribution+: + { + '#withLinearThreshold': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLinearThreshold(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: { linearThreshold: value } } } } }, + '#withLog': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLog(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: { log: value } } } } }, + '#withType': { 'function': { args: [{ default: null, enums: ['linear', 'log', 'ordinal', 'symlog'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withType(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: { type: value } } } } }, + }, + '#withHideFrom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFrom(value): { fieldConfig+: { defaults+: { custom+: { hideFrom: value } } } }, + '#withHideFromMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFromMixin(value): { fieldConfig+: { defaults+: { custom+: { hideFrom+: value } } } }, + hideFrom+: + { + '#withLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withLegend(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { legend: value } } } } }, + '#withTooltip': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withTooltip(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { tooltip: value } } } } }, + '#withViz': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withViz(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { viz: value } } } } }, + }, + '#withFillOpacity': { 'function': { args: [{ default: 80, enums: null, name: 'value', type: 'integer' }], help: 'Controls the fill opacity of the bars.' } }, + withFillOpacity(value=80): { fieldConfig+: { defaults+: { custom+: { fillOpacity: value } } } }, + '#withGradientMode': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Set the mode of the gradient fill. Fill gradient is based on the line color. To change the color, use the standard color scheme field option.\nGradient appearance is influenced by the Fill opacity setting.' } }, + withGradientMode(value): { fieldConfig+: { defaults+: { custom+: { gradientMode: value } } } }, + '#withLineWidth': { 'function': { args: [{ default: 1, enums: null, name: 'value', type: 'integer' }], help: 'Controls line width of the bars.' } }, + withLineWidth(value=1): { fieldConfig+: { defaults+: { custom+: { lineWidth: value } } } }, + '#withThresholdsStyle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withThresholdsStyle(value): { fieldConfig+: { defaults+: { custom+: { thresholdsStyle: value } } } }, + '#withThresholdsStyleMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withThresholdsStyleMixin(value): { fieldConfig+: { defaults+: { custom+: { thresholdsStyle+: value } } } }, + thresholdsStyle+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['off', 'line', 'dashed', 'area', 'line+area', 'dashed+area', 'series'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withMode(value): { fieldConfig+: { defaults+: { custom+: { thresholdsStyle+: { mode: value } } } } }, + }, + }, + }, + }, + options+: + { + '#withLegend': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLegend(value): { options+: { legend: value } }, + '#withLegendMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLegendMixin(value): { options+: { legend+: value } }, + legend+: + { + '#withAsTable': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAsTable(value=true): { options+: { legend+: { asTable: value } } }, + '#withCalcs': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withCalcs(value): { options+: { legend+: { calcs: (if std.isArray(value) + then value + else [value]) } } }, + '#withCalcsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withCalcsMixin(value): { options+: { legend+: { calcs+: (if std.isArray(value) + then value + else [value]) } } }, + '#withDisplayMode': { 'function': { args: [{ default: null, enums: ['list', 'table', 'hidden'], name: 'value', type: 'string' }], help: 'TODO docs\nNote: "hidden" needs to remain as an option for plugins compatibility' } }, + withDisplayMode(value): { options+: { legend+: { displayMode: value } } }, + '#withIsVisible': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withIsVisible(value=true): { options+: { legend+: { isVisible: value } } }, + '#withPlacement': { 'function': { args: [{ default: null, enums: ['bottom', 'right'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withPlacement(value): { options+: { legend+: { placement: value } } }, + '#withShowLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowLegend(value=true): { options+: { legend+: { showLegend: value } } }, + '#withSortBy': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withSortBy(value): { options+: { legend+: { sortBy: value } } }, + '#withSortDesc': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withSortDesc(value=true): { options+: { legend+: { sortDesc: value } } }, + '#withWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withWidth(value): { options+: { legend+: { width: value } } }, + }, + '#withTooltip': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTooltip(value): { options+: { tooltip: value } }, + '#withTooltipMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTooltipMixin(value): { options+: { tooltip+: value } }, + tooltip+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['single', 'multi', 'none'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withMode(value): { options+: { tooltip+: { mode: value } } }, + '#withSort': { 'function': { args: [{ default: null, enums: ['asc', 'desc', 'none'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withSort(value): { options+: { tooltip+: { sort: value } } }, + }, + '#withText': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withText(value): { options+: { text: value } }, + '#withTextMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTextMixin(value): { options+: { text+: value } }, + text+: + { + '#withTitleSize': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Explicit title text size' } }, + withTitleSize(value): { options+: { text+: { titleSize: value } } }, + '#withValueSize': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Explicit value text size' } }, + withValueSize(value): { options+: { text+: { valueSize: value } } }, + }, + '#withBarRadius': { 'function': { args: [{ default: 0, enums: null, name: 'value', type: 'number' }], help: 'Controls the radius of each bar.' } }, + withBarRadius(value=0): { options+: { barRadius: value } }, + '#withBarWidth': { 'function': { args: [{ default: 0.96999999999999997, enums: null, name: 'value', type: 'number' }], help: 'Controls the width of bars. 1 = Max width, 0 = Min width.' } }, + withBarWidth(value=0.96999999999999997): { options+: { barWidth: value } }, + '#withColorByField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Use the color value for a sibling field to color each bar value.' } }, + withColorByField(value): { options+: { colorByField: value } }, + '#withFullHighlight': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Enables mode which highlights the entire bar area and shows tooltip when cursor\nhovers over highlighted area' } }, + withFullHighlight(value=true): { options+: { fullHighlight: value } }, + '#withGroupWidth': { 'function': { args: [{ default: 0.69999999999999996, enums: null, name: 'value', type: 'number' }], help: 'Controls the width of groups. 1 = max with, 0 = min width.' } }, + withGroupWidth(value=0.69999999999999996): { options+: { groupWidth: value } }, + '#withOrientation': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Controls the orientation of the bar chart, either vertical or horizontal.' } }, + withOrientation(value): { options+: { orientation: value } }, + '#withShowValue': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'This controls whether values are shown on top or to the left of bars.' } }, + withShowValue(value): { options+: { showValue: value } }, + '#withStacking': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Controls whether bars are stacked or not, either normally or in percent mode.' } }, + withStacking(value): { options+: { stacking: value } }, + '#withXField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Manually select which field from the dataset to represent the x field.' } }, + withXField(value): { options+: { xField: value } }, + '#withXTickLabelMaxLength': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'Sets the max length that a label can have before it is truncated.' } }, + withXTickLabelMaxLength(value): { options+: { xTickLabelMaxLength: value } }, + '#withXTickLabelRotation': { 'function': { args: [{ default: 0, enums: null, name: 'value', type: 'integer' }], help: 'Controls the rotation of the x axis labels.' } }, + withXTickLabelRotation(value=0): { options+: { xTickLabelRotation: value } }, + '#withXTickLabelSpacing': { 'function': { args: [{ default: 0, enums: null, name: 'value', type: 'integer' }], help: 'Controls the spacing between x axis labels.\nnegative values indicate backwards skipping behavior' } }, + withXTickLabelSpacing(value=0): { options+: { xTickLabelSpacing: value } }, + }, +} ++ { panelOptions+: { '#withType':: {} } } diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/barGauge.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/barGauge.libsonnet new file mode 100644 index 0000000000..1596a280c3 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/barGauge.libsonnet @@ -0,0 +1,58 @@ +// This file is generated, do not manually edit. +(import '../../clean/panel.libsonnet') ++ { + '#': { help: 'grafonnet.panel.barGauge', name: 'barGauge' }, + panelOptions+: + { + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'bargauge' }, + }, + options+: + { + '#withText': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withText(value): { options+: { text: value } }, + '#withTextMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTextMixin(value): { options+: { text+: value } }, + text+: + { + '#withTitleSize': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Explicit title text size' } }, + withTitleSize(value): { options+: { text+: { titleSize: value } } }, + '#withValueSize': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Explicit value text size' } }, + withValueSize(value): { options+: { text+: { valueSize: value } } }, + }, + '#withOrientation': { 'function': { args: [{ default: null, enums: ['auto', 'vertical', 'horizontal'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withOrientation(value): { options+: { orientation: value } }, + '#withReduceOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withReduceOptions(value): { options+: { reduceOptions: value } }, + '#withReduceOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withReduceOptionsMixin(value): { options+: { reduceOptions+: value } }, + reduceOptions+: + { + '#withCalcs': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'When !values, pick one value for the whole field' } }, + withCalcs(value): { options+: { reduceOptions+: { calcs: (if std.isArray(value) + then value + else [value]) } } }, + '#withCalcsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'When !values, pick one value for the whole field' } }, + withCalcsMixin(value): { options+: { reduceOptions+: { calcs+: (if std.isArray(value) + then value + else [value]) } } }, + '#withFields': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Which fields to show. By default this is only numeric fields' } }, + withFields(value): { options+: { reduceOptions+: { fields: value } } }, + '#withLimit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'if showing all values limit' } }, + withLimit(value): { options+: { reduceOptions+: { limit: value } } }, + '#withValues': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'If true show each row value' } }, + withValues(value=true): { options+: { reduceOptions+: { values: value } } }, + }, + '#withDisplayMode': { 'function': { args: [{ default: null, enums: ['basic', 'lcd', 'gradient'], name: 'value', type: 'string' }], help: 'Enum expressing the possible display modes\nfor the bar gauge component of Grafana UI' } }, + withDisplayMode(value): { options+: { displayMode: value } }, + '#withMinVizHeight': { 'function': { args: [{ default: 10, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withMinVizHeight(value=10): { options+: { minVizHeight: value } }, + '#withMinVizWidth': { 'function': { args: [{ default: 0, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withMinVizWidth(value=0): { options+: { minVizWidth: value } }, + '#withShowUnfilled': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowUnfilled(value=true): { options+: { showUnfilled: value } }, + '#withValueMode': { 'function': { args: [{ default: null, enums: ['color', 'text', 'hidden'], name: 'value', type: 'string' }], help: 'Allows for the table cell gauge display type to set the gauge mode.' } }, + withValueMode(value): { options+: { valueMode: value } }, + }, +} ++ { panelOptions+: { '#withType':: {} } } diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/candlestick.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/candlestick.libsonnet new file mode 100644 index 0000000000..8d9e6ef1e1 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/candlestick.libsonnet @@ -0,0 +1,11 @@ +// This file is generated, do not manually edit. +(import '../../clean/panel.libsonnet') ++ { + '#': { help: 'grafonnet.panel.candlestick', name: 'candlestick' }, + panelOptions+: + { + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'candlestick' }, + }, +} ++ { panelOptions+: { '#withType':: {} } } diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/canvas.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/canvas.libsonnet new file mode 100644 index 0000000000..4814e32c2e --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/canvas.libsonnet @@ -0,0 +1,11 @@ +// This file is generated, do not manually edit. +(import '../../clean/panel.libsonnet') ++ { + '#': { help: 'grafonnet.panel.canvas', name: 'canvas' }, + panelOptions+: + { + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'canvas' }, + }, +} ++ { panelOptions+: { '#withType':: {} } } diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/dashboardList.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/dashboardList.libsonnet new file mode 100644 index 0000000000..9c981c2973 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/dashboardList.libsonnet @@ -0,0 +1,40 @@ +// This file is generated, do not manually edit. +(import '../../clean/panel.libsonnet') ++ { + '#': { help: 'grafonnet.panel.dashboardList', name: 'dashboardList' }, + panelOptions+: + { + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'dashlist' }, + }, + options+: + { + '#withFolderId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withFolderId(value): { options+: { folderId: value } }, + '#withIncludeVars': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withIncludeVars(value=true): { options+: { includeVars: value } }, + '#withKeepTime': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withKeepTime(value=true): { options+: { keepTime: value } }, + '#withMaxItems': { 'function': { args: [{ default: 10, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withMaxItems(value=10): { options+: { maxItems: value } }, + '#withQuery': { 'function': { args: [{ default: '', enums: null, name: 'value', type: 'string' }], help: '' } }, + withQuery(value=''): { options+: { query: value } }, + '#withShowHeadings': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowHeadings(value=true): { options+: { showHeadings: value } }, + '#withShowRecentlyViewed': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowRecentlyViewed(value=true): { options+: { showRecentlyViewed: value } }, + '#withShowSearch': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowSearch(value=true): { options+: { showSearch: value } }, + '#withShowStarred': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowStarred(value=true): { options+: { showStarred: value } }, + '#withTags': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTags(value): { options+: { tags: (if std.isArray(value) + then value + else [value]) } }, + '#withTagsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTagsMixin(value): { options+: { tags+: (if std.isArray(value) + then value + else [value]) } }, + }, +} ++ { panelOptions+: { '#withType':: {} } } diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/datagrid.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/datagrid.libsonnet new file mode 100644 index 0000000000..e8d7558928 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/datagrid.libsonnet @@ -0,0 +1,16 @@ +// This file is generated, do not manually edit. +(import '../../clean/panel.libsonnet') ++ { + '#': { help: 'grafonnet.panel.datagrid', name: 'datagrid' }, + panelOptions+: + { + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'datagrid' }, + }, + options+: + { + '#withSelectedSeries': { 'function': { args: [{ default: 0, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withSelectedSeries(value=0): { options+: { selectedSeries: value } }, + }, +} ++ { panelOptions+: { '#withType':: {} } } diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/debug.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/debug.libsonnet new file mode 100644 index 0000000000..da8c70ed10 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/debug.libsonnet @@ -0,0 +1,29 @@ +// This file is generated, do not manually edit. +(import '../../clean/panel.libsonnet') ++ { + '#': { help: 'grafonnet.panel.debug', name: 'debug' }, + panelOptions+: + { + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'debug' }, + }, + options+: + { + '#withCounters': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withCounters(value): { options+: { counters: value } }, + '#withCountersMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withCountersMixin(value): { options+: { counters+: value } }, + counters+: + { + '#withDataChanged': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withDataChanged(value=true): { options+: { counters+: { dataChanged: value } } }, + '#withRender': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withRender(value=true): { options+: { counters+: { render: value } } }, + '#withSchemaChanged': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withSchemaChanged(value=true): { options+: { counters+: { schemaChanged: value } } }, + }, + '#withMode': { 'function': { args: [{ default: null, enums: ['render', 'events', 'cursor', 'State', 'ThrowError'], name: 'value', type: 'string' }], help: '' } }, + withMode(value): { options+: { mode: value } }, + }, +} ++ { panelOptions+: { '#withType':: {} } } diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/gauge.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/gauge.libsonnet new file mode 100644 index 0000000000..a45c39cbfc --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/gauge.libsonnet @@ -0,0 +1,52 @@ +// This file is generated, do not manually edit. +(import '../../clean/panel.libsonnet') ++ { + '#': { help: 'grafonnet.panel.gauge', name: 'gauge' }, + panelOptions+: + { + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'gauge' }, + }, + options+: + { + '#withText': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withText(value): { options+: { text: value } }, + '#withTextMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTextMixin(value): { options+: { text+: value } }, + text+: + { + '#withTitleSize': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Explicit title text size' } }, + withTitleSize(value): { options+: { text+: { titleSize: value } } }, + '#withValueSize': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Explicit value text size' } }, + withValueSize(value): { options+: { text+: { valueSize: value } } }, + }, + '#withOrientation': { 'function': { args: [{ default: null, enums: ['auto', 'vertical', 'horizontal'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withOrientation(value): { options+: { orientation: value } }, + '#withReduceOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withReduceOptions(value): { options+: { reduceOptions: value } }, + '#withReduceOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withReduceOptionsMixin(value): { options+: { reduceOptions+: value } }, + reduceOptions+: + { + '#withCalcs': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'When !values, pick one value for the whole field' } }, + withCalcs(value): { options+: { reduceOptions+: { calcs: (if std.isArray(value) + then value + else [value]) } } }, + '#withCalcsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'When !values, pick one value for the whole field' } }, + withCalcsMixin(value): { options+: { reduceOptions+: { calcs+: (if std.isArray(value) + then value + else [value]) } } }, + '#withFields': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Which fields to show. By default this is only numeric fields' } }, + withFields(value): { options+: { reduceOptions+: { fields: value } } }, + '#withLimit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'if showing all values limit' } }, + withLimit(value): { options+: { reduceOptions+: { limit: value } } }, + '#withValues': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'If true show each row value' } }, + withValues(value=true): { options+: { reduceOptions+: { values: value } } }, + }, + '#withShowThresholdLabels': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowThresholdLabels(value=true): { options+: { showThresholdLabels: value } }, + '#withShowThresholdMarkers': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowThresholdMarkers(value=true): { options+: { showThresholdMarkers: value } }, + }, +} ++ { panelOptions+: { '#withType':: {} } } diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/geomap.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/geomap.libsonnet new file mode 100644 index 0000000000..70c8eb7e74 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/geomap.libsonnet @@ -0,0 +1,156 @@ +// This file is generated, do not manually edit. +(import '../../clean/panel.libsonnet') ++ { + '#': { help: 'grafonnet.panel.geomap', name: 'geomap' }, + panelOptions+: + { + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'geomap' }, + }, + options+: + { + '#withBasemap': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withBasemap(value): { options+: { basemap: value } }, + '#withBasemapMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withBasemapMixin(value): { options+: { basemap+: value } }, + basemap+: + { + '#withConfig': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Custom options depending on the type' } }, + withConfig(value): { options+: { basemap+: { config: value } } }, + '#withFilterData': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Defines a frame MatcherConfig that may filter data for the given layer' } }, + withFilterData(value): { options+: { basemap+: { filterData: value } } }, + '#withLocation': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withLocation(value): { options+: { basemap+: { location: value } } }, + '#withLocationMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withLocationMixin(value): { options+: { basemap+: { location+: value } } }, + location+: + { + '#withGazetteer': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Path to Gazetteer' } }, + withGazetteer(value): { options+: { basemap+: { location+: { gazetteer: value } } } }, + '#withGeohash': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Field mappings' } }, + withGeohash(value): { options+: { basemap+: { location+: { geohash: value } } } }, + '#withLatitude': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withLatitude(value): { options+: { basemap+: { location+: { latitude: value } } } }, + '#withLongitude': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withLongitude(value): { options+: { basemap+: { location+: { longitude: value } } } }, + '#withLookup': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withLookup(value): { options+: { basemap+: { location+: { lookup: value } } } }, + '#withMode': { 'function': { args: [{ default: null, enums: ['auto', 'geohash', 'coords', 'lookup'], name: 'value', type: 'string' }], help: '' } }, + withMode(value): { options+: { basemap+: { location+: { mode: value } } } }, + '#withWkt': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withWkt(value): { options+: { basemap+: { location+: { wkt: value } } } }, + }, + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'configured unique display name' } }, + withName(value): { options+: { basemap+: { name: value } } }, + '#withOpacity': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'Common properties:\nhttps://openlayers.org/en/latest/apidoc/module-ol_layer_Base-BaseLayer.html\nLayer opacity (0-1)' } }, + withOpacity(value): { options+: { basemap+: { opacity: value } } }, + '#withTooltip': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Check tooltip (defaults to true)' } }, + withTooltip(value=true): { options+: { basemap+: { tooltip: value } } }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { options+: { basemap+: { type: value } } }, + }, + '#withControls': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withControls(value): { options+: { controls: value } }, + '#withControlsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withControlsMixin(value): { options+: { controls+: value } }, + controls+: + { + '#withMouseWheelZoom': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'let the mouse wheel zoom' } }, + withMouseWheelZoom(value=true): { options+: { controls+: { mouseWheelZoom: value } } }, + '#withShowAttribution': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Lower right' } }, + withShowAttribution(value=true): { options+: { controls+: { showAttribution: value } } }, + '#withShowDebug': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Show debug' } }, + withShowDebug(value=true): { options+: { controls+: { showDebug: value } } }, + '#withShowMeasure': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Show measure' } }, + withShowMeasure(value=true): { options+: { controls+: { showMeasure: value } } }, + '#withShowScale': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Scale options' } }, + withShowScale(value=true): { options+: { controls+: { showScale: value } } }, + '#withShowZoom': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Zoom (upper left)' } }, + withShowZoom(value=true): { options+: { controls+: { showZoom: value } } }, + }, + '#withLayers': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withLayers(value): { options+: { layers: (if std.isArray(value) + then value + else [value]) } }, + '#withLayersMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withLayersMixin(value): { options+: { layers+: (if std.isArray(value) + then value + else [value]) } }, + layers+: + { + '#': { help: '', name: 'layers' }, + '#withConfig': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Custom options depending on the type' } }, + withConfig(value): { config: value }, + '#withFilterData': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Defines a frame MatcherConfig that may filter data for the given layer' } }, + withFilterData(value): { filterData: value }, + '#withLocation': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withLocation(value): { location: value }, + '#withLocationMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withLocationMixin(value): { location+: value }, + location+: + { + '#withGazetteer': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Path to Gazetteer' } }, + withGazetteer(value): { location+: { gazetteer: value } }, + '#withGeohash': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Field mappings' } }, + withGeohash(value): { location+: { geohash: value } }, + '#withLatitude': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withLatitude(value): { location+: { latitude: value } }, + '#withLongitude': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withLongitude(value): { location+: { longitude: value } }, + '#withLookup': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withLookup(value): { location+: { lookup: value } }, + '#withMode': { 'function': { args: [{ default: null, enums: ['auto', 'geohash', 'coords', 'lookup'], name: 'value', type: 'string' }], help: '' } }, + withMode(value): { location+: { mode: value } }, + '#withWkt': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withWkt(value): { location+: { wkt: value } }, + }, + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'configured unique display name' } }, + withName(value): { name: value }, + '#withOpacity': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'Common properties:\nhttps://openlayers.org/en/latest/apidoc/module-ol_layer_Base-BaseLayer.html\nLayer opacity (0-1)' } }, + withOpacity(value): { opacity: value }, + '#withTooltip': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Check tooltip (defaults to true)' } }, + withTooltip(value=true): { tooltip: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + }, + '#withTooltip': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withTooltip(value): { options+: { tooltip: value } }, + '#withTooltipMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withTooltipMixin(value): { options+: { tooltip+: value } }, + tooltip+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['none', 'details'], name: 'value', type: 'string' }], help: '' } }, + withMode(value): { options+: { tooltip+: { mode: value } } }, + }, + '#withView': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withView(value): { options+: { view: value } }, + '#withViewMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withViewMixin(value): { options+: { view+: value } }, + view+: + { + '#withAllLayers': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAllLayers(value=true): { options+: { view+: { allLayers: value } } }, + '#withId': { 'function': { args: [{ default: 'zero', enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value='zero'): { options+: { view+: { id: value } } }, + '#withLastOnly': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withLastOnly(value=true): { options+: { view+: { lastOnly: value } } }, + '#withLat': { 'function': { args: [{ default: 0, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withLat(value=0): { options+: { view+: { lat: value } } }, + '#withLayer': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withLayer(value): { options+: { view+: { layer: value } } }, + '#withLon': { 'function': { args: [{ default: 0, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withLon(value=0): { options+: { view+: { lon: value } } }, + '#withMaxZoom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withMaxZoom(value): { options+: { view+: { maxZoom: value } } }, + '#withMinZoom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withMinZoom(value): { options+: { view+: { minZoom: value } } }, + '#withPadding': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withPadding(value): { options+: { view+: { padding: value } } }, + '#withShared': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShared(value=true): { options+: { view+: { shared: value } } }, + '#withZoom': { 'function': { args: [{ default: 1, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withZoom(value=1): { options+: { view+: { zoom: value } } }, + }, + }, +} ++ { panelOptions+: { '#withType':: {} } } diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/heatmap.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/heatmap.libsonnet new file mode 100644 index 0000000000..24b141c9d9 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/heatmap.libsonnet @@ -0,0 +1,266 @@ +// This file is generated, do not manually edit. +(import '../../clean/panel.libsonnet') ++ { + '#': { help: 'grafonnet.panel.heatmap', name: 'heatmap' }, + panelOptions+: + { + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'heatmap' }, + }, + fieldConfig+: + { + defaults+: + { + custom+: + { + '#withHideFrom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFrom(value): { fieldConfig+: { defaults+: { custom+: { hideFrom: value } } } }, + '#withHideFromMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFromMixin(value): { fieldConfig+: { defaults+: { custom+: { hideFrom+: value } } } }, + hideFrom+: + { + '#withLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withLegend(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { legend: value } } } } }, + '#withTooltip': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withTooltip(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { tooltip: value } } } } }, + '#withViz': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withViz(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { viz: value } } } } }, + }, + '#withScaleDistribution': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistribution(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution: value } } } }, + '#withScaleDistributionMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistributionMixin(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: value } } } }, + scaleDistribution+: + { + '#withLinearThreshold': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLinearThreshold(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: { linearThreshold: value } } } } }, + '#withLog': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLog(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: { log: value } } } } }, + '#withType': { 'function': { args: [{ default: null, enums: ['linear', 'log', 'ordinal', 'symlog'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withType(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: { type: value } } } } }, + }, + }, + }, + }, + options+: + { + '#withCalculate': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Controls if the heatmap should be calculated from data' } }, + withCalculate(value=true): { options+: { calculate: value } }, + '#withCalculation': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withCalculation(value): { options+: { calculation: value } }, + '#withCalculationMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withCalculationMixin(value): { options+: { calculation+: value } }, + calculation+: + { + '#withXBuckets': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withXBuckets(value): { options+: { calculation+: { xBuckets: value } } }, + '#withXBucketsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withXBucketsMixin(value): { options+: { calculation+: { xBuckets+: value } } }, + xBuckets+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['size', 'count'], name: 'value', type: 'string' }], help: '' } }, + withMode(value): { options+: { calculation+: { xBuckets+: { mode: value } } } }, + '#withScale': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScale(value): { options+: { calculation+: { xBuckets+: { scale: value } } } }, + '#withScaleMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleMixin(value): { options+: { calculation+: { xBuckets+: { scale+: value } } } }, + scale+: + { + '#withLinearThreshold': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLinearThreshold(value): { options+: { calculation+: { xBuckets+: { scale+: { linearThreshold: value } } } } }, + '#withLog': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLog(value): { options+: { calculation+: { xBuckets+: { scale+: { log: value } } } } }, + '#withType': { 'function': { args: [{ default: null, enums: ['linear', 'log', 'ordinal', 'symlog'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withType(value): { options+: { calculation+: { xBuckets+: { scale+: { type: value } } } } }, + }, + '#withValue': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The number of buckets to use for the axis in the heatmap' } }, + withValue(value): { options+: { calculation+: { xBuckets+: { value: value } } } }, + }, + '#withYBuckets': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withYBuckets(value): { options+: { calculation+: { yBuckets: value } } }, + '#withYBucketsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withYBucketsMixin(value): { options+: { calculation+: { yBuckets+: value } } }, + yBuckets+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['size', 'count'], name: 'value', type: 'string' }], help: '' } }, + withMode(value): { options+: { calculation+: { yBuckets+: { mode: value } } } }, + '#withScale': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScale(value): { options+: { calculation+: { yBuckets+: { scale: value } } } }, + '#withScaleMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleMixin(value): { options+: { calculation+: { yBuckets+: { scale+: value } } } }, + scale+: + { + '#withLinearThreshold': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLinearThreshold(value): { options+: { calculation+: { yBuckets+: { scale+: { linearThreshold: value } } } } }, + '#withLog': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLog(value): { options+: { calculation+: { yBuckets+: { scale+: { log: value } } } } }, + '#withType': { 'function': { args: [{ default: null, enums: ['linear', 'log', 'ordinal', 'symlog'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withType(value): { options+: { calculation+: { yBuckets+: { scale+: { type: value } } } } }, + }, + '#withValue': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The number of buckets to use for the axis in the heatmap' } }, + withValue(value): { options+: { calculation+: { yBuckets+: { value: value } } } }, + }, + }, + '#withCellGap': { 'function': { args: [{ default: 1, enums: null, name: 'value', type: 'integer' }], help: 'Controls gap between cells' } }, + withCellGap(value=1): { options+: { cellGap: value } }, + '#withCellRadius': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Controls cell radius' } }, + withCellRadius(value): { options+: { cellRadius: value } }, + '#withCellValues': { 'function': { args: [{ default: {}, enums: null, name: 'value', type: 'object' }], help: 'Controls cell value unit' } }, + withCellValues(value={}): { options+: { cellValues: value } }, + '#withCellValuesMixin': { 'function': { args: [{ default: {}, enums: null, name: 'value', type: 'object' }], help: 'Controls cell value unit' } }, + withCellValuesMixin(value): { options+: { cellValues+: value } }, + cellValues+: + { + '#withCellValues': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls cell value options' } }, + withCellValues(value): { options+: { cellValues+: { CellValues: value } } }, + '#withCellValuesMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls cell value options' } }, + withCellValuesMixin(value): { options+: { cellValues+: { CellValues+: value } } }, + CellValues+: + { + '#withDecimals': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Controls the number of decimals for cell values' } }, + withDecimals(value): { options+: { cellValues+: { decimals: value } } }, + '#withUnit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Controls the cell value unit' } }, + withUnit(value): { options+: { cellValues+: { unit: value } } }, + }, + }, + '#withColor': { 'function': { args: [{ default: { exponent: 0.5, fill: 'dark-orange', reverse: false, scheme: 'Oranges', steps: 64 }, enums: null, name: 'value', type: 'object' }], help: 'Controls the color options' } }, + withColor(value={ exponent: 0.5, fill: 'dark-orange', reverse: false, scheme: 'Oranges', steps: 64 }): { options+: { color: value } }, + '#withColorMixin': { 'function': { args: [{ default: { exponent: 0.5, fill: 'dark-orange', reverse: false, scheme: 'Oranges', steps: 64 }, enums: null, name: 'value', type: 'object' }], help: 'Controls the color options' } }, + withColorMixin(value): { options+: { color+: value } }, + color+: + { + '#withHeatmapColorOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls various color options' } }, + withHeatmapColorOptions(value): { options+: { color+: { HeatmapColorOptions: value } } }, + '#withHeatmapColorOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls various color options' } }, + withHeatmapColorOptionsMixin(value): { options+: { color+: { HeatmapColorOptions+: value } } }, + HeatmapColorOptions+: + { + '#withExponent': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Controls the exponent when scale is set to exponential' } }, + withExponent(value): { options+: { color+: { exponent: value } } }, + '#withFill': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Controls the color fill when in opacity mode' } }, + withFill(value): { options+: { color+: { fill: value } } }, + '#withMax': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Sets the maximum value for the color scale' } }, + withMax(value): { options+: { color+: { max: value } } }, + '#withMin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Sets the minimum value for the color scale' } }, + withMin(value): { options+: { color+: { min: value } } }, + '#withMode': { 'function': { args: [{ default: null, enums: ['opacity', 'scheme'], name: 'value', type: 'string' }], help: 'Controls the color mode of the heatmap' } }, + withMode(value): { options+: { color+: { mode: value } } }, + '#withReverse': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Reverses the color scheme' } }, + withReverse(value=true): { options+: { color+: { reverse: value } } }, + '#withScale': { 'function': { args: [{ default: null, enums: ['linear', 'exponential'], name: 'value', type: 'string' }], help: 'Controls the color scale of the heatmap' } }, + withScale(value): { options+: { color+: { scale: value } } }, + '#withScheme': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Controls the color scheme used' } }, + withScheme(value): { options+: { color+: { scheme: value } } }, + '#withSteps': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'Controls the number of color steps' } }, + withSteps(value): { options+: { color+: { steps: value } } }, + }, + }, + '#withExemplars': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls exemplar options' } }, + withExemplars(value): { options+: { exemplars: value } }, + '#withExemplarsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls exemplar options' } }, + withExemplarsMixin(value): { options+: { exemplars+: value } }, + exemplars+: + { + '#withColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Sets the color of the exemplar markers' } }, + withColor(value): { options+: { exemplars+: { color: value } } }, + }, + '#withFilterValues': { 'function': { args: [{ default: { le: 1.0000000000000001e-09 }, enums: null, name: 'value', type: 'object' }], help: 'Filters values between a given range' } }, + withFilterValues(value={ le: 1.0000000000000001e-09 }): { options+: { filterValues: value } }, + '#withFilterValuesMixin': { 'function': { args: [{ default: { le: 1.0000000000000001e-09 }, enums: null, name: 'value', type: 'object' }], help: 'Filters values between a given range' } }, + withFilterValuesMixin(value): { options+: { filterValues+: value } }, + filterValues+: + { + '#withFilterValueRange': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls the value filter range' } }, + withFilterValueRange(value): { options+: { filterValues+: { FilterValueRange: value } } }, + '#withFilterValueRangeMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls the value filter range' } }, + withFilterValueRangeMixin(value): { options+: { filterValues+: { FilterValueRange+: value } } }, + FilterValueRange+: + { + '#withGe': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Sets the filter range to values greater than or equal to the given value' } }, + withGe(value): { options+: { filterValues+: { ge: value } } }, + '#withLe': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Sets the filter range to values less than or equal to the given value' } }, + withLe(value): { options+: { filterValues+: { le: value } } }, + }, + }, + '#withLegend': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls legend options' } }, + withLegend(value): { options+: { legend: value } }, + '#withLegendMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls legend options' } }, + withLegendMixin(value): { options+: { legend+: value } }, + legend+: + { + '#withShow': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Controls if the legend is shown' } }, + withShow(value=true): { options+: { legend+: { show: value } } }, + }, + '#withRowsFrame': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls frame rows options' } }, + withRowsFrame(value): { options+: { rowsFrame: value } }, + '#withRowsFrameMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls frame rows options' } }, + withRowsFrameMixin(value): { options+: { rowsFrame+: value } }, + rowsFrame+: + { + '#withLayout': { 'function': { args: [{ default: null, enums: ['le', 'ge', 'unknown', 'auto'], name: 'value', type: 'string' }], help: '' } }, + withLayout(value): { options+: { rowsFrame+: { layout: value } } }, + '#withValue': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Sets the name of the cell when not calculating from data' } }, + withValue(value): { options+: { rowsFrame+: { value: value } } }, + }, + '#withShowValue': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '| *{\n\tlayout: ui.HeatmapCellLayout & "auto" // TODO: fix after remove when https://github.com/grafana/cuetsy/issues/74 is fixed\n}\nControls the display of the value in the cell' } }, + withShowValue(value): { options+: { showValue: value } }, + '#withTooltip': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls tooltip options' } }, + withTooltip(value): { options+: { tooltip: value } }, + '#withTooltipMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls tooltip options' } }, + withTooltipMixin(value): { options+: { tooltip+: value } }, + tooltip+: + { + '#withShow': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Controls if the tooltip is shown' } }, + withShow(value=true): { options+: { tooltip+: { show: value } } }, + '#withYHistogram': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Controls if the tooltip shows a histogram of the y-axis values' } }, + withYHistogram(value=true): { options+: { tooltip+: { yHistogram: value } } }, + }, + '#withYAxis': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Configuration options for the yAxis' } }, + withYAxis(value): { options+: { yAxis: value } }, + '#withYAxisMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Configuration options for the yAxis' } }, + withYAxisMixin(value): { options+: { yAxis+: value } }, + yAxis+: + { + '#withAxisCenteredZero': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAxisCenteredZero(value=true): { options+: { yAxis+: { axisCenteredZero: value } } }, + '#withAxisColorMode': { 'function': { args: [{ default: null, enums: ['text', 'series'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withAxisColorMode(value): { options+: { yAxis+: { axisColorMode: value } } }, + '#withAxisGridShow': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAxisGridShow(value=true): { options+: { yAxis+: { axisGridShow: value } } }, + '#withAxisLabel': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withAxisLabel(value): { options+: { yAxis+: { axisLabel: value } } }, + '#withAxisPlacement': { 'function': { args: [{ default: null, enums: ['auto', 'top', 'right', 'bottom', 'left', 'hidden'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withAxisPlacement(value): { options+: { yAxis+: { axisPlacement: value } } }, + '#withAxisSoftMax': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisSoftMax(value): { options+: { yAxis+: { axisSoftMax: value } } }, + '#withAxisSoftMin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisSoftMin(value): { options+: { yAxis+: { axisSoftMin: value } } }, + '#withAxisWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisWidth(value): { options+: { yAxis+: { axisWidth: value } } }, + '#withScaleDistribution': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistribution(value): { options+: { yAxis+: { scaleDistribution: value } } }, + '#withScaleDistributionMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistributionMixin(value): { options+: { yAxis+: { scaleDistribution+: value } } }, + scaleDistribution+: + { + '#withLinearThreshold': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLinearThreshold(value): { options+: { yAxis+: { scaleDistribution+: { linearThreshold: value } } } }, + '#withLog': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLog(value): { options+: { yAxis+: { scaleDistribution+: { log: value } } } }, + '#withType': { 'function': { args: [{ default: null, enums: ['linear', 'log', 'ordinal', 'symlog'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withType(value): { options+: { yAxis+: { scaleDistribution+: { type: value } } } }, + }, + '#withDecimals': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Controls the number of decimals for yAxis values' } }, + withDecimals(value): { options+: { yAxis+: { decimals: value } } }, + '#withMax': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Sets the maximum value for the yAxis' } }, + withMax(value): { options+: { yAxis+: { max: value } } }, + '#withMin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Sets the minimum value for the yAxis' } }, + withMin(value): { options+: { yAxis+: { min: value } } }, + '#withReverse': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Reverses the yAxis' } }, + withReverse(value=true): { options+: { yAxis+: { reverse: value } } }, + '#withUnit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Sets the yAxis unit' } }, + withUnit(value): { options+: { yAxis+: { unit: value } } }, + }, + }, +} ++ { panelOptions+: { '#withType':: {} } } diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/histogram.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/histogram.libsonnet new file mode 100644 index 0000000000..36f46eb607 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/histogram.libsonnet @@ -0,0 +1,119 @@ +// This file is generated, do not manually edit. +(import '../../clean/panel.libsonnet') ++ { + '#': { help: 'grafonnet.panel.histogram', name: 'histogram' }, + panelOptions+: + { + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'histogram' }, + }, + fieldConfig+: + { + defaults+: + { + custom+: + { + '#withAxisCenteredZero': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAxisCenteredZero(value=true): { fieldConfig+: { defaults+: { custom+: { axisCenteredZero: value } } } }, + '#withAxisColorMode': { 'function': { args: [{ default: null, enums: ['text', 'series'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withAxisColorMode(value): { fieldConfig+: { defaults+: { custom+: { axisColorMode: value } } } }, + '#withAxisGridShow': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAxisGridShow(value=true): { fieldConfig+: { defaults+: { custom+: { axisGridShow: value } } } }, + '#withAxisLabel': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withAxisLabel(value): { fieldConfig+: { defaults+: { custom+: { axisLabel: value } } } }, + '#withAxisPlacement': { 'function': { args: [{ default: null, enums: ['auto', 'top', 'right', 'bottom', 'left', 'hidden'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withAxisPlacement(value): { fieldConfig+: { defaults+: { custom+: { axisPlacement: value } } } }, + '#withAxisSoftMax': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisSoftMax(value): { fieldConfig+: { defaults+: { custom+: { axisSoftMax: value } } } }, + '#withAxisSoftMin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisSoftMin(value): { fieldConfig+: { defaults+: { custom+: { axisSoftMin: value } } } }, + '#withAxisWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisWidth(value): { fieldConfig+: { defaults+: { custom+: { axisWidth: value } } } }, + '#withScaleDistribution': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistribution(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution: value } } } }, + '#withScaleDistributionMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistributionMixin(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: value } } } }, + scaleDistribution+: + { + '#withLinearThreshold': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLinearThreshold(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: { linearThreshold: value } } } } }, + '#withLog': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLog(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: { log: value } } } } }, + '#withType': { 'function': { args: [{ default: null, enums: ['linear', 'log', 'ordinal', 'symlog'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withType(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: { type: value } } } } }, + }, + '#withHideFrom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFrom(value): { fieldConfig+: { defaults+: { custom+: { hideFrom: value } } } }, + '#withHideFromMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFromMixin(value): { fieldConfig+: { defaults+: { custom+: { hideFrom+: value } } } }, + hideFrom+: + { + '#withLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withLegend(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { legend: value } } } } }, + '#withTooltip': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withTooltip(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { tooltip: value } } } } }, + '#withViz': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withViz(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { viz: value } } } } }, + }, + '#withFillOpacity': { 'function': { args: [{ default: 80, enums: null, name: 'value', type: 'integer' }], help: 'Controls the fill opacity of the bars.' } }, + withFillOpacity(value=80): { fieldConfig+: { defaults+: { custom+: { fillOpacity: value } } } }, + '#withGradientMode': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Set the mode of the gradient fill. Fill gradient is based on the line color. To change the color, use the standard color scheme field option.\nGradient appearance is influenced by the Fill opacity setting.' } }, + withGradientMode(value): { fieldConfig+: { defaults+: { custom+: { gradientMode: value } } } }, + '#withLineWidth': { 'function': { args: [{ default: 1, enums: null, name: 'value', type: 'integer' }], help: 'Controls line width of the bars.' } }, + withLineWidth(value=1): { fieldConfig+: { defaults+: { custom+: { lineWidth: value } } } }, + }, + }, + }, + options+: + { + '#withLegend': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLegend(value): { options+: { legend: value } }, + '#withLegendMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLegendMixin(value): { options+: { legend+: value } }, + legend+: + { + '#withAsTable': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAsTable(value=true): { options+: { legend+: { asTable: value } } }, + '#withCalcs': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withCalcs(value): { options+: { legend+: { calcs: (if std.isArray(value) + then value + else [value]) } } }, + '#withCalcsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withCalcsMixin(value): { options+: { legend+: { calcs+: (if std.isArray(value) + then value + else [value]) } } }, + '#withDisplayMode': { 'function': { args: [{ default: null, enums: ['list', 'table', 'hidden'], name: 'value', type: 'string' }], help: 'TODO docs\nNote: "hidden" needs to remain as an option for plugins compatibility' } }, + withDisplayMode(value): { options+: { legend+: { displayMode: value } } }, + '#withIsVisible': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withIsVisible(value=true): { options+: { legend+: { isVisible: value } } }, + '#withPlacement': { 'function': { args: [{ default: null, enums: ['bottom', 'right'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withPlacement(value): { options+: { legend+: { placement: value } } }, + '#withShowLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowLegend(value=true): { options+: { legend+: { showLegend: value } } }, + '#withSortBy': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withSortBy(value): { options+: { legend+: { sortBy: value } } }, + '#withSortDesc': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withSortDesc(value=true): { options+: { legend+: { sortDesc: value } } }, + '#withWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withWidth(value): { options+: { legend+: { width: value } } }, + }, + '#withTooltip': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTooltip(value): { options+: { tooltip: value } }, + '#withTooltipMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTooltipMixin(value): { options+: { tooltip+: value } }, + tooltip+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['single', 'multi', 'none'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withMode(value): { options+: { tooltip+: { mode: value } } }, + '#withSort': { 'function': { args: [{ default: null, enums: ['asc', 'desc', 'none'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withSort(value): { options+: { tooltip+: { sort: value } } }, + }, + '#withBucketOffset': { 'function': { args: [{ default: 0, enums: null, name: 'value', type: 'integer' }], help: 'Offset buckets by this amount' } }, + withBucketOffset(value=0): { options+: { bucketOffset: value } }, + '#withBucketSize': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'Size of each bucket' } }, + withBucketSize(value): { options+: { bucketSize: value } }, + '#withCombine': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Combines multiple series into a single histogram' } }, + withCombine(value=true): { options+: { combine: value } }, + }, +} ++ { panelOptions+: { '#withType':: {} } } diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/logs.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/logs.libsonnet new file mode 100644 index 0000000000..cd95ac5c8f --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/logs.libsonnet @@ -0,0 +1,30 @@ +// This file is generated, do not manually edit. +(import '../../clean/panel.libsonnet') ++ { + '#': { help: 'grafonnet.panel.logs', name: 'logs' }, + panelOptions+: + { + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'logs' }, + }, + options+: + { + '#withDedupStrategy': { 'function': { args: [{ default: null, enums: ['none', 'exact', 'numbers', 'signature'], name: 'value', type: 'string' }], help: '' } }, + withDedupStrategy(value): { options+: { dedupStrategy: value } }, + '#withEnableLogDetails': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withEnableLogDetails(value=true): { options+: { enableLogDetails: value } }, + '#withPrettifyLogMessage': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withPrettifyLogMessage(value=true): { options+: { prettifyLogMessage: value } }, + '#withShowCommonLabels': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowCommonLabels(value=true): { options+: { showCommonLabels: value } }, + '#withShowLabels': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowLabels(value=true): { options+: { showLabels: value } }, + '#withShowTime': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowTime(value=true): { options+: { showTime: value } }, + '#withSortOrder': { 'function': { args: [{ default: null, enums: ['Descending', 'Ascending'], name: 'value', type: 'string' }], help: '' } }, + withSortOrder(value): { options+: { sortOrder: value } }, + '#withWrapLogMessage': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withWrapLogMessage(value=true): { options+: { wrapLogMessage: value } }, + }, +} ++ { panelOptions+: { '#withType':: {} } } diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/news.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/news.libsonnet new file mode 100644 index 0000000000..1c44759dd1 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/news.libsonnet @@ -0,0 +1,18 @@ +// This file is generated, do not manually edit. +(import '../../clean/panel.libsonnet') ++ { + '#': { help: 'grafonnet.panel.news', name: 'news' }, + panelOptions+: + { + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'news' }, + }, + options+: + { + '#withFeedUrl': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'empty/missing will default to grafana blog' } }, + withFeedUrl(value): { options+: { feedUrl: value } }, + '#withShowImage': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowImage(value=true): { options+: { showImage: value } }, + }, +} ++ { panelOptions+: { '#withType':: {} } } diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/nodeGraph.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/nodeGraph.libsonnet new file mode 100644 index 0000000000..0cfc3e7bcc --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/nodeGraph.libsonnet @@ -0,0 +1,52 @@ +// This file is generated, do not manually edit. +(import '../../clean/panel.libsonnet') ++ { + '#': { help: 'grafonnet.panel.nodeGraph', name: 'nodeGraph' }, + panelOptions+: + { + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'nodeGraph' }, + }, + options+: + { + '#withEdges': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withEdges(value): { options+: { edges: value } }, + '#withEdgesMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withEdgesMixin(value): { options+: { edges+: value } }, + edges+: + { + '#withMainStatUnit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Unit for the main stat to override what ever is set in the data frame.' } }, + withMainStatUnit(value): { options+: { edges+: { mainStatUnit: value } } }, + '#withSecondaryStatUnit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Unit for the secondary stat to override what ever is set in the data frame.' } }, + withSecondaryStatUnit(value): { options+: { edges+: { secondaryStatUnit: value } } }, + }, + '#withNodes': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withNodes(value): { options+: { nodes: value } }, + '#withNodesMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withNodesMixin(value): { options+: { nodes+: value } }, + nodes+: + { + '#withArcs': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Define which fields are shown as part of the node arc (colored circle around the node).' } }, + withArcs(value): { options+: { nodes+: { arcs: (if std.isArray(value) + then value + else [value]) } } }, + '#withArcsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Define which fields are shown as part of the node arc (colored circle around the node).' } }, + withArcsMixin(value): { options+: { nodes+: { arcs+: (if std.isArray(value) + then value + else [value]) } } }, + arcs+: + { + '#': { help: '', name: 'arcs' }, + '#withColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The color of the arc.' } }, + withColor(value): { color: value }, + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Field from which to get the value. Values should be less than 1, representing fraction of a circle.' } }, + withField(value): { field: value }, + }, + '#withMainStatUnit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Unit for the main stat to override what ever is set in the data frame.' } }, + withMainStatUnit(value): { options+: { nodes+: { mainStatUnit: value } } }, + '#withSecondaryStatUnit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Unit for the secondary stat to override what ever is set in the data frame.' } }, + withSecondaryStatUnit(value): { options+: { nodes+: { secondaryStatUnit: value } } }, + }, + }, +} ++ { panelOptions+: { '#withType':: {} } } diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/pieChart.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/pieChart.libsonnet new file mode 100644 index 0000000000..4854949e5c --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/pieChart.libsonnet @@ -0,0 +1,130 @@ +// This file is generated, do not manually edit. +(import '../../clean/panel.libsonnet') ++ { + '#': { help: 'grafonnet.panel.pieChart', name: 'pieChart' }, + panelOptions+: + { + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'piechart' }, + }, + fieldConfig+: + { + defaults+: + { + custom+: + { + '#withHideFrom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFrom(value): { fieldConfig+: { defaults+: { custom+: { hideFrom: value } } } }, + '#withHideFromMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFromMixin(value): { fieldConfig+: { defaults+: { custom+: { hideFrom+: value } } } }, + hideFrom+: + { + '#withLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withLegend(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { legend: value } } } } }, + '#withTooltip': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withTooltip(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { tooltip: value } } } } }, + '#withViz': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withViz(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { viz: value } } } } }, + }, + }, + }, + }, + options+: + { + '#withTooltip': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTooltip(value): { options+: { tooltip: value } }, + '#withTooltipMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTooltipMixin(value): { options+: { tooltip+: value } }, + tooltip+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['single', 'multi', 'none'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withMode(value): { options+: { tooltip+: { mode: value } } }, + '#withSort': { 'function': { args: [{ default: null, enums: ['asc', 'desc', 'none'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withSort(value): { options+: { tooltip+: { sort: value } } }, + }, + '#withText': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withText(value): { options+: { text: value } }, + '#withTextMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTextMixin(value): { options+: { text+: value } }, + text+: + { + '#withTitleSize': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Explicit title text size' } }, + withTitleSize(value): { options+: { text+: { titleSize: value } } }, + '#withValueSize': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Explicit value text size' } }, + withValueSize(value): { options+: { text+: { valueSize: value } } }, + }, + '#withOrientation': { 'function': { args: [{ default: null, enums: ['auto', 'vertical', 'horizontal'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withOrientation(value): { options+: { orientation: value } }, + '#withReduceOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withReduceOptions(value): { options+: { reduceOptions: value } }, + '#withReduceOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withReduceOptionsMixin(value): { options+: { reduceOptions+: value } }, + reduceOptions+: + { + '#withCalcs': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'When !values, pick one value for the whole field' } }, + withCalcs(value): { options+: { reduceOptions+: { calcs: (if std.isArray(value) + then value + else [value]) } } }, + '#withCalcsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'When !values, pick one value for the whole field' } }, + withCalcsMixin(value): { options+: { reduceOptions+: { calcs+: (if std.isArray(value) + then value + else [value]) } } }, + '#withFields': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Which fields to show. By default this is only numeric fields' } }, + withFields(value): { options+: { reduceOptions+: { fields: value } } }, + '#withLimit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'if showing all values limit' } }, + withLimit(value): { options+: { reduceOptions+: { limit: value } } }, + '#withValues': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'If true show each row value' } }, + withValues(value=true): { options+: { reduceOptions+: { values: value } } }, + }, + '#withDisplayLabels': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withDisplayLabels(value): { options+: { displayLabels: (if std.isArray(value) + then value + else [value]) } }, + '#withDisplayLabelsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withDisplayLabelsMixin(value): { options+: { displayLabels+: (if std.isArray(value) + then value + else [value]) } }, + '#withLegend': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withLegend(value): { options+: { legend: value } }, + '#withLegendMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withLegendMixin(value): { options+: { legend+: value } }, + legend+: + { + '#withAsTable': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAsTable(value=true): { options+: { legend+: { asTable: value } } }, + '#withCalcs': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withCalcs(value): { options+: { legend+: { calcs: (if std.isArray(value) + then value + else [value]) } } }, + '#withCalcsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withCalcsMixin(value): { options+: { legend+: { calcs+: (if std.isArray(value) + then value + else [value]) } } }, + '#withDisplayMode': { 'function': { args: [{ default: null, enums: ['list', 'table', 'hidden'], name: 'value', type: 'string' }], help: 'TODO docs\nNote: "hidden" needs to remain as an option for plugins compatibility' } }, + withDisplayMode(value): { options+: { legend+: { displayMode: value } } }, + '#withIsVisible': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withIsVisible(value=true): { options+: { legend+: { isVisible: value } } }, + '#withPlacement': { 'function': { args: [{ default: null, enums: ['bottom', 'right'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withPlacement(value): { options+: { legend+: { placement: value } } }, + '#withShowLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowLegend(value=true): { options+: { legend+: { showLegend: value } } }, + '#withSortBy': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withSortBy(value): { options+: { legend+: { sortBy: value } } }, + '#withSortDesc': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withSortDesc(value=true): { options+: { legend+: { sortDesc: value } } }, + '#withWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withWidth(value): { options+: { legend+: { width: value } } }, + '#withValues': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withValues(value): { options+: { legend+: { values: (if std.isArray(value) + then value + else [value]) } } }, + '#withValuesMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withValuesMixin(value): { options+: { legend+: { values+: (if std.isArray(value) + then value + else [value]) } } }, + }, + '#withPieType': { 'function': { args: [{ default: null, enums: ['pie', 'donut'], name: 'value', type: 'string' }], help: 'Select the pie chart display style.' } }, + withPieType(value): { options+: { pieType: value } }, + }, +} ++ { panelOptions+: { '#withType':: {} } } diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/stat.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/stat.libsonnet new file mode 100644 index 0000000000..d6b5f8bc25 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/stat.libsonnet @@ -0,0 +1,56 @@ +// This file is generated, do not manually edit. +(import '../../clean/panel.libsonnet') ++ { + '#': { help: 'grafonnet.panel.stat', name: 'stat' }, + panelOptions+: + { + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'stat' }, + }, + options+: + { + '#withText': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withText(value): { options+: { text: value } }, + '#withTextMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTextMixin(value): { options+: { text+: value } }, + text+: + { + '#withTitleSize': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Explicit title text size' } }, + withTitleSize(value): { options+: { text+: { titleSize: value } } }, + '#withValueSize': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Explicit value text size' } }, + withValueSize(value): { options+: { text+: { valueSize: value } } }, + }, + '#withOrientation': { 'function': { args: [{ default: null, enums: ['auto', 'vertical', 'horizontal'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withOrientation(value): { options+: { orientation: value } }, + '#withReduceOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withReduceOptions(value): { options+: { reduceOptions: value } }, + '#withReduceOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withReduceOptionsMixin(value): { options+: { reduceOptions+: value } }, + reduceOptions+: + { + '#withCalcs': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'When !values, pick one value for the whole field' } }, + withCalcs(value): { options+: { reduceOptions+: { calcs: (if std.isArray(value) + then value + else [value]) } } }, + '#withCalcsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'When !values, pick one value for the whole field' } }, + withCalcsMixin(value): { options+: { reduceOptions+: { calcs+: (if std.isArray(value) + then value + else [value]) } } }, + '#withFields': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Which fields to show. By default this is only numeric fields' } }, + withFields(value): { options+: { reduceOptions+: { fields: value } } }, + '#withLimit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'if showing all values limit' } }, + withLimit(value): { options+: { reduceOptions+: { limit: value } } }, + '#withValues': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'If true show each row value' } }, + withValues(value=true): { options+: { reduceOptions+: { values: value } } }, + }, + '#withColorMode': { 'function': { args: [{ default: null, enums: ['value', 'background', 'background_solid', 'none'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withColorMode(value): { options+: { colorMode: value } }, + '#withGraphMode': { 'function': { args: [{ default: null, enums: ['none', 'line', 'area'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withGraphMode(value): { options+: { graphMode: value } }, + '#withJustifyMode': { 'function': { args: [{ default: null, enums: ['auto', 'center'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withJustifyMode(value): { options+: { justifyMode: value } }, + '#withTextMode': { 'function': { args: [{ default: null, enums: ['auto', 'value', 'value_and_name', 'name', 'none'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withTextMode(value): { options+: { textMode: value } }, + }, +} ++ { panelOptions+: { '#withType':: {} } } diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/stateTimeline.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/stateTimeline.libsonnet new file mode 100644 index 0000000000..1e75e691ef --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/stateTimeline.libsonnet @@ -0,0 +1,98 @@ +// This file is generated, do not manually edit. +(import '../../clean/panel.libsonnet') ++ { + '#': { help: 'grafonnet.panel.stateTimeline', name: 'stateTimeline' }, + panelOptions+: + { + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'state-timeline' }, + }, + fieldConfig+: + { + defaults+: + { + custom+: + { + '#withHideFrom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFrom(value): { fieldConfig+: { defaults+: { custom+: { hideFrom: value } } } }, + '#withHideFromMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFromMixin(value): { fieldConfig+: { defaults+: { custom+: { hideFrom+: value } } } }, + hideFrom+: + { + '#withLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withLegend(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { legend: value } } } } }, + '#withTooltip': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withTooltip(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { tooltip: value } } } } }, + '#withViz': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withViz(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { viz: value } } } } }, + }, + '#withFillOpacity': { 'function': { args: [{ default: 70, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withFillOpacity(value=70): { fieldConfig+: { defaults+: { custom+: { fillOpacity: value } } } }, + '#withLineWidth': { 'function': { args: [{ default: 0, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withLineWidth(value=0): { fieldConfig+: { defaults+: { custom+: { lineWidth: value } } } }, + }, + }, + }, + options+: + { + '#withLegend': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLegend(value): { options+: { legend: value } }, + '#withLegendMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLegendMixin(value): { options+: { legend+: value } }, + legend+: + { + '#withAsTable': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAsTable(value=true): { options+: { legend+: { asTable: value } } }, + '#withCalcs': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withCalcs(value): { options+: { legend+: { calcs: (if std.isArray(value) + then value + else [value]) } } }, + '#withCalcsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withCalcsMixin(value): { options+: { legend+: { calcs+: (if std.isArray(value) + then value + else [value]) } } }, + '#withDisplayMode': { 'function': { args: [{ default: null, enums: ['list', 'table', 'hidden'], name: 'value', type: 'string' }], help: 'TODO docs\nNote: "hidden" needs to remain as an option for plugins compatibility' } }, + withDisplayMode(value): { options+: { legend+: { displayMode: value } } }, + '#withIsVisible': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withIsVisible(value=true): { options+: { legend+: { isVisible: value } } }, + '#withPlacement': { 'function': { args: [{ default: null, enums: ['bottom', 'right'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withPlacement(value): { options+: { legend+: { placement: value } } }, + '#withShowLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowLegend(value=true): { options+: { legend+: { showLegend: value } } }, + '#withSortBy': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withSortBy(value): { options+: { legend+: { sortBy: value } } }, + '#withSortDesc': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withSortDesc(value=true): { options+: { legend+: { sortDesc: value } } }, + '#withWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withWidth(value): { options+: { legend+: { width: value } } }, + }, + '#withTooltip': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTooltip(value): { options+: { tooltip: value } }, + '#withTooltipMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTooltipMixin(value): { options+: { tooltip+: value } }, + tooltip+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['single', 'multi', 'none'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withMode(value): { options+: { tooltip+: { mode: value } } }, + '#withSort': { 'function': { args: [{ default: null, enums: ['asc', 'desc', 'none'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withSort(value): { options+: { tooltip+: { sort: value } } }, + }, + '#withTimezone': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTimezone(value): { options+: { timezone: (if std.isArray(value) + then value + else [value]) } }, + '#withTimezoneMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTimezoneMixin(value): { options+: { timezone+: (if std.isArray(value) + then value + else [value]) } }, + '#withAlignValue': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Controls value alignment on the timelines' } }, + withAlignValue(value): { options+: { alignValue: value } }, + '#withMergeValues': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Merge equal consecutive values' } }, + withMergeValues(value=true): { options+: { mergeValues: value } }, + '#withRowHeight': { 'function': { args: [{ default: 0.90000000000000002, enums: null, name: 'value', type: 'number' }], help: 'Controls the row height' } }, + withRowHeight(value=0.90000000000000002): { options+: { rowHeight: value } }, + '#withShowValue': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Show timeline values on chart' } }, + withShowValue(value): { options+: { showValue: value } }, + }, +} ++ { panelOptions+: { '#withType':: {} } } diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/statusHistory.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/statusHistory.libsonnet new file mode 100644 index 0000000000..9fe7e6b3d9 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/statusHistory.libsonnet @@ -0,0 +1,96 @@ +// This file is generated, do not manually edit. +(import '../../clean/panel.libsonnet') ++ { + '#': { help: 'grafonnet.panel.statusHistory', name: 'statusHistory' }, + panelOptions+: + { + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'status-history' }, + }, + fieldConfig+: + { + defaults+: + { + custom+: + { + '#withHideFrom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFrom(value): { fieldConfig+: { defaults+: { custom+: { hideFrom: value } } } }, + '#withHideFromMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFromMixin(value): { fieldConfig+: { defaults+: { custom+: { hideFrom+: value } } } }, + hideFrom+: + { + '#withLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withLegend(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { legend: value } } } } }, + '#withTooltip': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withTooltip(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { tooltip: value } } } } }, + '#withViz': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withViz(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { viz: value } } } } }, + }, + '#withFillOpacity': { 'function': { args: [{ default: 70, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withFillOpacity(value=70): { fieldConfig+: { defaults+: { custom+: { fillOpacity: value } } } }, + '#withLineWidth': { 'function': { args: [{ default: 1, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withLineWidth(value=1): { fieldConfig+: { defaults+: { custom+: { lineWidth: value } } } }, + }, + }, + }, + options+: + { + '#withLegend': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLegend(value): { options+: { legend: value } }, + '#withLegendMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLegendMixin(value): { options+: { legend+: value } }, + legend+: + { + '#withAsTable': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAsTable(value=true): { options+: { legend+: { asTable: value } } }, + '#withCalcs': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withCalcs(value): { options+: { legend+: { calcs: (if std.isArray(value) + then value + else [value]) } } }, + '#withCalcsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withCalcsMixin(value): { options+: { legend+: { calcs+: (if std.isArray(value) + then value + else [value]) } } }, + '#withDisplayMode': { 'function': { args: [{ default: null, enums: ['list', 'table', 'hidden'], name: 'value', type: 'string' }], help: 'TODO docs\nNote: "hidden" needs to remain as an option for plugins compatibility' } }, + withDisplayMode(value): { options+: { legend+: { displayMode: value } } }, + '#withIsVisible': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withIsVisible(value=true): { options+: { legend+: { isVisible: value } } }, + '#withPlacement': { 'function': { args: [{ default: null, enums: ['bottom', 'right'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withPlacement(value): { options+: { legend+: { placement: value } } }, + '#withShowLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowLegend(value=true): { options+: { legend+: { showLegend: value } } }, + '#withSortBy': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withSortBy(value): { options+: { legend+: { sortBy: value } } }, + '#withSortDesc': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withSortDesc(value=true): { options+: { legend+: { sortDesc: value } } }, + '#withWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withWidth(value): { options+: { legend+: { width: value } } }, + }, + '#withTooltip': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTooltip(value): { options+: { tooltip: value } }, + '#withTooltipMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTooltipMixin(value): { options+: { tooltip+: value } }, + tooltip+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['single', 'multi', 'none'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withMode(value): { options+: { tooltip+: { mode: value } } }, + '#withSort': { 'function': { args: [{ default: null, enums: ['asc', 'desc', 'none'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withSort(value): { options+: { tooltip+: { sort: value } } }, + }, + '#withTimezone': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTimezone(value): { options+: { timezone: (if std.isArray(value) + then value + else [value]) } }, + '#withTimezoneMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTimezoneMixin(value): { options+: { timezone+: (if std.isArray(value) + then value + else [value]) } }, + '#withColWidth': { 'function': { args: [{ default: 0.90000000000000002, enums: null, name: 'value', type: 'number' }], help: 'Controls the column width' } }, + withColWidth(value=0.90000000000000002): { options+: { colWidth: value } }, + '#withRowHeight': { 'function': { args: [{ default: 0.90000000000000002, enums: null, name: 'value', type: 'number' }], help: 'Set the height of the rows' } }, + withRowHeight(value=0.90000000000000002): { options+: { rowHeight: value } }, + '#withShowValue': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Show values on the columns' } }, + withShowValue(value): { options+: { showValue: value } }, + }, +} ++ { panelOptions+: { '#withType':: {} } } diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/table.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/table.libsonnet new file mode 100644 index 0000000000..ad3f1bc1a3 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/table.libsonnet @@ -0,0 +1,288 @@ +// This file is generated, do not manually edit. +(import '../../clean/panel.libsonnet') ++ { + '#': { help: 'grafonnet.panel.table', name: 'table' }, + panelOptions+: + { + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'table' }, + }, + fieldConfig+: + { + defaults+: + { + custom+: + { + '#withAlign': { 'function': { args: [{ default: null, enums: ['auto', 'left', 'right', 'center'], name: 'value', type: 'string' }], help: 'TODO -- should not be table specific! TODO docs' } }, + withAlign(value): { fieldConfig+: { defaults+: { custom+: { align: value } } } }, + '#withCellOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Table cell options. Each cell has a display mode and other potential options for that display.' } }, + withCellOptions(value): { fieldConfig+: { defaults+: { custom+: { cellOptions: value } } } }, + '#withCellOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Table cell options. Each cell has a display mode and other potential options for that display.' } }, + withCellOptionsMixin(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: value } } } }, + cellOptions+: + { + '#withTableAutoCellOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Auto mode table cell options' } }, + withTableAutoCellOptions(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { TableAutoCellOptions: value } } } } }, + '#withTableAutoCellOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Auto mode table cell options' } }, + withTableAutoCellOptionsMixin(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { TableAutoCellOptions+: value } } } } }, + TableAutoCellOptions+: + { + '#withType': { 'function': { args: [], help: '' } }, + withType(): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { type: 'auto' } } } } }, + }, + '#withTableSparklineCellOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Sparkline cell options' } }, + withTableSparklineCellOptions(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { TableSparklineCellOptions: value } } } } }, + '#withTableSparklineCellOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Sparkline cell options' } }, + withTableSparklineCellOptionsMixin(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { TableSparklineCellOptions+: value } } } } }, + TableSparklineCellOptions+: + { + '#withAxisCenteredZero': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAxisCenteredZero(value=true): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { axisCenteredZero: value } } } } }, + '#withAxisColorMode': { 'function': { args: [{ default: null, enums: ['series', 'text'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withAxisColorMode(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { axisColorMode: value } } } } }, + '#withAxisGridShow': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAxisGridShow(value=true): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { axisGridShow: value } } } } }, + '#withAxisLabel': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withAxisLabel(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { axisLabel: value } } } } }, + '#withAxisPlacement': { 'function': { args: [{ default: null, enums: ['auto', 'bottom', 'hidden', 'left', 'right', 'top'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withAxisPlacement(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { axisPlacement: value } } } } }, + '#withAxisSoftMax': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisSoftMax(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { axisSoftMax: value } } } } }, + '#withAxisSoftMin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisSoftMin(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { axisSoftMin: value } } } } }, + '#withAxisWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisWidth(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { axisWidth: value } } } } }, + '#withBarAlignment': { 'function': { args: [{ default: null, enums: [1, -1, 0], name: 'value', type: 'number' }], help: 'TODO docs' } }, + withBarAlignment(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { barAlignment: value } } } } }, + '#withBarMaxWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withBarMaxWidth(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { barMaxWidth: value } } } } }, + '#withBarWidthFactor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withBarWidthFactor(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { barWidthFactor: value } } } } }, + '#withDrawStyle': { 'function': { args: [{ default: null, enums: ['bars', 'line', 'points'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withDrawStyle(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { drawStyle: value } } } } }, + '#withFillBelowTo': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withFillBelowTo(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { fillBelowTo: value } } } } }, + '#withFillColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withFillColor(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { fillColor: value } } } } }, + '#withFillOpacity': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withFillOpacity(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { fillOpacity: value } } } } }, + '#withGradientMode': { 'function': { args: [{ default: null, enums: ['hue', 'none', 'opacity', 'scheme'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withGradientMode(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { gradientMode: value } } } } }, + '#withHideFrom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFrom(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { hideFrom: value } } } } }, + '#withHideFromMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFromMixin(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { hideFrom+: value } } } } }, + hideFrom+: + { + '#withLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withLegend(value=true): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { hideFrom+: { legend: value } } } } } }, + '#withTooltip': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withTooltip(value=true): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { hideFrom+: { tooltip: value } } } } } }, + '#withViz': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withViz(value=true): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { hideFrom+: { viz: value } } } } } }, + }, + '#withLineColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withLineColor(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { lineColor: value } } } } }, + '#withLineInterpolation': { 'function': { args: [{ default: null, enums: ['linear', 'smooth', 'stepAfter', 'stepBefore'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withLineInterpolation(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { lineInterpolation: value } } } } }, + '#withLineStyle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLineStyle(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { lineStyle: value } } } } }, + '#withLineStyleMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLineStyleMixin(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { lineStyle+: value } } } } }, + lineStyle+: + { + '#withDash': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withDash(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { lineStyle+: { dash: (if std.isArray(value) + then value + else [value]) } } } } } }, + '#withDashMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withDashMixin(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { lineStyle+: { dash+: (if std.isArray(value) + then value + else [value]) } } } } } }, + '#withFill': { 'function': { args: [{ default: null, enums: ['solid', 'dash', 'dot', 'square'], name: 'value', type: 'string' }], help: '' } }, + withFill(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { lineStyle+: { fill: value } } } } } }, + }, + '#withLineWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLineWidth(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { lineWidth: value } } } } }, + '#withPointColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withPointColor(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { pointColor: value } } } } }, + '#withPointSize': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withPointSize(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { pointSize: value } } } } }, + '#withPointSymbol': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withPointSymbol(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { pointSymbol: value } } } } }, + '#withScaleDistribution': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistribution(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { scaleDistribution: value } } } } }, + '#withScaleDistributionMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistributionMixin(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { scaleDistribution+: value } } } } }, + scaleDistribution+: + { + '#withLinearThreshold': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLinearThreshold(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { scaleDistribution+: { linearThreshold: value } } } } } }, + '#withLog': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLog(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { scaleDistribution+: { log: value } } } } } }, + '#withType': { 'function': { args: [{ default: null, enums: ['linear', 'log', 'ordinal', 'symlog'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withType(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { scaleDistribution+: { type: value } } } } } }, + }, + '#withShowPoints': { 'function': { args: [{ default: null, enums: ['always', 'auto', 'never'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withShowPoints(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { showPoints: value } } } } }, + '#withSpanNulls': { 'function': { args: [{ default: null, enums: null, name: 'value', type: ['boolean', 'number'] }], help: 'Indicate if null values should be treated as gaps or connected. When the value is a number, it represents the maximum delta in the X axis that should be considered connected. For timeseries, this is milliseconds' } }, + withSpanNulls(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { spanNulls: value } } } } }, + '#withStacking': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withStacking(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { stacking: value } } } } }, + '#withStackingMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withStackingMixin(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { stacking+: value } } } } }, + stacking+: + { + '#withGroup': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withGroup(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { stacking+: { group: value } } } } } }, + '#withMode': { 'function': { args: [{ default: null, enums: ['none', 'normal', 'percent'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withMode(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { stacking+: { mode: value } } } } } }, + }, + '#withThresholdsStyle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withThresholdsStyle(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { thresholdsStyle: value } } } } }, + '#withThresholdsStyleMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withThresholdsStyleMixin(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { thresholdsStyle+: value } } } } }, + thresholdsStyle+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['area', 'dashed', 'dashed+area', 'line', 'line+area', 'off', 'series'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withMode(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { thresholdsStyle+: { mode: value } } } } } }, + }, + '#withTransform': { 'function': { args: [{ default: null, enums: ['constant', 'negative-Y'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withTransform(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { transform: value } } } } }, + '#withType': { 'function': { args: [], help: '' } }, + withType(): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { type: 'sparkline' } } } } }, + }, + '#withTableBarGaugeCellOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Gauge cell options' } }, + withTableBarGaugeCellOptions(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { TableBarGaugeCellOptions: value } } } } }, + '#withTableBarGaugeCellOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Gauge cell options' } }, + withTableBarGaugeCellOptionsMixin(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { TableBarGaugeCellOptions+: value } } } } }, + TableBarGaugeCellOptions+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['basic', 'gradient', 'lcd'], name: 'value', type: 'string' }], help: 'Enum expressing the possible display modes for the bar gauge component of Grafana UI' } }, + withMode(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { mode: value } } } } }, + '#withType': { 'function': { args: [], help: '' } }, + withType(): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { type: 'gauge' } } } } }, + '#withValueDisplayMode': { 'function': { args: [{ default: null, enums: ['color', 'hidden', 'text'], name: 'value', type: 'string' }], help: 'Allows for the table cell gauge display type to set the gauge mode.' } }, + withValueDisplayMode(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { valueDisplayMode: value } } } } }, + }, + '#withTableColoredBackgroundCellOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Colored background cell options' } }, + withTableColoredBackgroundCellOptions(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { TableColoredBackgroundCellOptions: value } } } } }, + '#withTableColoredBackgroundCellOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Colored background cell options' } }, + withTableColoredBackgroundCellOptionsMixin(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { TableColoredBackgroundCellOptions+: value } } } } }, + TableColoredBackgroundCellOptions+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['basic', 'gradient'], name: 'value', type: 'string' }], help: 'Display mode to the "Colored Background" display mode for table cells. Either displays a solid color (basic mode) or a gradient.' } }, + withMode(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { mode: value } } } } }, + '#withType': { 'function': { args: [], help: '' } }, + withType(): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { type: 'color-background' } } } } }, + }, + '#withTableColorTextCellOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Colored text cell options' } }, + withTableColorTextCellOptions(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { TableColorTextCellOptions: value } } } } }, + '#withTableColorTextCellOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Colored text cell options' } }, + withTableColorTextCellOptionsMixin(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { TableColorTextCellOptions+: value } } } } }, + TableColorTextCellOptions+: + { + '#withType': { 'function': { args: [], help: '' } }, + withType(): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { type: 'color-text' } } } } }, + }, + '#withTableImageCellOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Json view cell options' } }, + withTableImageCellOptions(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { TableImageCellOptions: value } } } } }, + '#withTableImageCellOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Json view cell options' } }, + withTableImageCellOptionsMixin(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { TableImageCellOptions+: value } } } } }, + TableImageCellOptions+: + { + '#withType': { 'function': { args: [], help: '' } }, + withType(): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { type: 'image' } } } } }, + }, + '#withTableJsonViewCellOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Json view cell options' } }, + withTableJsonViewCellOptions(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { TableJsonViewCellOptions: value } } } } }, + '#withTableJsonViewCellOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Json view cell options' } }, + withTableJsonViewCellOptionsMixin(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { TableJsonViewCellOptions+: value } } } } }, + TableJsonViewCellOptions+: + { + '#withType': { 'function': { args: [], help: '' } }, + withType(): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { type: 'json-view' } } } } }, + }, + }, + '#withDisplayMode': { 'function': { args: [{ default: null, enums: ['auto', 'basic', 'color-background', 'color-background-solid', 'color-text', 'custom', 'gauge', 'gradient-gauge', 'image', 'json-view', 'lcd-gauge', 'sparkline'], name: 'value', type: 'string' }], help: "Internally, this is the \"type\" of cell that's being displayed in the table such as colored text, JSON, gauge, etc. The color-background-solid, gradient-gauge, and lcd-gauge modes are deprecated in favor of new cell subOptions" } }, + withDisplayMode(value): { fieldConfig+: { defaults+: { custom+: { displayMode: value } } } }, + '#withFilterable': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withFilterable(value=true): { fieldConfig+: { defaults+: { custom+: { filterable: value } } } }, + '#withHidden': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withHidden(value=true): { fieldConfig+: { defaults+: { custom+: { hidden: value } } } }, + '#withHideHeader': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Hides any header for a column, usefull for columns that show some static content or buttons.' } }, + withHideHeader(value=true): { fieldConfig+: { defaults+: { custom+: { hideHeader: value } } } }, + '#withInspect': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withInspect(value=true): { fieldConfig+: { defaults+: { custom+: { inspect: value } } } }, + '#withMinWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withMinWidth(value): { fieldConfig+: { defaults+: { custom+: { minWidth: value } } } }, + '#withWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withWidth(value): { fieldConfig+: { defaults+: { custom+: { width: value } } } }, + }, + }, + }, + options+: + { + '#withCellHeight': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Controls the height of the rows' } }, + withCellHeight(value): { options+: { cellHeight: value } }, + '#withFooter': { 'function': { args: [{ default: { countRows: false, reducer: [], show: false }, enums: null, name: 'value', type: 'object' }], help: 'Controls footer options' } }, + withFooter(value={ countRows: false, reducer: [], show: false }): { options+: { footer: value } }, + '#withFooterMixin': { 'function': { args: [{ default: { countRows: false, reducer: [], show: false }, enums: null, name: 'value', type: 'object' }], help: 'Controls footer options' } }, + withFooterMixin(value): { options+: { footer+: value } }, + footer+: + { + '#withTableFooterOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Footer options' } }, + withTableFooterOptions(value): { options+: { footer+: { TableFooterOptions: value } } }, + '#withTableFooterOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Footer options' } }, + withTableFooterOptionsMixin(value): { options+: { footer+: { TableFooterOptions+: value } } }, + TableFooterOptions+: + { + '#withCountRows': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withCountRows(value=true): { options+: { footer+: { countRows: value } } }, + '#withEnablePagination': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withEnablePagination(value=true): { options+: { footer+: { enablePagination: value } } }, + '#withFields': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withFields(value): { options+: { footer+: { fields: (if std.isArray(value) + then value + else [value]) } } }, + '#withFieldsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withFieldsMixin(value): { options+: { footer+: { fields+: (if std.isArray(value) + then value + else [value]) } } }, + '#withReducer': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withReducer(value): { options+: { footer+: { reducer: (if std.isArray(value) + then value + else [value]) } } }, + '#withReducerMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withReducerMixin(value): { options+: { footer+: { reducer+: (if std.isArray(value) + then value + else [value]) } } }, + '#withShow': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShow(value=true): { options+: { footer+: { show: value } } }, + }, + }, + '#withFrameIndex': { 'function': { args: [{ default: 0, enums: null, name: 'value', type: 'number' }], help: 'Represents the index of the selected frame' } }, + withFrameIndex(value=0): { options+: { frameIndex: value } }, + '#withShowHeader': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Controls whether the panel should show the header' } }, + withShowHeader(value=true): { options+: { showHeader: value } }, + '#withShowTypeIcons': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Controls whether the header should show icons for the column types' } }, + withShowTypeIcons(value=true): { options+: { showTypeIcons: value } }, + '#withSortBy': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Used to control row sorting' } }, + withSortBy(value): { options+: { sortBy: (if std.isArray(value) + then value + else [value]) } }, + '#withSortByMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Used to control row sorting' } }, + withSortByMixin(value): { options+: { sortBy+: (if std.isArray(value) + then value + else [value]) } }, + sortBy+: + { + '#': { help: '', name: 'sortBy' }, + '#withDesc': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Flag used to indicate descending sort order' } }, + withDesc(value=true): { desc: value }, + '#withDisplayName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Sets the display name of the field to sort by' } }, + withDisplayName(value): { displayName: value }, + }, + }, +} ++ { panelOptions+: { '#withType':: {} } } diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/text.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/text.libsonnet new file mode 100644 index 0000000000..fe1101ba10 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/text.libsonnet @@ -0,0 +1,31 @@ +// This file is generated, do not manually edit. +(import '../../clean/panel.libsonnet') ++ { + '#': { help: 'grafonnet.panel.text', name: 'text' }, + panelOptions+: + { + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'text' }, + }, + options+: + { + '#withCode': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withCode(value): { options+: { code: value } }, + '#withCodeMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withCodeMixin(value): { options+: { code+: value } }, + code+: + { + '#withLanguage': { 'function': { args: [{ default: 'plaintext', enums: ['plaintext', 'yaml', 'xml', 'typescript', 'sql', 'go', 'markdown', 'html', 'json'], name: 'value', type: 'string' }], help: '' } }, + withLanguage(value='plaintext'): { options+: { code+: { language: value } } }, + '#withShowLineNumbers': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowLineNumbers(value=true): { options+: { code+: { showLineNumbers: value } } }, + '#withShowMiniMap': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowMiniMap(value=true): { options+: { code+: { showMiniMap: value } } }, + }, + '#withContent': { 'function': { args: [{ default: '# Title\n\nFor markdown syntax help: [commonmark.org/help](https://commonmark.org/help/)', enums: null, name: 'value', type: 'string' }], help: '' } }, + withContent(value='# Title\n\nFor markdown syntax help: [commonmark.org/help](https://commonmark.org/help/)'): { options+: { content: value } }, + '#withMode': { 'function': { args: [{ default: null, enums: ['html', 'markdown', 'code'], name: 'value', type: 'string' }], help: '' } }, + withMode(value): { options+: { mode: value } }, + }, +} ++ { panelOptions+: { '#withType':: {} } } diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/timeSeries.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/timeSeries.libsonnet new file mode 100644 index 0000000000..8c034d5e19 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/timeSeries.libsonnet @@ -0,0 +1,188 @@ +// This file is generated, do not manually edit. +(import '../../clean/panel.libsonnet') ++ { + '#': { help: 'grafonnet.panel.timeSeries', name: 'timeSeries' }, + panelOptions+: + { + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'timeseries' }, + }, + fieldConfig+: + { + defaults+: + { + custom+: + { + '#withLineColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withLineColor(value): { fieldConfig+: { defaults+: { custom+: { lineColor: value } } } }, + '#withLineInterpolation': { 'function': { args: [{ default: null, enums: ['linear', 'smooth', 'stepBefore', 'stepAfter'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withLineInterpolation(value): { fieldConfig+: { defaults+: { custom+: { lineInterpolation: value } } } }, + '#withLineStyle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLineStyle(value): { fieldConfig+: { defaults+: { custom+: { lineStyle: value } } } }, + '#withLineStyleMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLineStyleMixin(value): { fieldConfig+: { defaults+: { custom+: { lineStyle+: value } } } }, + lineStyle+: + { + '#withDash': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withDash(value): { fieldConfig+: { defaults+: { custom+: { lineStyle+: { dash: (if std.isArray(value) + then value + else [value]) } } } } }, + '#withDashMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withDashMixin(value): { fieldConfig+: { defaults+: { custom+: { lineStyle+: { dash+: (if std.isArray(value) + then value + else [value]) } } } } }, + '#withFill': { 'function': { args: [{ default: null, enums: ['solid', 'dash', 'dot', 'square'], name: 'value', type: 'string' }], help: '' } }, + withFill(value): { fieldConfig+: { defaults+: { custom+: { lineStyle+: { fill: value } } } } }, + }, + '#withLineWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLineWidth(value): { fieldConfig+: { defaults+: { custom+: { lineWidth: value } } } }, + '#withSpanNulls': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Indicate if null values should be treated as gaps or connected.\nWhen the value is a number, it represents the maximum delta in the\nX axis that should be considered connected. For timeseries, this is milliseconds' } }, + withSpanNulls(value): { fieldConfig+: { defaults+: { custom+: { spanNulls: value } } } }, + '#withSpanNullsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Indicate if null values should be treated as gaps or connected.\nWhen the value is a number, it represents the maximum delta in the\nX axis that should be considered connected. For timeseries, this is milliseconds' } }, + withSpanNullsMixin(value): { fieldConfig+: { defaults+: { custom+: { spanNulls+: value } } } }, + '#withFillBelowTo': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withFillBelowTo(value): { fieldConfig+: { defaults+: { custom+: { fillBelowTo: value } } } }, + '#withFillColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withFillColor(value): { fieldConfig+: { defaults+: { custom+: { fillColor: value } } } }, + '#withFillOpacity': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withFillOpacity(value): { fieldConfig+: { defaults+: { custom+: { fillOpacity: value } } } }, + '#withPointColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withPointColor(value): { fieldConfig+: { defaults+: { custom+: { pointColor: value } } } }, + '#withPointSize': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withPointSize(value): { fieldConfig+: { defaults+: { custom+: { pointSize: value } } } }, + '#withPointSymbol': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withPointSymbol(value): { fieldConfig+: { defaults+: { custom+: { pointSymbol: value } } } }, + '#withShowPoints': { 'function': { args: [{ default: null, enums: ['auto', 'never', 'always'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withShowPoints(value): { fieldConfig+: { defaults+: { custom+: { showPoints: value } } } }, + '#withAxisCenteredZero': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAxisCenteredZero(value=true): { fieldConfig+: { defaults+: { custom+: { axisCenteredZero: value } } } }, + '#withAxisColorMode': { 'function': { args: [{ default: null, enums: ['text', 'series'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withAxisColorMode(value): { fieldConfig+: { defaults+: { custom+: { axisColorMode: value } } } }, + '#withAxisGridShow': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAxisGridShow(value=true): { fieldConfig+: { defaults+: { custom+: { axisGridShow: value } } } }, + '#withAxisLabel': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withAxisLabel(value): { fieldConfig+: { defaults+: { custom+: { axisLabel: value } } } }, + '#withAxisPlacement': { 'function': { args: [{ default: null, enums: ['auto', 'top', 'right', 'bottom', 'left', 'hidden'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withAxisPlacement(value): { fieldConfig+: { defaults+: { custom+: { axisPlacement: value } } } }, + '#withAxisSoftMax': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisSoftMax(value): { fieldConfig+: { defaults+: { custom+: { axisSoftMax: value } } } }, + '#withAxisSoftMin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisSoftMin(value): { fieldConfig+: { defaults+: { custom+: { axisSoftMin: value } } } }, + '#withAxisWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisWidth(value): { fieldConfig+: { defaults+: { custom+: { axisWidth: value } } } }, + '#withScaleDistribution': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistribution(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution: value } } } }, + '#withScaleDistributionMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistributionMixin(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: value } } } }, + scaleDistribution+: + { + '#withLinearThreshold': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLinearThreshold(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: { linearThreshold: value } } } } }, + '#withLog': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLog(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: { log: value } } } } }, + '#withType': { 'function': { args: [{ default: null, enums: ['linear', 'log', 'ordinal', 'symlog'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withType(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: { type: value } } } } }, + }, + '#withBarAlignment': { 'function': { args: [{ default: null, enums: [-1, 0, 1], name: 'value', type: 'integer' }], help: 'TODO docs' } }, + withBarAlignment(value): { fieldConfig+: { defaults+: { custom+: { barAlignment: value } } } }, + '#withBarMaxWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withBarMaxWidth(value): { fieldConfig+: { defaults+: { custom+: { barMaxWidth: value } } } }, + '#withBarWidthFactor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withBarWidthFactor(value): { fieldConfig+: { defaults+: { custom+: { barWidthFactor: value } } } }, + '#withStacking': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withStacking(value): { fieldConfig+: { defaults+: { custom+: { stacking: value } } } }, + '#withStackingMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withStackingMixin(value): { fieldConfig+: { defaults+: { custom+: { stacking+: value } } } }, + stacking+: + { + '#withGroup': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withGroup(value): { fieldConfig+: { defaults+: { custom+: { stacking+: { group: value } } } } }, + '#withMode': { 'function': { args: [{ default: null, enums: ['none', 'normal', 'percent'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withMode(value): { fieldConfig+: { defaults+: { custom+: { stacking+: { mode: value } } } } }, + }, + '#withHideFrom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFrom(value): { fieldConfig+: { defaults+: { custom+: { hideFrom: value } } } }, + '#withHideFromMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFromMixin(value): { fieldConfig+: { defaults+: { custom+: { hideFrom+: value } } } }, + hideFrom+: + { + '#withLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withLegend(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { legend: value } } } } }, + '#withTooltip': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withTooltip(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { tooltip: value } } } } }, + '#withViz': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withViz(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { viz: value } } } } }, + }, + '#withDrawStyle': { 'function': { args: [{ default: null, enums: ['line', 'bars', 'points'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withDrawStyle(value): { fieldConfig+: { defaults+: { custom+: { drawStyle: value } } } }, + '#withGradientMode': { 'function': { args: [{ default: null, enums: ['none', 'opacity', 'hue', 'scheme'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withGradientMode(value): { fieldConfig+: { defaults+: { custom+: { gradientMode: value } } } }, + '#withThresholdsStyle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withThresholdsStyle(value): { fieldConfig+: { defaults+: { custom+: { thresholdsStyle: value } } } }, + '#withThresholdsStyleMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withThresholdsStyleMixin(value): { fieldConfig+: { defaults+: { custom+: { thresholdsStyle+: value } } } }, + thresholdsStyle+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['off', 'line', 'dashed', 'area', 'line+area', 'dashed+area', 'series'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withMode(value): { fieldConfig+: { defaults+: { custom+: { thresholdsStyle+: { mode: value } } } } }, + }, + '#withTransform': { 'function': { args: [{ default: null, enums: ['constant', 'negative-Y'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withTransform(value): { fieldConfig+: { defaults+: { custom+: { transform: value } } } }, + }, + }, + }, + options+: + { + '#withTimezone': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTimezone(value): { options+: { timezone: (if std.isArray(value) + then value + else [value]) } }, + '#withTimezoneMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTimezoneMixin(value): { options+: { timezone+: (if std.isArray(value) + then value + else [value]) } }, + '#withLegend': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLegend(value): { options+: { legend: value } }, + '#withLegendMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLegendMixin(value): { options+: { legend+: value } }, + legend+: + { + '#withAsTable': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAsTable(value=true): { options+: { legend+: { asTable: value } } }, + '#withCalcs': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withCalcs(value): { options+: { legend+: { calcs: (if std.isArray(value) + then value + else [value]) } } }, + '#withCalcsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withCalcsMixin(value): { options+: { legend+: { calcs+: (if std.isArray(value) + then value + else [value]) } } }, + '#withDisplayMode': { 'function': { args: [{ default: null, enums: ['list', 'table', 'hidden'], name: 'value', type: 'string' }], help: 'TODO docs\nNote: "hidden" needs to remain as an option for plugins compatibility' } }, + withDisplayMode(value): { options+: { legend+: { displayMode: value } } }, + '#withIsVisible': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withIsVisible(value=true): { options+: { legend+: { isVisible: value } } }, + '#withPlacement': { 'function': { args: [{ default: null, enums: ['bottom', 'right'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withPlacement(value): { options+: { legend+: { placement: value } } }, + '#withShowLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowLegend(value=true): { options+: { legend+: { showLegend: value } } }, + '#withSortBy': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withSortBy(value): { options+: { legend+: { sortBy: value } } }, + '#withSortDesc': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withSortDesc(value=true): { options+: { legend+: { sortDesc: value } } }, + '#withWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withWidth(value): { options+: { legend+: { width: value } } }, + }, + '#withTooltip': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTooltip(value): { options+: { tooltip: value } }, + '#withTooltipMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTooltipMixin(value): { options+: { tooltip+: value } }, + tooltip+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['single', 'multi', 'none'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withMode(value): { options+: { tooltip+: { mode: value } } }, + '#withSort': { 'function': { args: [{ default: null, enums: ['asc', 'desc', 'none'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withSort(value): { options+: { tooltip+: { sort: value } } }, + }, + }, +} ++ { panelOptions+: { '#withType':: {} } } diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/trend.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/trend.libsonnet new file mode 100644 index 0000000000..51e3173e60 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/trend.libsonnet @@ -0,0 +1,182 @@ +// This file is generated, do not manually edit. +(import '../../clean/panel.libsonnet') ++ { + '#': { help: 'grafonnet.panel.trend', name: 'trend' }, + panelOptions+: + { + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'trend' }, + }, + fieldConfig+: + { + defaults+: + { + custom+: + { + '#withLineColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withLineColor(value): { fieldConfig+: { defaults+: { custom+: { lineColor: value } } } }, + '#withLineInterpolation': { 'function': { args: [{ default: null, enums: ['linear', 'smooth', 'stepBefore', 'stepAfter'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withLineInterpolation(value): { fieldConfig+: { defaults+: { custom+: { lineInterpolation: value } } } }, + '#withLineStyle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLineStyle(value): { fieldConfig+: { defaults+: { custom+: { lineStyle: value } } } }, + '#withLineStyleMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLineStyleMixin(value): { fieldConfig+: { defaults+: { custom+: { lineStyle+: value } } } }, + lineStyle+: + { + '#withDash': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withDash(value): { fieldConfig+: { defaults+: { custom+: { lineStyle+: { dash: (if std.isArray(value) + then value + else [value]) } } } } }, + '#withDashMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withDashMixin(value): { fieldConfig+: { defaults+: { custom+: { lineStyle+: { dash+: (if std.isArray(value) + then value + else [value]) } } } } }, + '#withFill': { 'function': { args: [{ default: null, enums: ['solid', 'dash', 'dot', 'square'], name: 'value', type: 'string' }], help: '' } }, + withFill(value): { fieldConfig+: { defaults+: { custom+: { lineStyle+: { fill: value } } } } }, + }, + '#withLineWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLineWidth(value): { fieldConfig+: { defaults+: { custom+: { lineWidth: value } } } }, + '#withSpanNulls': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Indicate if null values should be treated as gaps or connected.\nWhen the value is a number, it represents the maximum delta in the\nX axis that should be considered connected. For timeseries, this is milliseconds' } }, + withSpanNulls(value): { fieldConfig+: { defaults+: { custom+: { spanNulls: value } } } }, + '#withSpanNullsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Indicate if null values should be treated as gaps or connected.\nWhen the value is a number, it represents the maximum delta in the\nX axis that should be considered connected. For timeseries, this is milliseconds' } }, + withSpanNullsMixin(value): { fieldConfig+: { defaults+: { custom+: { spanNulls+: value } } } }, + '#withFillBelowTo': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withFillBelowTo(value): { fieldConfig+: { defaults+: { custom+: { fillBelowTo: value } } } }, + '#withFillColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withFillColor(value): { fieldConfig+: { defaults+: { custom+: { fillColor: value } } } }, + '#withFillOpacity': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withFillOpacity(value): { fieldConfig+: { defaults+: { custom+: { fillOpacity: value } } } }, + '#withPointColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withPointColor(value): { fieldConfig+: { defaults+: { custom+: { pointColor: value } } } }, + '#withPointSize': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withPointSize(value): { fieldConfig+: { defaults+: { custom+: { pointSize: value } } } }, + '#withPointSymbol': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withPointSymbol(value): { fieldConfig+: { defaults+: { custom+: { pointSymbol: value } } } }, + '#withShowPoints': { 'function': { args: [{ default: null, enums: ['auto', 'never', 'always'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withShowPoints(value): { fieldConfig+: { defaults+: { custom+: { showPoints: value } } } }, + '#withAxisCenteredZero': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAxisCenteredZero(value=true): { fieldConfig+: { defaults+: { custom+: { axisCenteredZero: value } } } }, + '#withAxisColorMode': { 'function': { args: [{ default: null, enums: ['text', 'series'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withAxisColorMode(value): { fieldConfig+: { defaults+: { custom+: { axisColorMode: value } } } }, + '#withAxisGridShow': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAxisGridShow(value=true): { fieldConfig+: { defaults+: { custom+: { axisGridShow: value } } } }, + '#withAxisLabel': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withAxisLabel(value): { fieldConfig+: { defaults+: { custom+: { axisLabel: value } } } }, + '#withAxisPlacement': { 'function': { args: [{ default: null, enums: ['auto', 'top', 'right', 'bottom', 'left', 'hidden'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withAxisPlacement(value): { fieldConfig+: { defaults+: { custom+: { axisPlacement: value } } } }, + '#withAxisSoftMax': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisSoftMax(value): { fieldConfig+: { defaults+: { custom+: { axisSoftMax: value } } } }, + '#withAxisSoftMin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisSoftMin(value): { fieldConfig+: { defaults+: { custom+: { axisSoftMin: value } } } }, + '#withAxisWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisWidth(value): { fieldConfig+: { defaults+: { custom+: { axisWidth: value } } } }, + '#withScaleDistribution': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistribution(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution: value } } } }, + '#withScaleDistributionMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistributionMixin(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: value } } } }, + scaleDistribution+: + { + '#withLinearThreshold': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLinearThreshold(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: { linearThreshold: value } } } } }, + '#withLog': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLog(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: { log: value } } } } }, + '#withType': { 'function': { args: [{ default: null, enums: ['linear', 'log', 'ordinal', 'symlog'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withType(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: { type: value } } } } }, + }, + '#withBarAlignment': { 'function': { args: [{ default: null, enums: [-1, 0, 1], name: 'value', type: 'integer' }], help: 'TODO docs' } }, + withBarAlignment(value): { fieldConfig+: { defaults+: { custom+: { barAlignment: value } } } }, + '#withBarMaxWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withBarMaxWidth(value): { fieldConfig+: { defaults+: { custom+: { barMaxWidth: value } } } }, + '#withBarWidthFactor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withBarWidthFactor(value): { fieldConfig+: { defaults+: { custom+: { barWidthFactor: value } } } }, + '#withStacking': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withStacking(value): { fieldConfig+: { defaults+: { custom+: { stacking: value } } } }, + '#withStackingMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withStackingMixin(value): { fieldConfig+: { defaults+: { custom+: { stacking+: value } } } }, + stacking+: + { + '#withGroup': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withGroup(value): { fieldConfig+: { defaults+: { custom+: { stacking+: { group: value } } } } }, + '#withMode': { 'function': { args: [{ default: null, enums: ['none', 'normal', 'percent'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withMode(value): { fieldConfig+: { defaults+: { custom+: { stacking+: { mode: value } } } } }, + }, + '#withHideFrom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFrom(value): { fieldConfig+: { defaults+: { custom+: { hideFrom: value } } } }, + '#withHideFromMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFromMixin(value): { fieldConfig+: { defaults+: { custom+: { hideFrom+: value } } } }, + hideFrom+: + { + '#withLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withLegend(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { legend: value } } } } }, + '#withTooltip': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withTooltip(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { tooltip: value } } } } }, + '#withViz': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withViz(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { viz: value } } } } }, + }, + '#withDrawStyle': { 'function': { args: [{ default: null, enums: ['line', 'bars', 'points'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withDrawStyle(value): { fieldConfig+: { defaults+: { custom+: { drawStyle: value } } } }, + '#withGradientMode': { 'function': { args: [{ default: null, enums: ['none', 'opacity', 'hue', 'scheme'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withGradientMode(value): { fieldConfig+: { defaults+: { custom+: { gradientMode: value } } } }, + '#withThresholdsStyle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withThresholdsStyle(value): { fieldConfig+: { defaults+: { custom+: { thresholdsStyle: value } } } }, + '#withThresholdsStyleMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withThresholdsStyleMixin(value): { fieldConfig+: { defaults+: { custom+: { thresholdsStyle+: value } } } }, + thresholdsStyle+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['off', 'line', 'dashed', 'area', 'line+area', 'dashed+area', 'series'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withMode(value): { fieldConfig+: { defaults+: { custom+: { thresholdsStyle+: { mode: value } } } } }, + }, + '#withTransform': { 'function': { args: [{ default: null, enums: ['constant', 'negative-Y'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withTransform(value): { fieldConfig+: { defaults+: { custom+: { transform: value } } } }, + }, + }, + }, + options+: + { + '#withLegend': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLegend(value): { options+: { legend: value } }, + '#withLegendMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLegendMixin(value): { options+: { legend+: value } }, + legend+: + { + '#withAsTable': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAsTable(value=true): { options+: { legend+: { asTable: value } } }, + '#withCalcs': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withCalcs(value): { options+: { legend+: { calcs: (if std.isArray(value) + then value + else [value]) } } }, + '#withCalcsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withCalcsMixin(value): { options+: { legend+: { calcs+: (if std.isArray(value) + then value + else [value]) } } }, + '#withDisplayMode': { 'function': { args: [{ default: null, enums: ['list', 'table', 'hidden'], name: 'value', type: 'string' }], help: 'TODO docs\nNote: "hidden" needs to remain as an option for plugins compatibility' } }, + withDisplayMode(value): { options+: { legend+: { displayMode: value } } }, + '#withIsVisible': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withIsVisible(value=true): { options+: { legend+: { isVisible: value } } }, + '#withPlacement': { 'function': { args: [{ default: null, enums: ['bottom', 'right'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withPlacement(value): { options+: { legend+: { placement: value } } }, + '#withShowLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowLegend(value=true): { options+: { legend+: { showLegend: value } } }, + '#withSortBy': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withSortBy(value): { options+: { legend+: { sortBy: value } } }, + '#withSortDesc': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withSortDesc(value=true): { options+: { legend+: { sortDesc: value } } }, + '#withWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withWidth(value): { options+: { legend+: { width: value } } }, + }, + '#withTooltip': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTooltip(value): { options+: { tooltip: value } }, + '#withTooltipMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTooltipMixin(value): { options+: { tooltip+: value } }, + tooltip+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['single', 'multi', 'none'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withMode(value): { options+: { tooltip+: { mode: value } } }, + '#withSort': { 'function': { args: [{ default: null, enums: ['asc', 'desc', 'none'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withSort(value): { options+: { tooltip+: { sort: value } } }, + }, + '#withXField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Name of the x field to use (defaults to first number)' } }, + withXField(value): { options+: { xField: value } }, + }, +} ++ { panelOptions+: { '#withType':: {} } } diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/xyChart.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/xyChart.libsonnet new file mode 100644 index 0000000000..57b9aa8be8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/panel/xyChart.libsonnet @@ -0,0 +1,212 @@ +// This file is generated, do not manually edit. +(import '../../clean/panel.libsonnet') ++ { + '#': { help: 'grafonnet.panel.xyChart', name: 'xyChart' }, + panelOptions+: + { + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'xychart' }, + }, + options+: + { + '#withLegend': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLegend(value): { options+: { legend: value } }, + '#withLegendMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLegendMixin(value): { options+: { legend+: value } }, + legend+: + { + '#withAsTable': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAsTable(value=true): { options+: { legend+: { asTable: value } } }, + '#withCalcs': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withCalcs(value): { options+: { legend+: { calcs: (if std.isArray(value) + then value + else [value]) } } }, + '#withCalcsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withCalcsMixin(value): { options+: { legend+: { calcs+: (if std.isArray(value) + then value + else [value]) } } }, + '#withDisplayMode': { 'function': { args: [{ default: null, enums: ['list', 'table', 'hidden'], name: 'value', type: 'string' }], help: 'TODO docs\nNote: "hidden" needs to remain as an option for plugins compatibility' } }, + withDisplayMode(value): { options+: { legend+: { displayMode: value } } }, + '#withIsVisible': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withIsVisible(value=true): { options+: { legend+: { isVisible: value } } }, + '#withPlacement': { 'function': { args: [{ default: null, enums: ['bottom', 'right'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withPlacement(value): { options+: { legend+: { placement: value } } }, + '#withShowLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowLegend(value=true): { options+: { legend+: { showLegend: value } } }, + '#withSortBy': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withSortBy(value): { options+: { legend+: { sortBy: value } } }, + '#withSortDesc': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withSortDesc(value=true): { options+: { legend+: { sortDesc: value } } }, + '#withWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withWidth(value): { options+: { legend+: { width: value } } }, + }, + '#withTooltip': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTooltip(value): { options+: { tooltip: value } }, + '#withTooltipMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTooltipMixin(value): { options+: { tooltip+: value } }, + tooltip+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['single', 'multi', 'none'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withMode(value): { options+: { tooltip+: { mode: value } } }, + '#withSort': { 'function': { args: [{ default: null, enums: ['asc', 'desc', 'none'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withSort(value): { options+: { tooltip+: { sort: value } } }, + }, + '#withDims': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withDims(value): { options+: { dims: value } }, + '#withDimsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withDimsMixin(value): { options+: { dims+: value } }, + dims+: + { + '#withExclude': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withExclude(value): { options+: { dims+: { exclude: (if std.isArray(value) + then value + else [value]) } } }, + '#withExcludeMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withExcludeMixin(value): { options+: { dims+: { exclude+: (if std.isArray(value) + then value + else [value]) } } }, + '#withFrame': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withFrame(value): { options+: { dims+: { frame: value } } }, + '#withX': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withX(value): { options+: { dims+: { x: value } } }, + }, + '#withSeries': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withSeries(value): { options+: { series: (if std.isArray(value) + then value + else [value]) } }, + '#withSeriesMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withSeriesMixin(value): { options+: { series+: (if std.isArray(value) + then value + else [value]) } }, + series+: + { + '#': { help: '', name: 'series' }, + '#withHideFrom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFrom(value): { hideFrom: value }, + '#withHideFromMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFromMixin(value): { hideFrom+: value }, + hideFrom+: + { + '#withLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withLegend(value=true): { hideFrom+: { legend: value } }, + '#withTooltip': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withTooltip(value=true): { hideFrom+: { tooltip: value } }, + '#withViz': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withViz(value=true): { hideFrom+: { viz: value } }, + }, + '#withAxisCenteredZero': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAxisCenteredZero(value=true): { axisCenteredZero: value }, + '#withAxisColorMode': { 'function': { args: [{ default: null, enums: ['text', 'series'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withAxisColorMode(value): { axisColorMode: value }, + '#withAxisGridShow': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAxisGridShow(value=true): { axisGridShow: value }, + '#withAxisLabel': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withAxisLabel(value): { axisLabel: value }, + '#withAxisPlacement': { 'function': { args: [{ default: null, enums: ['auto', 'top', 'right', 'bottom', 'left', 'hidden'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withAxisPlacement(value): { axisPlacement: value }, + '#withAxisSoftMax': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisSoftMax(value): { axisSoftMax: value }, + '#withAxisSoftMin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisSoftMin(value): { axisSoftMin: value }, + '#withAxisWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisWidth(value): { axisWidth: value }, + '#withScaleDistribution': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistribution(value): { scaleDistribution: value }, + '#withScaleDistributionMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistributionMixin(value): { scaleDistribution+: value }, + scaleDistribution+: + { + '#withLinearThreshold': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLinearThreshold(value): { scaleDistribution+: { linearThreshold: value } }, + '#withLog': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLog(value): { scaleDistribution+: { log: value } }, + '#withType': { 'function': { args: [{ default: null, enums: ['linear', 'log', 'ordinal', 'symlog'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withType(value): { scaleDistribution+: { type: value } }, + }, + '#withLabel': { 'function': { args: [{ default: null, enums: ['auto', 'never', 'always'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withLabel(value): { label: value }, + '#withLabelValue': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withLabelValue(value): { labelValue: value }, + '#withLabelValueMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withLabelValueMixin(value): { labelValue+: value }, + labelValue+: + { + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'fixed: T -- will be added by each element' } }, + withField(value): { labelValue+: { field: value } }, + '#withFixed': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withFixed(value): { labelValue+: { fixed: value } }, + '#withMode': { 'function': { args: [{ default: null, enums: ['fixed', 'field', 'template'], name: 'value', type: 'string' }], help: '' } }, + withMode(value): { labelValue+: { mode: value } }, + }, + '#withLineColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withLineColor(value): { lineColor: value }, + '#withLineColorMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withLineColorMixin(value): { lineColor+: value }, + lineColor+: + { + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'fixed: T -- will be added by each element' } }, + withField(value): { lineColor+: { field: value } }, + '#withFixed': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withFixed(value): { lineColor+: { fixed: value } }, + }, + '#withLineStyle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLineStyle(value): { lineStyle: value }, + '#withLineStyleMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLineStyleMixin(value): { lineStyle+: value }, + lineStyle+: + { + '#withDash': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withDash(value): { lineStyle+: { dash: (if std.isArray(value) + then value + else [value]) } }, + '#withDashMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withDashMixin(value): { lineStyle+: { dash+: (if std.isArray(value) + then value + else [value]) } }, + '#withFill': { 'function': { args: [{ default: null, enums: ['solid', 'dash', 'dot', 'square'], name: 'value', type: 'string' }], help: '' } }, + withFill(value): { lineStyle+: { fill: value } }, + }, + '#withLineWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withLineWidth(value): { lineWidth: value }, + '#withPointColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withPointColor(value): { pointColor: value }, + '#withPointColorMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withPointColorMixin(value): { pointColor+: value }, + pointColor+: + { + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'fixed: T -- will be added by each element' } }, + withField(value): { pointColor+: { field: value } }, + '#withFixed': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withFixed(value): { pointColor+: { fixed: value } }, + }, + '#withPointSize': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withPointSize(value): { pointSize: value }, + '#withPointSizeMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withPointSizeMixin(value): { pointSize+: value }, + pointSize+: + { + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'fixed: T -- will be added by each element' } }, + withField(value): { pointSize+: { field: value } }, + '#withFixed': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withFixed(value): { pointSize+: { fixed: value } }, + '#withMax': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withMax(value): { pointSize+: { max: value } }, + '#withMin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withMin(value): { pointSize+: { min: value } }, + '#withMode': { 'function': { args: [{ default: null, enums: ['linear', 'quad'], name: 'value', type: 'string' }], help: '' } }, + withMode(value): { pointSize+: { mode: value } }, + }, + '#withShow': { 'function': { args: [{ default: null, enums: ['points', 'lines', 'points+lines'], name: 'value', type: 'string' }], help: '' } }, + withShow(value): { show: value }, + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withName(value): { name: value }, + '#withX': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withX(value): { x: value }, + '#withY': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withY(value): { y: value }, + }, + '#withSeriesMapping': { 'function': { args: [{ default: null, enums: ['auto', 'manual'], name: 'value', type: 'string' }], help: '' } }, + withSeriesMapping(value): { options+: { seriesMapping: value } }, + }, +} ++ { panelOptions+: { '#withType':: {} } } diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/query/loki.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/query/loki.libsonnet new file mode 100644 index 0000000000..f7cf1bb777 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/query/loki.libsonnet @@ -0,0 +1,27 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.query.loki', name: 'loki' }, + '#withDatasource': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: "For mixed data sources the selected datasource is on the query level.\nFor non mixed scenarios this is undefined.\nTODO find a better way to do this ^ that's friendly to schema\nTODO this shouldn't be unknown but DataSourceRef | null" } }, + withDatasource(value): { datasource: value }, + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'true if query is disabled (ie should not be returned to the dashboard)\nNote this does not always imply that the query should not be executed since\nthe results from a hidden query may be used as the input to other queries (SSE etc)' } }, + withHide(value=true): { hide: value }, + '#withQueryType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Specify the query flavor\nTODO make this required and give it a default' } }, + withQueryType(value): { queryType: value }, + '#withRefId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'A unique identifier for the query within the list of targets.\nIn server side expressions, the refId is used as a variable name to identify results.\nBy default, the UI will assign A->Z; however setting meaningful names may be useful.' } }, + withRefId(value): { refId: value }, + '#withEditorMode': { 'function': { args: [{ default: null, enums: ['code', 'builder'], name: 'value', type: 'string' }], help: '' } }, + withEditorMode(value): { editorMode: value }, + '#withExpr': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The LogQL query.' } }, + withExpr(value): { expr: value }, + '#withInstant': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '@deprecated, now use queryType.' } }, + withInstant(value=true): { instant: value }, + '#withLegendFormat': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Used to override the name of the series.' } }, + withLegendFormat(value): { legendFormat: value }, + '#withMaxLines': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'Used to limit the number of log rows returned.' } }, + withMaxLines(value): { maxLines: value }, + '#withRange': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '@deprecated, now use queryType.' } }, + withRange(value=true): { range: value }, + '#withResolution': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'Used to scale the interval value.' } }, + withResolution(value): { resolution: value }, +} ++ (import '../../custom/query/loki.libsonnet') diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/query/prometheus.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/query/prometheus.libsonnet new file mode 100644 index 0000000000..19196ce822 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/query/prometheus.libsonnet @@ -0,0 +1,29 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.query.prometheus', name: 'prometheus' }, + '#withDatasource': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: "For mixed data sources the selected datasource is on the query level.\nFor non mixed scenarios this is undefined.\nTODO find a better way to do this ^ that's friendly to schema\nTODO this shouldn't be unknown but DataSourceRef | null" } }, + withDatasource(value): { datasource: value }, + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'true if query is disabled (ie should not be returned to the dashboard)\nNote this does not always imply that the query should not be executed since\nthe results from a hidden query may be used as the input to other queries (SSE etc)' } }, + withHide(value=true): { hide: value }, + '#withQueryType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Specify the query flavor\nTODO make this required and give it a default' } }, + withQueryType(value): { queryType: value }, + '#withRefId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'A unique identifier for the query within the list of targets.\nIn server side expressions, the refId is used as a variable name to identify results.\nBy default, the UI will assign A->Z; however setting meaningful names may be useful.' } }, + withRefId(value): { refId: value }, + '#withEditorMode': { 'function': { args: [{ default: null, enums: ['code', 'builder'], name: 'value', type: 'string' }], help: '' } }, + withEditorMode(value): { editorMode: value }, + '#withExemplar': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Execute an additional query to identify interesting raw samples relevant for the given expr' } }, + withExemplar(value=true): { exemplar: value }, + '#withExpr': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The actual expression/query that will be evaluated by Prometheus' } }, + withExpr(value): { expr: value }, + '#withFormat': { 'function': { args: [{ default: null, enums: ['time_series', 'table', 'heatmap'], name: 'value', type: 'string' }], help: '' } }, + withFormat(value): { format: value }, + '#withInstant': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Returns only the latest value that Prometheus has scraped for the requested time series' } }, + withInstant(value=true): { instant: value }, + '#withIntervalFactor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '@deprecated Used to specify how many times to divide max data points by. We use max data points under query options\nSee https://github.com/grafana/grafana/issues/48081' } }, + withIntervalFactor(value): { intervalFactor: value }, + '#withLegendFormat': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Series name override or template. Ex. {{hostname}} will be replaced with label value for hostname' } }, + withLegendFormat(value): { legendFormat: value }, + '#withRange': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Returns a Range vector, comprised of a set of time series containing a range of data points over time for each time series' } }, + withRange(value=true): { range: value }, +} ++ (import '../../custom/query/prometheus.libsonnet') diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/query/tempo.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/query/tempo.libsonnet new file mode 100644 index 0000000000..52fcfd1ec7 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/clean/query/tempo.libsonnet @@ -0,0 +1,55 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.query.tempo', name: 'tempo' }, + '#withDatasource': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: "For mixed data sources the selected datasource is on the query level.\nFor non mixed scenarios this is undefined.\nTODO find a better way to do this ^ that's friendly to schema\nTODO this shouldn't be unknown but DataSourceRef | null" } }, + withDatasource(value): { datasource: value }, + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'true if query is disabled (ie should not be returned to the dashboard)\nNote this does not always imply that the query should not be executed since\nthe results from a hidden query may be used as the input to other queries (SSE etc)' } }, + withHide(value=true): { hide: value }, + '#withQueryType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Specify the query flavor\nTODO make this required and give it a default' } }, + withQueryType(value): { queryType: value }, + '#withRefId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'A unique identifier for the query within the list of targets.\nIn server side expressions, the refId is used as a variable name to identify results.\nBy default, the UI will assign A->Z; however setting meaningful names may be useful.' } }, + withRefId(value): { refId: value }, + '#withFilters': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withFilters(value): { filters: (if std.isArray(value) + then value + else [value]) }, + '#withFiltersMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withFiltersMixin(value): { filters+: (if std.isArray(value) + then value + else [value]) }, + filters+: + { + '#': { help: '', name: 'filters' }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Uniquely identify the filter, will not be used in the query generation' } }, + withId(value): { id: value }, + '#withOperator': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The operator that connects the tag to the value, for example: =, >, !=, =~' } }, + withOperator(value): { operator: value }, + '#withScope': { 'function': { args: [{ default: null, enums: ['unscoped', 'resource', 'span'], name: 'value', type: 'string' }], help: 'static fields are pre-set in the UI, dynamic fields are added by the user' } }, + withScope(value): { scope: value }, + '#withTag': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The tag for the search filter, for example: .http.status_code, .service.name, status' } }, + withTag(value): { tag: value }, + '#withValue': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The value for the search filter' } }, + withValue(value): { value: value }, + '#withValueMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The value for the search filter' } }, + withValueMixin(value): { value+: value }, + '#withValueType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The type of the value, used for example to check whether we need to wrap the value in quotes when generating the query' } }, + withValueType(value): { valueType: value }, + }, + '#withLimit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'Defines the maximum number of traces that are returned from Tempo' } }, + withLimit(value): { limit: value }, + '#withMaxDuration': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Define the maximum duration to select traces. Use duration format, for example: 1.2s, 100ms' } }, + withMaxDuration(value): { maxDuration: value }, + '#withMinDuration': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Define the minimum duration to select traces. Use duration format, for example: 1.2s, 100ms' } }, + withMinDuration(value): { minDuration: value }, + '#withQuery': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'TraceQL query or trace ID' } }, + withQuery(value): { query: value }, + '#withSearch': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Logfmt query to filter traces by their tags. Example: http.status_code=200 error=true' } }, + withSearch(value): { search: value }, + '#withServiceMapQuery': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Filters to be included in a PromQL query to select data for the service graph. Example: {client="app",service="app"}' } }, + withServiceMapQuery(value): { serviceMapQuery: value }, + '#withServiceName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Query traces by service name' } }, + withServiceName(value): { serviceName: value }, + '#withSpanName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Query traces by span name' } }, + withSpanName(value): { spanName: value }, +} ++ (import '../../custom/query/tempo.libsonnet') diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/alerting/contactPoint.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/alerting/contactPoint.libsonnet new file mode 100644 index 0000000000..4b8bbf0b57 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/alerting/contactPoint.libsonnet @@ -0,0 +1,12 @@ +local d = import 'github.com/jsonnet-libs/docsonnet/doc-util/main.libsonnet'; + +{ + '#'+:: { + help+: + ||| + + + **NOTE**: The schemas for all different contact points is under development, this means we can't properly express them in Grafonnet yet. The way this works now may change heavily. + |||, + }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/alerting/muteTiming.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/alerting/muteTiming.libsonnet new file mode 100644 index 0000000000..4a2efb3604 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/alerting/muteTiming.libsonnet @@ -0,0 +1,8 @@ +{ + '#withTimeIntervals': { ignore: true }, + '#withIntervals': super['#withTimeIntervals'], + withIntervals: super.withTimeIntervals, + '#withTimeIntervalsMixin': { ignore: true }, + '#withIntervalsMixin': super['#withTimeIntervalsMixin'], + withIntervalsMixin: super.withTimeIntervalsMixin, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/alerting/notificationPolicy.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/alerting/notificationPolicy.libsonnet new file mode 100644 index 0000000000..cf9a2b7dcf --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/alerting/notificationPolicy.libsonnet @@ -0,0 +1,12 @@ +{ + '#withReceiver': { ignore: true }, + '#withContactPoint': super['#withReceiver'], + withContactPoint: super.withReceiver, + + '#withRoutes': { ignore: true }, + '#withPolicy': super['#withRoutes'], + withPolicy: super.withRoutes, + '#withRoutesMixin': { ignore: true }, + '#withPolicyMixin': super['#withRoutesMixin'], + withPolicyMixin: super.withRoutesMixin, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/alerting/ruleGroup.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/alerting/ruleGroup.libsonnet new file mode 100644 index 0000000000..4ed32afb06 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/alerting/ruleGroup.libsonnet @@ -0,0 +1,13 @@ +local d = import 'github.com/jsonnet-libs/docsonnet/doc-util/main.libsonnet'; + +{ + '#withTitle': { ignore: true }, + '#withName': super['#withTitle'], + withName: super.withTitle, + rule+: { + '#':: d.package.newSub('rule', ''), + '#withTitle': { ignore: true }, + '#withName': super['#withTitle'], + withName: super.withTitle, + }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/dashboard.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/dashboard.libsonnet new file mode 100644 index 0000000000..0620a22520 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/dashboard.libsonnet @@ -0,0 +1,44 @@ +local util = import './util/main.libsonnet'; +local d = import 'github.com/jsonnet-libs/docsonnet/doc-util/main.libsonnet'; + +{ + '#new':: d.func.new( + 'Creates a new dashboard with a title.', + args=[d.arg('title', d.T.string)] + ), + new(title): + self.withTitle(title) + + self.withSchemaVersion() + + self.withTimezone('utc') + + self.time.withFrom('now-6h') + + self.time.withTo('now'), + + withPanels(value): { + _panels:: if std.isArray(value) then value else [value], + panels: util.panel.setPanelIDs(self._panels), + }, + withPanelsMixin(value): { + _panels+:: if std.isArray(value) then value else [value], + panels: util.panel.setPanelIDs(self._panels), + }, + + graphTooltip+: { + // 0 - Default + // 1 - Shared crosshair + // 2 - Shared tooltip + '#withSharedCrosshair':: d.func.new( + 'Share crosshair on all panels.', + ), + withSharedCrosshair(): + { graphTooltip: 1 }, + + '#withSharedTooltip':: d.func.new( + 'Share crosshair and tooltip on all panels.', + ), + withSharedTooltip(): + { graphTooltip: 2 }, + }, +} ++ (import './dashboard/annotation.libsonnet') ++ (import './dashboard/link.libsonnet') ++ (import './dashboard/variable.libsonnet') diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/dashboard/annotation.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/dashboard/annotation.libsonnet new file mode 100644 index 0000000000..02892ab33e --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/dashboard/annotation.libsonnet @@ -0,0 +1,36 @@ +local d = import 'github.com/jsonnet-libs/docsonnet/doc-util/main.libsonnet'; + +{ + '#annotation':: {}, + + '#withAnnotations': + d.func.new( + ||| + `withAnnotations` adds an array of annotations to a dashboard. + + This function appends passed data to existing values + |||, + args=[d.arg('value', d.T.array)] + ), + withAnnotations(value): super.annotation.withList(value), + + '#withAnnotationsMixin': + d.func.new( + ||| + `withAnnotationsMixin` adds an array of annotations to a dashboard. + + This function appends passed data to existing values + |||, + args=[d.arg('value', d.T.array)] + ), + withAnnotationsMixin(value): super.annotation.withListMixin(value), + + annotation: + super.annotation.list + + { + '#':: d.package.newSub( + 'annotation', + '', + ), + }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/dashboard/link.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/dashboard/link.libsonnet new file mode 100644 index 0000000000..eb9b2fe9aa --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/dashboard/link.libsonnet @@ -0,0 +1,90 @@ +local d = import 'github.com/jsonnet-libs/docsonnet/doc-util/main.libsonnet'; + +{ + '#withLinks':: d.func.new( + ||| + Dashboard links are displayed at the top of the dashboard, these can either link to other dashboards or to external URLs. + + `withLinks` takes an array of [link objects](./link.md). + + The [docs](https://grafana.com/docs/grafana/latest/dashboards/build-dashboards/manage-dashboard-links/#dashboard-links) give a more comprehensive description. + + Example: + + ```jsonnet + local g = import 'g.libsonnet'; + local link = g.dashboard.link; + + g.dashboard.new('Title dashboard') + + g.dashboard.withLinks([ + link.link.new('My title', 'https://wikipedia.org/'), + ]) + ``` + |||, + [d.arg('value', d.T.array)], + ), + '#withLinksMixin':: self['#withLinks'], + + link+: { + '#':: d.package.newSub( + 'link', + ||| + Dashboard links are displayed at the top of the dashboard, these can either link to other dashboards or to external URLs. + + The [docs](https://grafana.com/docs/grafana/latest/dashboards/build-dashboards/manage-dashboard-links/#dashboard-links) give a more comprehensive description. + + Example: + + ```jsonnet + local g = import 'g.libsonnet'; + local link = g.dashboard.link; + + g.dashboard.new('Title dashboard') + + g.dashboard.withLinks([ + link.link.new('My title', 'https://wikipedia.org/'), + ]) + ``` + |||, + ), + + dashboards+: { + '#new':: d.func.new( + ||| + Create links to dashboards based on `tags`. + |||, + args=[ + d.arg('title', d.T.string), + d.arg('tags', d.T.array), + ] + ), + new(title, tags): + self.withTitle(title) + + self.withType('dashboards') + + self.withTags(tags), + + '#withTitle':: {}, + '#withType':: {}, + '#withTags':: {}, + }, + + link+: { + '#new':: d.func.new( + ||| + Create link to an arbitrary URL. + |||, + args=[ + d.arg('title', d.T.string), + d.arg('url', d.T.string), + ] + ), + new(title, url): + self.withTitle(title) + + self.withType('link') + + self.withUrl(url), + + '#withTitle':: {}, + '#withType':: {}, + '#withUrl':: {}, + }, + }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/dashboard/variable.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/dashboard/variable.libsonnet new file mode 100644 index 0000000000..3cd298811a --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/dashboard/variable.libsonnet @@ -0,0 +1,516 @@ +local util = import '../util/main.libsonnet'; +local d = import 'github.com/jsonnet-libs/docsonnet/doc-util/main.libsonnet'; + +{ + local var = super.variable.list, + + '#withVariables': + d.func.new( + ||| + `withVariables` adds an array of variables to a dashboard + |||, + args=[d.arg('value', d.T.array)] + ), + withVariables(value): super.variable.withList(value), + + '#withVariablesMixin': + d.func.new( + ||| + `withVariablesMixin` adds an array of variables to a dashboard. + + This function appends passed data to existing values + |||, + args=[d.arg('value', d.T.array)] + ), + withVariablesMixin(value): super.variable.withListMixin(value), + + variable: { + '#':: d.package.newSub( + 'variable', + ||| + Example usage: + + ```jsonnet + local g = import 'g.libsonnet'; + local var = g.dashboard.variable; + + local customVar = + var.custom.new( + 'myOptions', + values=['a', 'b', 'c', 'd'], + ) + + var.custom.generalOptions.withDescription( + 'This is a variable for my custom options.' + ) + + var.custom.selectionOptions.withMulti(); + + local queryVar = + var.query.new('queryOptions') + + var.query.queryTypes.withLabelValues( + 'up', + 'instance', + ) + + var.query.withDatasource( + type='prometheus', + uid='mimir-prod', + ) + + var.query.selectionOptions.withIncludeAll(); + + + g.dashboard.new('my dashboard') + + g.dashboard.withVariables([ + customVar, + queryVar, + ]) + ``` + |||, + ), + + local generalOptions = { + generalOptions+: + { + + '#withName': var['#withName'], + withName: var.withName, + '#withLabel': var['#withLabel'], + withLabel: var.withLabel, + '#withDescription': var['#withDescription'], + withDescription: var.withDescription, + + showOnDashboard: { + '#withLabelAndValue':: d.func.new(''), + withLabelAndValue(): var.withHide(0), + '#withValueOnly':: d.func.new(''), + withValueOnly(): var.withHide(1), + '#withNothing':: d.func.new(''), + withNothing(): var.withHide(2), + }, + + '#withCurrent':: d.func.new( + ||| + `withCurrent` sets the currently selected value of a variable. If key and value are different, both need to be given. + |||, + args=[ + d.arg('key', d.T.any), + d.arg('value', d.T.any, default=''), + ] + ), + withCurrent(key, value=key): { + local multi(v) = + if self.multi + && std.isArray(v) + then v + else [v], + current: { + selected: false, + text: multi(key), + value: multi(value), + }, + }, + }, + }, + + local selectionOptions = + { + selectionOptions: + { + '#withMulti':: d.func.new( + 'Enable selecting multiple values.', + args=[ + d.arg('value', d.T.boolean, default=true), + ] + ), + withMulti(value=true): { + multi: value, + }, + + '#withIncludeAll':: d.func.new( + ||| + `withIncludeAll` enables an option to include all variables. + + Optionally you can set a `customAllValue`. + |||, + args=[ + d.arg('value', d.T.boolean, default=true), + d.arg('customAllValue', d.T.boolean, default=null), + ] + ), + withIncludeAll(value=true, customAllValue=null): { + includeAll: value, + [if customAllValue != null then 'allValue']: customAllValue, + }, + }, + }, + + query: + generalOptions + + selectionOptions + + { + '#new':: d.func.new( + ||| + Create a query template variable. + + `query` argument is optional, this can also be set with `query.queryTypes`. + |||, + args=[ + d.arg('name', d.T.string), + d.arg('query', d.T.string, default=''), + ] + ), + new(name, query=''): + var.withName(name) + + var.withType('query') + + var.withQuery(query), + + '#withDatasource':: d.func.new( + 'Select a datasource for the variable template query.', + args=[ + d.arg('type', d.T.string), + d.arg('uid', d.T.string), + ] + ), + withDatasource(type, uid): + var.datasource.withType(type) + + var.datasource.withUid(uid), + + '#withDatasourceFromVariable':: d.func.new( + 'Select the datasource from another template variable.', + args=[ + d.arg('variable', d.T.object), + ] + ), + withDatasourceFromVariable(variable): + if variable.type == 'datasource' + then self.withDatasource(variable.query, '${%s}' % variable.name) + else error "`variable` not of type 'datasource'", + + '#withRegex':: d.func.new( + ||| + `withRegex` can extract part of a series name or metric node segment. Named + capture groups can be used to separate the display text and value + ([see examples](https://grafana.com/docs/grafana/latest/variables/filter-variables-with-regex#filter-and-modify-using-named-text-and-value-capture-groups)). + |||, + args=[ + d.arg('value', d.T.string), + ] + ), + withRegex(value): { + regex: value, + }, + + '#withSort':: d.func.new( + ||| + Choose how to sort the values in the dropdown. + + This can be called as `withSort() to use the integer values for each + option. If `i==0` then it will be ignored and the other arguments will take + precedence. + + The numerical values are: + + - 1 - Alphabetical (asc) + - 2 - Alphabetical (desc) + - 3 - Numerical (asc) + - 4 - Numerical (desc) + - 5 - Alphabetical (case-insensitive, asc) + - 6 - Alphabetical (case-insensitive, desc) + |||, + args=[ + d.arg('i', d.T.number, default=0), + d.arg('type', d.T.string, default='alphabetical'), + d.arg('asc', d.T.boolean, default=true), + d.arg('caseInsensitive', d.T.boolean, default=false), + ], + ), + withSort(i=0, type='alphabetical', asc=true, caseInsensitive=false): + if i != 0 // provide fallback to numerical value + then { sort: i } + else + { + local mapping = { + alphabetical: + if !caseInsensitive + then + if asc + then 1 + else 2 + else + if asc + then 5 + else 6, + numerical: + if asc + then 3 + else 4, + }, + sort: mapping[type], + }, + + // TODO: Expand with Query types to match GUI + queryTypes: { + '#withLabelValues':: d.func.new( + 'Construct a Prometheus template variable using `label_values()`.', + args=[ + d.arg('label', d.T.string), + d.arg('metric', d.T.string, default=''), + ] + ), + withLabelValues(label, metric=''): + if metric == '' + then var.withQuery('label_values(%s)' % label) + else var.withQuery('label_values(%s, %s)' % [metric, label]), + }, + + // Deliberately undocumented, use `refresh` below + withRefresh(value): { + // 1 - On dashboard load + // 2 - On time range chagne + refresh: value, + }, + + local withRefresh = self.withRefresh, + refresh+: { + '#onLoad':: d.func.new( + 'Refresh label values on dashboard load.' + ), + onLoad(): withRefresh(1), + + '#onTime':: d.func.new( + 'Refresh label values on time range change.' + ), + onTime(): withRefresh(2), + }, + }, + + custom: + generalOptions + + selectionOptions + + { + '#new':: d.func.new( + ||| + `new` creates a custom template variable. + + The `values` array accepts an object with key/value keys, if it's not an object + then it will be added as a string. + + Example: + ``` + [ + { key: 'mykey', value: 'myvalue' }, + 'myvalue', + 12, + ] + |||, + args=[ + d.arg('name', d.T.string), + d.arg('values', d.T.array), + ] + ), + new(name, values): + var.withName(name) + + var.withType('custom') + + { + // Make values array available in jsonnet + values:: [ + if !std.isObject(item) + then { + key: std.toString(item), + value: std.toString(item), + } + else item + for item in values + ], + + // Render query from values array + query: + std.join(',', [ + std.join(' : ', [item.key, item.value]) + for item in self.values + ]), + + // Set current/options + current: + util.dashboard.getCurrentFromValues( + self.values, + std.get(self, 'multi', false) + ), + options: util.dashboard.getOptionsFromValues(self.values), + }, + + withQuery(query): { + values:: util.dashboard.parseCustomQuery(query), + query: query, + }, + }, + + textbox: + generalOptions + + { + '#new':: d.func.new( + '`new` creates a textbox template variable.', + args=[ + d.arg('name', d.T.string), + d.arg('default', d.T.string, default=''), + ] + ), + new(name, default=''): + var.withName(name) + + var.withType('textbox') + + { + local this = self, + default:: default, + query: self.default, + + // Set current/options + keyvaluedict:: [{ key: this.query, value: this.query }], + current: + util.dashboard.getCurrentFromValues( + self.keyvaluedict, + std.get(self, 'multi', false) + ), + options: util.dashboard.getOptionsFromValues(self.keyvaluedict), + }, + }, + + constant: + generalOptions + + { + '#new':: d.func.new( + '`new` creates a hidden constant template variable.', + args=[ + d.arg('name', d.T.string), + d.arg('value', d.T.string), + ] + ), + new(name, value=''): + var.withName(name) + + var.withType('constant') + + var.withHide(2) + + var.withQuery(value), + }, + + datasource: + generalOptions + + selectionOptions + + { + '#new':: d.func.new( + '`new` creates a datasource template variable.', + args=[ + d.arg('name', d.T.string), + d.arg('type', d.T.string), + ] + ), + new(name, type): + var.withName(name) + + var.withType('datasource') + + var.withQuery(type), + + '#withRegex':: d.func.new( + ||| + `withRegex` filter for which data source instances to choose from in the + variable value list. Example: `/^prod/` + |||, + args=[ + d.arg('value', d.T.string), + ] + ), + withRegex(value): { + regex: value, + }, + }, + + interval: + generalOptions + + { + '#new':: d.func.new( + '`new` creates an interval template variable.', + args=[ + d.arg('name', d.T.string), + d.arg('values', d.T.array), + ] + ), + new(name, values): + var.withName(name) + + var.withType('interval') + + { + // Make values array available in jsonnet + values:: values, + // Render query from values array + query: std.join(',', self.values), + + // Set current/options + keyvaluedict:: [ + { + key: item, + value: item, + } + for item in values + ], + current: + util.dashboard.getCurrentFromValues( + self.keyvaluedict, + std.get(self, 'multi', false) + ), + options: util.dashboard.getOptionsFromValues(self.keyvaluedict), + }, + + + '#withAutoOption':: d.func.new( + ||| + `withAutoOption` adds an options to dynamically calculate interval by dividing + time range by the count specified. + + `minInterval' has to be either unit-less or end with one of the following units: + "y, M, w, d, h, m, s, ms". + |||, + args=[ + d.arg('count', d.T.number), + d.arg('minInterval', d.T.string), + ] + ), + withAutoOption(count=30, minInterval='10s'): { + local this = self, + + auto: true, + auto_count: count, + auto_min: minInterval, + + // Add auto item to current/options + keyvaluedict:: + [{ key: 'auto', value: '$__auto_interval_' + this.name }] + + super.keyvaluedict, + }, + }, + + adhoc: + generalOptions + + { + '#new':: d.func.new( + '`new` creates an adhoc template variable for datasource with `type` and `uid`.', + args=[ + d.arg('name', d.T.string), + d.arg('type', d.T.string), + d.arg('uid', d.T.string), + ] + ), + new(name, type, uid): + var.withName(name) + + var.withType('adhoc') + + var.datasource.withType(type) + + var.datasource.withUid(uid), + + '#newFromDatasourceVariable':: d.func.new( + 'Same as `new` but selecting the datasource from another template variable.', + args=[ + d.arg('name', d.T.string), + d.arg('variable', d.T.object), + ] + ), + newFromDatasourceVariable(name, variable): + if variable.type == 'datasource' + then self.new(name, variable.query, '${%s}' % variable.name) + else error "`variable` not of type 'datasource'", + + }, + }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/panel.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/panel.libsonnet new file mode 100644 index 0000000000..98d2c2354d --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/panel.libsonnet @@ -0,0 +1,171 @@ +local d = import 'github.com/jsonnet-libs/docsonnet/doc-util/main.libsonnet'; + +// match name/title to reduce diff in docs +local panelNames = { + alertgroups: 'alertGroups', + annolist: 'annotationsList', + barchart: 'barChart', + bargauge: 'barGauge', + dashlist: 'dashboardList', + nodeGraph: 'nodeGraph', + piechart: 'pieChart', + 'state-timeline': 'stateTimeline', + 'status-history': 'statusHistory', + timeseries: 'timeSeries', + xychart: 'xyChart', +}; + +local getPanelName(type) = + std.get(panelNames, type, type); + +{ + '#new':: d.func.new( + 'Creates a new %s panel with a title.' % getPanelName(self.panelOptions.withType().type), + args=[d.arg('title', d.T.string)] + ), + new(title): + self.panelOptions.withTitle(title) + + self.panelOptions.withType() + + self.panelOptions.withPluginVersion() + // Default to Mixed datasource so panels can be datasource agnostic, this + // requires query targets to explicitly set datasource, which is a lot more + // interesting from a reusability standpoint. + + self.queryOptions.withDatasource('datasource', '-- Mixed --'), + + // Backwards compatible entries, ignored in docs + link+: self.panelOptions.link + { '#':: { ignore: true } }, + thresholdStep+: self.standardOptions.threshold.step + { '#':: { ignore: true } }, + transformation+: self.queryOptions.transformation + { '#':: { ignore: true } }, + valueMapping+: self.standardOptions.mapping + { '#':: { ignore: true } }, + fieldOverride+: self.standardOptions.override + { '#':: { ignore: true } }, + + '#gridPos': {}, // use withGridPos instead, a bit more concise. + local gridPos = self.gridPos, + panelOptions+: { + '#withPluginVersion': {}, + + '#withGridPos': d.func.new( + ||| + `withGridPos` configures the height, width and xy coordinates of the panel. Also see `grafonnet.util.grid` for helper functions to calculate these fields. + + All arguments default to `null`, which means they will remain unchanged or unset. + |||, + args=[ + d.arg('h', d.T.number, default='null'), + d.arg('w', d.T.number, default='null'), + d.arg('x', d.T.number, default='null'), + d.arg('y', d.T.number, default='null'), + ] + ), + withGridPos(h=null, w=null, x=null, y=null): + (if h != null then gridPos.withH(h) else {}) + + (if w != null then gridPos.withW(w) else {}) + + (if x != null then gridPos.withX(x) else {}) + + (if y != null then gridPos.withY(y) else {}), + }, + + '#datasource':: {}, // use withDatasource instead, bit more concise + local datasource = self.datasource, + queryOptions+: { + '#withDatasource':: d.func.new( + ||| + `withDatasource` sets the datasource for all queries in a panel. + + The default datasource for a panel is set to 'Mixed datasource' so panels can be datasource agnostic, which is a lot more interesting from a reusability standpoint. Note that this requires query targets to explicitly set datasource for the same reason. + |||, + args=[ + d.arg('type', d.T.string), + d.arg('uid', d.T.string), + ] + ), + withDatasource(type, uid): + datasource.withType(type) + + datasource.withUid(uid), + }, + + standardOptions+: { + threshold+: { step+: { '#':: d.package.newSub('threshold.step', '') } }, + + local overrides = super.override, + local commonOverrideFunctions = { + '#new':: d.fn( + '`new` creates a new override of type `%s`.' % self.type, + args=[ + d.arg('value', d.T.string), + ] + ), + new(value): + overrides.matcher.withId(self.type) + + overrides.matcher.withOptions(value), + + '#withProperty':: d.fn( + ||| + `withProperty` adds a property that needs to be overridden. This function can + be called multiple time, adding more properties. + |||, + args=[ + d.arg('id', d.T.string), + d.arg('value', d.T.any), + ] + ), + withProperty(id, value): + overrides.withPropertiesMixin([ + overrides.properties.withId(id) + + overrides.properties.withValue(value), + ]), + + '#withPropertiesFromOptions':: d.fn( + ||| + `withPropertiesFromOptions` takes an object with properties that need to be + overridden. See example code above. + |||, + args=[ + d.arg('options', d.T.object), + ] + ), + withPropertiesFromOptions(options): + local infunc(input, path=[]) = + std.foldl( + function(acc, p) + acc + ( + if p == 'custom' + then infunc(input[p], path=path + [p]) + else + overrides.withPropertiesMixin([ + overrides.properties.withId(std.join('.', path + [p])) + + overrides.properties.withValue(input[p]), + ]) + ), + std.objectFields(input), + {} + ); + infunc(options.fieldConfig.defaults), + }, + + override: + { + '#':: d.package.newSub( + 'override', + ||| + Overrides allow you to customize visualization settings for specific fields or + series. This is accomplished by adding an override rule that targets + a particular set of fields and that can each define multiple options. + + ```jsonnet + override.byType.new('number') + + override.byType.withPropertiesFromOptions( + panel.standardOptions.withDecimals(2) + + panel.standardOptions.withUnit('s') + ) + ``` + ||| + ), + byName: commonOverrideFunctions + { type:: 'byName' }, + byRegexp: commonOverrideFunctions + { type:: 'byRegexp' }, + byType: commonOverrideFunctions + { type:: 'byType' }, + byQuery: commonOverrideFunctions + { type:: 'byQuery' }, + // TODO: byValue takes more complex `options` than string + byValue: commonOverrideFunctions + { type:: 'byValue' }, + }, + }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/query/loki.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/query/loki.libsonnet new file mode 100644 index 0000000000..9c19f83518 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/query/loki.libsonnet @@ -0,0 +1,27 @@ +local d = import 'github.com/jsonnet-libs/docsonnet/doc-util/main.libsonnet'; + +{ + '#new':: d.func.new( + 'Creates a new loki query target for panels.', + args=[ + d.arg('datasource', d.T.string), + d.arg('expr', d.T.string), + ] + ), + new(datasource, expr): + self.withDatasource(datasource) + + self.withExpr(expr), + + '#withDatasource':: d.func.new( + 'Set the datasource for this query.', + args=[ + d.arg('value', d.T.string), + ] + ), + withDatasource(value): { + datasource+: { + type: 'loki', + uid: value, + }, + }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/query/prometheus.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/query/prometheus.libsonnet new file mode 100644 index 0000000000..3abe221280 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/query/prometheus.libsonnet @@ -0,0 +1,47 @@ +local d = import 'github.com/jsonnet-libs/docsonnet/doc-util/main.libsonnet'; + +{ + '#new':: d.func.new( + 'Creates a new prometheus query target for panels.', + args=[ + d.arg('datasource', d.T.string), + d.arg('expr', d.T.string), + ] + ), + new(datasource, expr): + self.withDatasource(datasource) + + self.withExpr(expr), + + '#withIntervalFactor':: d.func.new( + 'Set the interval factor for this query.', + args=[ + d.arg('value', d.T.string), + ] + ), + withIntervalFactor(value): { + intervalFactor: value, + }, + + '#withLegendFormat':: d.func.new( + 'Set the legend format for this query.', + args=[ + d.arg('value', d.T.string), + ] + ), + withLegendFormat(value): { + legendFormat: value, + }, + + '#withDatasource':: d.func.new( + 'Set the datasource for this query.', + args=[ + d.arg('value', d.T.string), + ] + ), + withDatasource(value): { + datasource+: { + type: 'prometheus', + uid: value, + }, + }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/query/tempo.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/query/tempo.libsonnet new file mode 100644 index 0000000000..debcb73aac --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/query/tempo.libsonnet @@ -0,0 +1,29 @@ +local d = import 'github.com/jsonnet-libs/docsonnet/doc-util/main.libsonnet'; + +{ + '#new':: d.func.new( + 'Creates a new tempo query target for panels.', + args=[ + d.arg('datasource', d.T.string), + d.arg('query', d.T.string), + d.arg('filters', d.T.array), + ] + ), + new(datasource, query, filters): + self.withDatasource(datasource) + + self.withQuery(query) + + self.withFilters(filters), + + '#withDatasource':: d.func.new( + 'Set the datasource for this query.', + args=[ + d.arg('value', d.T.string), + ] + ), + withDatasource(value): { + datasource+: { + type: 'tempo', + uid: value, + }, + }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/row.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/row.libsonnet new file mode 100644 index 0000000000..cf0b333cf3 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/row.libsonnet @@ -0,0 +1,11 @@ +local d = import 'github.com/jsonnet-libs/docsonnet/doc-util/main.libsonnet'; + +{ + '#new':: d.func.new( + 'Creates a new row panel with a title.', + args=[d.arg('title', d.T.string)] + ), + new(title): + self.withTitle(title) + + self.withType(), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/util/dashboard.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/util/dashboard.libsonnet new file mode 100644 index 0000000000..da7b2c8d0b --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/util/dashboard.libsonnet @@ -0,0 +1,55 @@ +local d = import 'github.com/jsonnet-libs/docsonnet/doc-util/main.libsonnet'; +local xtd = import 'github.com/jsonnet-libs/xtd/main.libsonnet'; + +{ + local root = self, + + '#getOptionsForCustomQuery':: d.func.new( + ||| + `getOptionsForCustomQuery` provides values for the `options` and `current` fields. + These are required for template variables of type 'custom'but do not automatically + get populated by Grafana when importing a dashboard from JSON. + + This is a bit of a hack and should always be called on functions that set `type` on + a template variable. Ideally Grafana populates these fields from the `query` value + but this provides a backwards compatible solution. + |||, + args=[d.arg('query', d.T.string)], + ), + getOptionsForCustomQuery(query, multi): { + local values = root.parseCustomQuery(query), + current: root.getCurrentFromValues(values, multi), + options: root.getOptionsFromValues(values), + }, + + getCurrentFromValues(values, multi): { + selected: false, + text: if multi then [values[0].key] else values[0].key, + value: if multi then [values[0].value] else values[0].value, + }, + + getOptionsFromValues(values): + std.mapWithIndex( + function(i, item) { + selected: i == 0, + text: item.key, + value: item.value, + }, + values + ), + + parseCustomQuery(query): + std.map( + function(v) + // Split items into key:value pairs + local split = std.splitLimit(v, ' : ', 1); + { + key: std.stripChars(split[0], ' '), + value: + if std.length(split) == 2 + then std.stripChars(split[1], ' ') + else self.key, + }, + xtd.string.splitEscape(query, ',') // Split query by comma, unless the comma is escaped + ), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/util/grid.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/util/grid.libsonnet new file mode 100644 index 0000000000..92f011a689 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/util/grid.libsonnet @@ -0,0 +1,231 @@ +local d = import 'github.com/jsonnet-libs/docsonnet/doc-util/main.libsonnet'; + +{ + local root = self, + + local rowPanelHeight = 1, + local gridWidth = 24, + + // Calculates the number of rows for a set of panels. + countRows(panels, panelWidth): + std.ceil(std.length(panels) / std.floor(gridWidth / panelWidth)), + + // Calculates gridPos for a panel based on its index, width and height. + gridPosForIndex(index, panelWidth, panelHeight, startY): { + local panelsPerRow = std.floor(gridWidth / panelWidth), + local row = std.floor(index / panelsPerRow), + local col = std.mod(index, panelsPerRow), + gridPos: { + w: panelWidth, + h: panelHeight, + x: panelWidth * col, + y: startY + (panelHeight * row) + row, + }, + }, + + // Configures gridPos for each panel in a grid with equal width and equal height. + makePanelGrid(panels, panelWidth, panelHeight, startY): + std.mapWithIndex( + function(i, panel) + panel + root.gridPosForIndex(i, panelWidth, panelHeight, startY), + panels + ), + + '#makeGrid':: d.func.new( + ||| + `makeGrid` returns an array of `panels` organized in a grid with equal `panelWidth` + and `panelHeight`. Row panels are used as "linebreaks", if a Row panel is collapsed, + then all panels below it will be folded into the row. + + This function will use the full grid of 24 columns, setting `panelWidth` to a value + that can divide 24 into equal parts will fill up the page nicely. (1, 2, 3, 4, 6, 8, 12) + Other value for `panelWidth` will leave a gap on the far right. + + Optional `startY` can be provided to place generated grid above or below existing panels. + |||, + args=[ + d.arg('panels', d.T.array), + d.arg('panelWidth', d.T.number), + d.arg('panelHeight', d.T.number), + d.arg('startY', d.T.number), + ], + ), + makeGrid(panels, panelWidth=8, panelHeight=8, startY=0): + // Get indexes for all Row panels + local rowIndexes = [ + i + for i in std.range(0, std.length(panels) - 1) + if panels[i].type == 'row' + ]; + + // Group panels below each Row panel + local rowGroups = + std.mapWithIndex( + function(i, r) { + header: + { + // Set initial values to ensure a value is set + // may be overridden at per Row panel + collapsed: false, + panels: [], + } + + panels[r], + panels: + self.header.panels // prepend panels that are part of the Row panel + + (if i == std.length(rowIndexes) - 1 // last rowIndex + then panels[r + 1:] + else panels[r + 1:rowIndexes[i + 1]]), + rows: root.countRows(self.panels, panelWidth), + }, + rowIndexes + ); + + // Loop over rowGroups + std.foldl( + function(acc, rowGroup) acc + { + local y = acc.nexty, + nexty: y // previous y + + (rowGroup.rows * panelHeight) // height of all rows + + rowGroup.rows // plus 1 for each row + + acc.lastRowPanelHeight, + + lastRowPanelHeight: rowPanelHeight, // set height for next round + + // Create a grid per group + local panels = root.makePanelGrid(rowGroup.panels, panelWidth, panelHeight, y + 1), + + panels+: + [ + // Add row header aka the Row panel + rowGroup.header + { + gridPos: { + w: gridWidth, // always full length + h: rowPanelHeight, // always 1 height + x: 0, // always at beginning + y: y, + }, + panels: + // If row is collapsed, then store panels inside Row panel + if rowGroup.header.collapsed + then panels + else [], + }, + ] + + ( + // If row is not collapsed, then expose panels directly + if !rowGroup.header.collapsed + then panels + else [] + ), + }, + rowGroups, + { + // Get panels that come before the rowGroups + local panelsBeforeRowGroups = + if std.length(rowIndexes) != 0 + then panels[0:rowIndexes[0]] + else panels, // matches all panels if no Row panels found + local rows = root.countRows(panelsBeforeRowGroups, panelWidth), + nexty: startY + (rows * panelHeight) + rows, + + lastRowPanelHeight: 0, // starts without a row panel + + // Create a grid for the panels that come before the rowGroups + panels: root.makePanelGrid(panelsBeforeRowGroups, panelWidth, panelHeight, startY), + } + ).panels, + + '#wrapPanels':: d.func.new( + ||| + `wrapPanels` returns an array of `panels` organized in a grid, wrapping up to next 'row' if total width exceeds full grid of 24 columns. + 'panelHeight' and 'panelWidth' are used unless panels already have height and width defined. + |||, + args=[ + d.arg('panels', d.T.array), + d.arg('panelWidth', d.T.number), + d.arg('panelHeight', d.T.number), + d.arg('startY', d.T.number), + ], + ), + wrapPanels(panels, panelWidth=8, panelHeight=8, startY=0): + std.foldl( + function(acc, panel) + if panel.type == 'row' + then + // when type=row, start new row immediatly and shift Y of new row by max height recorded + acc + { + panels+: [ + panel + { + gridPos+: + { + x: acc.cursor.x, + y: acc.cursor.y + acc.cursor.maxH, + w: 0, + h: 1, + }, + }, + ], + cursor:: { + x: 0, + y: acc.cursor.y + acc.cursor.maxH + 1, + maxH: 0, + }, + } + else + // handle regular panel + local gridPos = std.get(panel, 'gridPos', {}); + local width = std.get(gridPos, 'w', panelWidth); + local height = std.get(gridPos, 'h', panelHeight); + if acc.cursor.x + width > gridWidth + then + // start new row as width exceeds gridWidth + acc + { + panels+: [ + panel + { + gridPos+: + { + x: 0, + y: acc.cursor.y + height, + w: width, + h: height, + }, + }, + ], + cursor+:: { + x: 0 + width, + y: acc.cursor.y + height, + maxH: if height > super.maxH then height else super.maxH, + }, + } + else + // enough width, place panel on current row + acc + { + panels+: [ + panel + { + gridPos+: + { + x: acc.cursor.x, + y: acc.cursor.y, + w: width, + h: height, + }, + }, + ], + cursor+:: { + x: acc.cursor.x + width, + y: acc.cursor.y, + maxH: if height > super.maxH then height else super.maxH, + }, + }, + panels, + // Initial value for acc + { + panels: [], + cursor:: { + x: 0, + y: startY, + maxH: 0, // max height of current 'row' + }, + } + ).panels, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/util/main.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/util/main.libsonnet new file mode 100644 index 0000000000..78fe95fc20 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/util/main.libsonnet @@ -0,0 +1,9 @@ +local d = import 'github.com/jsonnet-libs/docsonnet/doc-util/main.libsonnet'; + +{ + '#': d.package.newSub('util', 'Helper functions that work well with Grafonnet.'), + dashboard: (import './dashboard.libsonnet'), + grid: (import './grid.libsonnet'), + panel: (import './panel.libsonnet'), + string: (import './string.libsonnet'), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/util/panel.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/util/panel.libsonnet new file mode 100644 index 0000000000..1191b23c84 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/util/panel.libsonnet @@ -0,0 +1,51 @@ +local d = import 'github.com/jsonnet-libs/docsonnet/doc-util/main.libsonnet'; + +{ + local this = self, + + '#setPanelIDs':: d.func.new( + ||| + `setPanelIDs` ensures that all `panels` have a unique ID, this functions is used in + `dashboard.withPanels` and `dashboard.withPanelsMixin` to provide a consistent + experience. + + used in ../dashboard.libsonnet + |||, + args=[ + d.arg('panels', d.T.array), + ] + ), + setPanelIDs(panels): + local infunc(panels, start=1) = + std.foldl( + function(acc, panel) + acc + { + index: // Track the index to ensure no duplicates exist. + acc.index + + 1 + + (if panel.type == 'row' + && 'panels' in panel + then std.length(panel.panels) + else 0), + + panels+: [ + panel + { id: acc.index } + + ( + if panel.type == 'row' + && 'panels' in panel + then { + panels: + infunc( + panel.panels, + acc.index + 1 + ), + } + else {} + ), + ], + }, + panels, + { index: start, panels: [] } + ).panels; + infunc(panels), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/util/string.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/util/string.libsonnet new file mode 100644 index 0000000000..ec5a66e429 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/custom/util/string.libsonnet @@ -0,0 +1,27 @@ +local d = import 'github.com/jsonnet-libs/docsonnet/doc-util/main.libsonnet'; +local xtd = import 'github.com/jsonnet-libs/xtd/main.libsonnet'; + +{ + '#slugify':: d.func.new( + ||| + `slugify` will create a simple slug from `string`, keeping only alphanumeric + characters and replacing spaces with dashes. + |||, + args=[d.arg('string', d.T.string)] + ), + slugify(string): + std.strReplace( + std.asciiLower( + std.join('', [ + string[i] + for i in std.range(0, std.length(string) - 1) + if xtd.ascii.isUpper(string[i]) + || xtd.ascii.isLower(string[i]) + || xtd.ascii.isNumber(string[i]) + || string[i] == ' ' + ]) + ), + ' ', + '-', + ), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/README.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/README.md new file mode 100644 index 0000000000..161f1e4341 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/README.md @@ -0,0 +1,29 @@ +# grafonnet + +Jsonnet library for rendering Grafana resources +## Install + +``` +jb install github.com/grafana/grafonnet/gen/grafonnet-v10.0.0@main +``` + +## Usage + +```jsonnet +local grafonnet = import "github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/main.libsonnet" +``` + + +## Subpackages + +* [alerting](alerting/index.md) +* [dashboard](dashboard/index.md) +* [librarypanel](librarypanel.md) +* [panel](panel/index.md) +* [playlist](playlist/index.md) +* [preferences](preferences.md) +* [publicdashboard](publicdashboard.md) +* [query](query/index.md) +* [serviceaccount](serviceaccount.md) +* [team](team.md) +* [util](util.md) diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/alerting/contactPoint.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/alerting/contactPoint.md new file mode 100644 index 0000000000..b796b0c1b8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/alerting/contactPoint.md @@ -0,0 +1,100 @@ +# contactPoint + +grafonnet.alerting.contactPoint + +**NOTE**: The schemas for all different contact points is under development, this means we can't properly express them in Grafonnet yet. The way this works now may change heavily. + + +## Index + +* [`fn withDisableResolveMessage(value=true)`](#fn-withdisableresolvemessage) +* [`fn withName(value)`](#fn-withname) +* [`fn withProvenance(value)`](#fn-withprovenance) +* [`fn withSettings(value)`](#fn-withsettings) +* [`fn withSettingsMixin(value)`](#fn-withsettingsmixin) +* [`fn withType(value)`](#fn-withtype) +* [`fn withUid(value)`](#fn-withuid) + +## Fields + +### fn withDisableResolveMessage + +```jsonnet +withDisableResolveMessage(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withName + +```jsonnet +withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name is used as grouping key in the UI. Contact points with the +same name will be grouped in the UI. +### fn withProvenance + +```jsonnet +withProvenance(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withSettings + +```jsonnet +withSettings(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withSettingsMixin + +```jsonnet +withSettingsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withType + +```jsonnet +withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"alertmanager"`, `" dingding"`, `" discord"`, `" email"`, `" googlechat"`, `" kafka"`, `" line"`, `" opsgenie"`, `" pagerduty"`, `" pushover"`, `" sensugo"`, `" slack"`, `" teams"`, `" telegram"`, `" threema"`, `" victorops"`, `" webhook"`, `" wecom"` + + +### fn withUid + +```jsonnet +withUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + +UID is the unique identifier of the contact point. The UID can be +set by the user. \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/alerting/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/alerting/index.md new file mode 100644 index 0000000000..b77a82d09f --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/alerting/index.md @@ -0,0 +1,11 @@ +# alerting + +grafonnet.alerting + +## Subpackages + +* [contactPoint](contactPoint.md) +* [messageTemplate](messageTemplate.md) +* [muteTiming](muteTiming/index.md) +* [notificationPolicy](notificationPolicy/index.md) +* [ruleGroup](ruleGroup/index.md) diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/alerting/messageTemplate.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/alerting/messageTemplate.md new file mode 100644 index 0000000000..df7c233361 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/alerting/messageTemplate.md @@ -0,0 +1,32 @@ +# messageTemplate + +grafonnet.alerting.messageTemplate + +## Index + +* [`fn withName(value)`](#fn-withname) +* [`fn withTemplate(value)`](#fn-withtemplate) + +## Fields + +### fn withName + +```jsonnet +withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withTemplate + +```jsonnet +withTemplate(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/alerting/muteTiming/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/alerting/muteTiming/index.md new file mode 100644 index 0000000000..3aee846bb2 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/alerting/muteTiming/index.md @@ -0,0 +1,48 @@ +# muteTiming + +grafonnet.alerting.muteTiming + +## Subpackages + +* [interval](interval/index.md) + +## Index + +* [`fn withIntervals(value)`](#fn-withintervals) +* [`fn withIntervalsMixin(value)`](#fn-withintervalsmixin) +* [`fn withName(value)`](#fn-withname) + +## Fields + +### fn withIntervals + +```jsonnet +withIntervals(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withIntervalsMixin + +```jsonnet +withIntervalsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withName + +```jsonnet +withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/alerting/muteTiming/interval/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/alerting/muteTiming/interval/index.md new file mode 100644 index 0000000000..aecdd1d920 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/alerting/muteTiming/interval/index.md @@ -0,0 +1,144 @@ +# interval + + + +## Subpackages + +* [times](times.md) + +## Index + +* [`fn withDaysOfMonth(value)`](#fn-withdaysofmonth) +* [`fn withDaysOfMonthMixin(value)`](#fn-withdaysofmonthmixin) +* [`fn withLocation(value)`](#fn-withlocation) +* [`fn withMonths(value)`](#fn-withmonths) +* [`fn withMonthsMixin(value)`](#fn-withmonthsmixin) +* [`fn withTimes(value)`](#fn-withtimes) +* [`fn withTimesMixin(value)`](#fn-withtimesmixin) +* [`fn withWeekdays(value)`](#fn-withweekdays) +* [`fn withWeekdaysMixin(value)`](#fn-withweekdaysmixin) +* [`fn withYears(value)`](#fn-withyears) +* [`fn withYearsMixin(value)`](#fn-withyearsmixin) + +## Fields + +### fn withDaysOfMonth + +```jsonnet +withDaysOfMonth(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withDaysOfMonthMixin + +```jsonnet +withDaysOfMonthMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withLocation + +```jsonnet +withLocation(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withMonths + +```jsonnet +withMonths(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withMonthsMixin + +```jsonnet +withMonthsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTimes + +```jsonnet +withTimes(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTimesMixin + +```jsonnet +withTimesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withWeekdays + +```jsonnet +withWeekdays(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withWeekdaysMixin + +```jsonnet +withWeekdaysMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withYears + +```jsonnet +withYears(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withYearsMixin + +```jsonnet +withYearsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/alerting/muteTiming/interval/times.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/alerting/muteTiming/interval/times.md new file mode 100644 index 0000000000..43f7b3fe91 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/alerting/muteTiming/interval/times.md @@ -0,0 +1,32 @@ +# times + + + +## Index + +* [`fn withFrom(value)`](#fn-withfrom) +* [`fn withTo(value)`](#fn-withto) + +## Fields + +### fn withFrom + +```jsonnet +withFrom(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withTo + +```jsonnet +withTo(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/alerting/notificationPolicy/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/alerting/notificationPolicy/index.md new file mode 100644 index 0000000000..cb4aa0a984 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/alerting/notificationPolicy/index.md @@ -0,0 +1,173 @@ +# notificationPolicy + +grafonnet.alerting.notificationPolicy + +## Subpackages + +* [matcher](matcher.md) + +## Index + +* [`fn withContactPoint(value)`](#fn-withcontactpoint) +* [`fn withContinue(value=true)`](#fn-withcontinue) +* [`fn withGroupBy(value)`](#fn-withgroupby) +* [`fn withGroupByMixin(value)`](#fn-withgroupbymixin) +* [`fn withGroupInterval(value)`](#fn-withgroupinterval) +* [`fn withGroupWait(value)`](#fn-withgroupwait) +* [`fn withMatchers(value)`](#fn-withmatchers) +* [`fn withMatchersMixin(value)`](#fn-withmatchersmixin) +* [`fn withMuteTimeIntervals(value)`](#fn-withmutetimeintervals) +* [`fn withMuteTimeIntervalsMixin(value)`](#fn-withmutetimeintervalsmixin) +* [`fn withPolicy(value)`](#fn-withpolicy) +* [`fn withPolicyMixin(value)`](#fn-withpolicymixin) +* [`fn withRepeatInterval(value)`](#fn-withrepeatinterval) + +## Fields + +### fn withContactPoint + +```jsonnet +withContactPoint(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withContinue + +```jsonnet +withContinue(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withGroupBy + +```jsonnet +withGroupBy(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withGroupByMixin + +```jsonnet +withGroupByMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withGroupInterval + +```jsonnet +withGroupInterval(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withGroupWait + +```jsonnet +withGroupWait(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withMatchers + +```jsonnet +withMatchers(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Matchers is a slice of Matchers that is sortable, implements Stringer, and +provides a Matches method to match a LabelSet against all Matchers in the +slice. Note that some users of Matchers might require it to be sorted. +### fn withMatchersMixin + +```jsonnet +withMatchersMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Matchers is a slice of Matchers that is sortable, implements Stringer, and +provides a Matches method to match a LabelSet against all Matchers in the +slice. Note that some users of Matchers might require it to be sorted. +### fn withMuteTimeIntervals + +```jsonnet +withMuteTimeIntervals(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withMuteTimeIntervalsMixin + +```jsonnet +withMuteTimeIntervalsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withPolicy + +```jsonnet +withPolicy(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withPolicyMixin + +```jsonnet +withPolicyMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withRepeatInterval + +```jsonnet +withRepeatInterval(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/alerting/notificationPolicy/matcher.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/alerting/notificationPolicy/matcher.md new file mode 100644 index 0000000000..f31b1d85b2 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/alerting/notificationPolicy/matcher.md @@ -0,0 +1,45 @@ +# matcher + + + +## Index + +* [`fn withName(value)`](#fn-withname) +* [`fn withType(value)`](#fn-withtype) +* [`fn withValue(value)`](#fn-withvalue) + +## Fields + +### fn withName + +```jsonnet +withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withType + +```jsonnet +withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"="`, `"!="`, `"=~"`, `"!~"` + +MatchType is an enum for label matching types. +### fn withValue + +```jsonnet +withValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/alerting/ruleGroup/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/alerting/ruleGroup/index.md new file mode 100644 index 0000000000..21d94b5fab --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/alerting/ruleGroup/index.md @@ -0,0 +1,72 @@ +# ruleGroup + +grafonnet.alerting.ruleGroup + +## Subpackages + +* [rule](rule/index.md) + +## Index + +* [`fn withFolderUid(value)`](#fn-withfolderuid) +* [`fn withInterval(value)`](#fn-withinterval) +* [`fn withName(value)`](#fn-withname) +* [`fn withRules(value)`](#fn-withrules) +* [`fn withRulesMixin(value)`](#fn-withrulesmixin) + +## Fields + +### fn withFolderUid + +```jsonnet +withFolderUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withInterval + +```jsonnet +withInterval(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +### fn withName + +```jsonnet +withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withRules + +```jsonnet +withRules(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withRulesMixin + +```jsonnet +withRulesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/alerting/ruleGroup/rule/data.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/alerting/ruleGroup/rule/data.md new file mode 100644 index 0000000000..0c6052003c --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/alerting/ruleGroup/rule/data.md @@ -0,0 +1,128 @@ +# data + + + +## Index + +* [`fn withDatasourceUid(value)`](#fn-withdatasourceuid) +* [`fn withModel(value)`](#fn-withmodel) +* [`fn withModelMixin(value)`](#fn-withmodelmixin) +* [`fn withQueryType(value)`](#fn-withquerytype) +* [`fn withRefId(value)`](#fn-withrefid) +* [`fn withRelativeTimeRange(value)`](#fn-withrelativetimerange) +* [`fn withRelativeTimeRangeMixin(value)`](#fn-withrelativetimerangemixin) +* [`obj relativeTimeRange`](#obj-relativetimerange) + * [`fn withFrom(value)`](#fn-relativetimerangewithfrom) + * [`fn withTo(value)`](#fn-relativetimerangewithto) + +## Fields + +### fn withDatasourceUid + +```jsonnet +withDatasourceUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Grafana data source unique identifier; it should be '__expr__' for a Server Side Expression operation. +### fn withModel + +```jsonnet +withModel(value) +``` + +PARAMETERS: + +* **value** (`object`) + +JSON is the raw JSON query and includes the above properties as well as custom properties. +### fn withModelMixin + +```jsonnet +withModelMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +JSON is the raw JSON query and includes the above properties as well as custom properties. +### fn withQueryType + +```jsonnet +withQueryType(value) +``` + +PARAMETERS: + +* **value** (`string`) + +QueryType is an optional identifier for the type of query. +It can be used to distinguish different types of queries. +### fn withRefId + +```jsonnet +withRefId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +RefID is the unique identifier of the query, set by the frontend call. +### fn withRelativeTimeRange + +```jsonnet +withRelativeTimeRange(value) +``` + +PARAMETERS: + +* **value** (`object`) + +RelativeTimeRange is the per query start and end time +for requests. +### fn withRelativeTimeRangeMixin + +```jsonnet +withRelativeTimeRangeMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +RelativeTimeRange is the per query start and end time +for requests. +### obj relativeTimeRange + + +#### fn relativeTimeRange.withFrom + +```jsonnet +relativeTimeRange.withFrom(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +A Duration represents the elapsed time between two instants +as an int64 nanosecond count. The representation limits the +largest representable duration to approximately 290 years. +#### fn relativeTimeRange.withTo + +```jsonnet +relativeTimeRange.withTo(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +A Duration represents the elapsed time between two instants +as an int64 nanosecond count. The representation limits the +largest representable duration to approximately 290 years. \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/alerting/ruleGroup/rule/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/alerting/ruleGroup/rule/index.md new file mode 100644 index 0000000000..e93787c028 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/alerting/ruleGroup/rule/index.md @@ -0,0 +1,161 @@ +# rule + + + +## Subpackages + +* [data](data.md) + +## Index + +* [`fn withAnnotations(value)`](#fn-withannotations) +* [`fn withAnnotationsMixin(value)`](#fn-withannotationsmixin) +* [`fn withCondition(value)`](#fn-withcondition) +* [`fn withData(value)`](#fn-withdata) +* [`fn withDataMixin(value)`](#fn-withdatamixin) +* [`fn withExecErrState(value)`](#fn-withexecerrstate) +* [`fn withFor(value)`](#fn-withfor) +* [`fn withIsPaused(value=true)`](#fn-withispaused) +* [`fn withLabels(value)`](#fn-withlabels) +* [`fn withLabelsMixin(value)`](#fn-withlabelsmixin) +* [`fn withName(value)`](#fn-withname) +* [`fn withNoDataState(value)`](#fn-withnodatastate) + +## Fields + +### fn withAnnotations + +```jsonnet +withAnnotations(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withAnnotationsMixin + +```jsonnet +withAnnotationsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withCondition + +```jsonnet +withCondition(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withData + +```jsonnet +withData(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withDataMixin + +```jsonnet +withDataMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withExecErrState + +```jsonnet +withExecErrState(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"OK"`, `"Alerting"`, `"Error"` + + +### fn withFor + +```jsonnet +withFor(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +A Duration represents the elapsed time between two instants +as an int64 nanosecond count. The representation limits the +largest representable duration to approximately 290 years. +### fn withIsPaused + +```jsonnet +withIsPaused(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withLabels + +```jsonnet +withLabels(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withLabelsMixin + +```jsonnet +withLabelsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withName + +```jsonnet +withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withNoDataState + +```jsonnet +withNoDataState(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"Alerting"`, `"NoData"`, `"OK"` + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/dashboard/annotation.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/dashboard/annotation.md new file mode 100644 index 0000000000..d486ab0fb8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/dashboard/annotation.md @@ -0,0 +1,285 @@ +# annotation + + + +## Index + +* [`fn withDatasource(value)`](#fn-withdatasource) +* [`fn withDatasourceMixin(value)`](#fn-withdatasourcemixin) +* [`fn withEnable(value=true)`](#fn-withenable) +* [`fn withFilter(value)`](#fn-withfilter) +* [`fn withFilterMixin(value)`](#fn-withfiltermixin) +* [`fn withHide(value=true)`](#fn-withhide) +* [`fn withIconColor(value)`](#fn-withiconcolor) +* [`fn withName(value)`](#fn-withname) +* [`fn withTarget(value)`](#fn-withtarget) +* [`fn withTargetMixin(value)`](#fn-withtargetmixin) +* [`fn withType(value)`](#fn-withtype) +* [`obj datasource`](#obj-datasource) + * [`fn withType(value)`](#fn-datasourcewithtype) + * [`fn withUid(value)`](#fn-datasourcewithuid) +* [`obj filter`](#obj-filter) + * [`fn withExclude(value=true)`](#fn-filterwithexclude) + * [`fn withIds(value)`](#fn-filterwithids) + * [`fn withIdsMixin(value)`](#fn-filterwithidsmixin) +* [`obj target`](#obj-target) + * [`fn withLimit(value)`](#fn-targetwithlimit) + * [`fn withMatchAny(value=true)`](#fn-targetwithmatchany) + * [`fn withTags(value)`](#fn-targetwithtags) + * [`fn withTagsMixin(value)`](#fn-targetwithtagsmixin) + * [`fn withType(value)`](#fn-targetwithtype) + +## Fields + +### fn withDatasource + +```jsonnet +withDatasource(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO: Should be DataSourceRef +### fn withDatasourceMixin + +```jsonnet +withDatasourceMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO: Should be DataSourceRef +### fn withEnable + +```jsonnet +withEnable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +When enabled the annotation query is issued with every dashboard refresh +### fn withFilter + +```jsonnet +withFilter(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withFilterMixin + +```jsonnet +withFilterMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withHide + +```jsonnet +withHide(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Annotation queries can be toggled on or off at the top of the dashboard. +When hide is true, the toggle is not shown in the dashboard. +### fn withIconColor + +```jsonnet +withIconColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Color to use for the annotation event markers +### fn withName + +```jsonnet +withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of annotation. +### fn withTarget + +```jsonnet +withTarget(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO: this should be a regular DataQuery that depends on the selected dashboard +these match the properties of the "grafana" datasouce that is default in most dashboards +### fn withTargetMixin + +```jsonnet +withTargetMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO: this should be a regular DataQuery that depends on the selected dashboard +these match the properties of the "grafana" datasouce that is default in most dashboards +### fn withType + +```jsonnet +withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO -- this should not exist here, it is based on the --grafana-- datasource +### obj datasource + + +#### fn datasource.withType + +```jsonnet +datasource.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn datasource.withUid + +```jsonnet +datasource.withUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj filter + + +#### fn filter.withExclude + +```jsonnet +filter.withExclude(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Should the specified panels be included or excluded +#### fn filter.withIds + +```jsonnet +filter.withIds(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel IDs that should be included or excluded +#### fn filter.withIdsMixin + +```jsonnet +filter.withIdsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel IDs that should be included or excluded +### obj target + + +#### fn target.withLimit + +```jsonnet +target.withLimit(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Only required/valid for the grafana datasource... +but code+tests is already depending on it so hard to change +#### fn target.withMatchAny + +```jsonnet +target.withMatchAny(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Only required/valid for the grafana datasource... +but code+tests is already depending on it so hard to change +#### fn target.withTags + +```jsonnet +target.withTags(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Only required/valid for the grafana datasource... +but code+tests is already depending on it so hard to change +#### fn target.withTagsMixin + +```jsonnet +target.withTagsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Only required/valid for the grafana datasource... +but code+tests is already depending on it so hard to change +#### fn target.withType + +```jsonnet +target.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Only required/valid for the grafana datasource... +but code+tests is already depending on it so hard to change \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/dashboard/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/dashboard/index.md new file mode 100644 index 0000000000..bb0a284dc0 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/dashboard/index.md @@ -0,0 +1,517 @@ +# dashboard + +grafonnet.dashboard + +## Subpackages + +* [annotation](annotation.md) +* [link](link.md) +* [variable](variable.md) + +## Index + +* [`fn new(title)`](#fn-new) +* [`fn withAnnotations(value)`](#fn-withannotations) +* [`fn withAnnotationsMixin(value)`](#fn-withannotationsmixin) +* [`fn withDescription(value)`](#fn-withdescription) +* [`fn withEditable(value=true)`](#fn-witheditable) +* [`fn withFiscalYearStartMonth(value=0)`](#fn-withfiscalyearstartmonth) +* [`fn withLinks(value)`](#fn-withlinks) +* [`fn withLinksMixin(value)`](#fn-withlinksmixin) +* [`fn withLiveNow(value=true)`](#fn-withlivenow) +* [`fn withPanels(value)`](#fn-withpanels) +* [`fn withPanelsMixin(value)`](#fn-withpanelsmixin) +* [`fn withRefresh(value)`](#fn-withrefresh) +* [`fn withRefreshMixin(value)`](#fn-withrefreshmixin) +* [`fn withSchemaVersion(value=36)`](#fn-withschemaversion) +* [`fn withStyle(value="dark")`](#fn-withstyle) +* [`fn withTags(value)`](#fn-withtags) +* [`fn withTagsMixin(value)`](#fn-withtagsmixin) +* [`fn withTemplating(value)`](#fn-withtemplating) +* [`fn withTemplatingMixin(value)`](#fn-withtemplatingmixin) +* [`fn withTimezone(value="browser")`](#fn-withtimezone) +* [`fn withTitle(value)`](#fn-withtitle) +* [`fn withUid(value)`](#fn-withuid) +* [`fn withVariables(value)`](#fn-withvariables) +* [`fn withVariablesMixin(value)`](#fn-withvariablesmixin) +* [`fn withWeekStart(value)`](#fn-withweekstart) +* [`obj graphTooltip`](#obj-graphtooltip) + * [`fn withSharedCrosshair()`](#fn-graphtooltipwithsharedcrosshair) + * [`fn withSharedTooltip()`](#fn-graphtooltipwithsharedtooltip) +* [`obj time`](#obj-time) + * [`fn withFrom(value="now-6h")`](#fn-timewithfrom) + * [`fn withTo(value="now")`](#fn-timewithto) +* [`obj timepicker`](#obj-timepicker) + * [`fn withCollapse(value=true)`](#fn-timepickerwithcollapse) + * [`fn withEnable(value=true)`](#fn-timepickerwithenable) + * [`fn withHidden(value=true)`](#fn-timepickerwithhidden) + * [`fn withRefreshIntervals(value=["5s","10s","30s","1m","5m","15m","30m","1h","2h","1d"])`](#fn-timepickerwithrefreshintervals) + * [`fn withRefreshIntervalsMixin(value=["5s","10s","30s","1m","5m","15m","30m","1h","2h","1d"])`](#fn-timepickerwithrefreshintervalsmixin) + * [`fn withTimeOptions(value=["5m","15m","1h","6h","12h","24h","2d","7d","30d"])`](#fn-timepickerwithtimeoptions) + * [`fn withTimeOptionsMixin(value=["5m","15m","1h","6h","12h","24h","2d","7d","30d"])`](#fn-timepickerwithtimeoptionsmixin) + +## Fields + +### fn new + +```jsonnet +new(title) +``` + +PARAMETERS: + +* **title** (`string`) + +Creates a new dashboard with a title. +### fn withAnnotations + +```jsonnet +withAnnotations(value) +``` + +PARAMETERS: + +* **value** (`array`) + +`withAnnotations` adds an array of annotations to a dashboard. + +This function appends passed data to existing values + +### fn withAnnotationsMixin + +```jsonnet +withAnnotationsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +`withAnnotationsMixin` adds an array of annotations to a dashboard. + +This function appends passed data to existing values + +### fn withDescription + +```jsonnet +withDescription(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Description of dashboard. +### fn withEditable + +```jsonnet +withEditable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Whether a dashboard is editable or not. +### fn withFiscalYearStartMonth + +```jsonnet +withFiscalYearStartMonth(value=0) +``` + +PARAMETERS: + +* **value** (`integer`) + - default value: `0` + +The month that the fiscal year starts on. 0 = January, 11 = December +### fn withLinks + +```jsonnet +withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Dashboard links are displayed at the top of the dashboard, these can either link to other dashboards or to external URLs. + +`withLinks` takes an array of [link objects](./link.md). + +The [docs](https://grafana.com/docs/grafana/latest/dashboards/build-dashboards/manage-dashboard-links/#dashboard-links) give a more comprehensive description. + +Example: + +```jsonnet +local g = import 'g.libsonnet'; +local link = g.dashboard.link; + +g.dashboard.new('Title dashboard') ++ g.dashboard.withLinks([ + link.link.new('My title', 'https://wikipedia.org/'), +]) +``` + +### fn withLinksMixin + +```jsonnet +withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Dashboard links are displayed at the top of the dashboard, these can either link to other dashboards or to external URLs. + +`withLinks` takes an array of [link objects](./link.md). + +The [docs](https://grafana.com/docs/grafana/latest/dashboards/build-dashboards/manage-dashboard-links/#dashboard-links) give a more comprehensive description. + +Example: + +```jsonnet +local g = import 'g.libsonnet'; +local link = g.dashboard.link; + +g.dashboard.new('Title dashboard') ++ g.dashboard.withLinks([ + link.link.new('My title', 'https://wikipedia.org/'), +]) +``` + +### fn withLiveNow + +```jsonnet +withLiveNow(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +When set to true, the dashboard will redraw panels at an interval matching the pixel width. +This will keep data "moving left" regardless of the query refresh rate. This setting helps +avoid dashboards presenting stale live data +### fn withPanels + +```jsonnet +withPanels(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withPanelsMixin + +```jsonnet +withPanelsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withRefresh + +```jsonnet +withRefresh(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Refresh rate of dashboard. Represented via interval string, e.g. "5s", "1m", "1h", "1d". +### fn withRefreshMixin + +```jsonnet +withRefreshMixin(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Refresh rate of dashboard. Represented via interval string, e.g. "5s", "1m", "1h", "1d". +### fn withSchemaVersion + +```jsonnet +withSchemaVersion(value=36) +``` + +PARAMETERS: + +* **value** (`integer`) + - default value: `36` + +Version of the JSON schema, incremented each time a Grafana update brings +changes to said schema. +TODO this is the existing schema numbering system. It will be replaced by Thema's themaVersion +### fn withStyle + +```jsonnet +withStyle(value="dark") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"dark"` + - valid values: `"dark"`, `"light"` + +Theme of dashboard. +### fn withTags + +```jsonnet +withTags(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Tags associated with dashboard. +### fn withTagsMixin + +```jsonnet +withTagsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Tags associated with dashboard. +### fn withTemplating + +```jsonnet +withTemplating(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +### fn withTemplatingMixin + +```jsonnet +withTemplatingMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +### fn withTimezone + +```jsonnet +withTimezone(value="browser") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"browser"` + +Timezone of dashboard. Accepts IANA TZDB zone ID or "browser" or "utc". +### fn withTitle + +```jsonnet +withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Title of dashboard. +### fn withUid + +```jsonnet +withUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Unique dashboard identifier that can be generated by anyone. string (8-40) +### fn withVariables + +```jsonnet +withVariables(value) +``` + +PARAMETERS: + +* **value** (`array`) + +`withVariables` adds an array of variables to a dashboard + +### fn withVariablesMixin + +```jsonnet +withVariablesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +`withVariablesMixin` adds an array of variables to a dashboard. + +This function appends passed data to existing values + +### fn withWeekStart + +```jsonnet +withWeekStart(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +### obj graphTooltip + + +#### fn graphTooltip.withSharedCrosshair + +```jsonnet +graphTooltip.withSharedCrosshair() +``` + + +Share crosshair on all panels. +#### fn graphTooltip.withSharedTooltip + +```jsonnet +graphTooltip.withSharedTooltip() +``` + + +Share crosshair and tooltip on all panels. +### obj time + + +#### fn time.withFrom + +```jsonnet +time.withFrom(value="now-6h") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"now-6h"` + + +#### fn time.withTo + +```jsonnet +time.withTo(value="now") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"now"` + + +### obj timepicker + + +#### fn timepicker.withCollapse + +```jsonnet +timepicker.withCollapse(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Whether timepicker is collapsed or not. +#### fn timepicker.withEnable + +```jsonnet +timepicker.withEnable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Whether timepicker is enabled or not. +#### fn timepicker.withHidden + +```jsonnet +timepicker.withHidden(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Whether timepicker is visible or not. +#### fn timepicker.withRefreshIntervals + +```jsonnet +timepicker.withRefreshIntervals(value=["5s","10s","30s","1m","5m","15m","30m","1h","2h","1d"]) +``` + +PARAMETERS: + +* **value** (`array`) + - default value: `["5s","10s","30s","1m","5m","15m","30m","1h","2h","1d"]` + +Selectable intervals for auto-refresh. +#### fn timepicker.withRefreshIntervalsMixin + +```jsonnet +timepicker.withRefreshIntervalsMixin(value=["5s","10s","30s","1m","5m","15m","30m","1h","2h","1d"]) +``` + +PARAMETERS: + +* **value** (`array`) + - default value: `["5s","10s","30s","1m","5m","15m","30m","1h","2h","1d"]` + +Selectable intervals for auto-refresh. +#### fn timepicker.withTimeOptions + +```jsonnet +timepicker.withTimeOptions(value=["5m","15m","1h","6h","12h","24h","2d","7d","30d"]) +``` + +PARAMETERS: + +* **value** (`array`) + - default value: `["5m","15m","1h","6h","12h","24h","2d","7d","30d"]` + +TODO docs +#### fn timepicker.withTimeOptionsMixin + +```jsonnet +timepicker.withTimeOptionsMixin(value=["5m","15m","1h","6h","12h","24h","2d","7d","30d"]) +``` + +PARAMETERS: + +* **value** (`array`) + - default value: `["5m","15m","1h","6h","12h","24h","2d","7d","30d"]` + +TODO docs \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/dashboard/link.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/dashboard/link.md new file mode 100644 index 0000000000..75072e581c --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/dashboard/link.md @@ -0,0 +1,195 @@ +# link + +Dashboard links are displayed at the top of the dashboard, these can either link to other dashboards or to external URLs. + +The [docs](https://grafana.com/docs/grafana/latest/dashboards/build-dashboards/manage-dashboard-links/#dashboard-links) give a more comprehensive description. + +Example: + +```jsonnet +local g = import 'g.libsonnet'; +local link = g.dashboard.link; + +g.dashboard.new('Title dashboard') ++ g.dashboard.withLinks([ + link.link.new('My title', 'https://wikipedia.org/'), +]) +``` + + +## Index + +* [`obj dashboards`](#obj-dashboards) + * [`fn new(title, tags)`](#fn-dashboardsnew) + * [`obj options`](#obj-dashboardsoptions) + * [`fn withAsDropdown(value=true)`](#fn-dashboardsoptionswithasdropdown) + * [`fn withIncludeVars(value=true)`](#fn-dashboardsoptionswithincludevars) + * [`fn withKeepTime(value=true)`](#fn-dashboardsoptionswithkeeptime) + * [`fn withTargetBlank(value=true)`](#fn-dashboardsoptionswithtargetblank) +* [`obj link`](#obj-link) + * [`fn new(title, url)`](#fn-linknew) + * [`fn withIcon(value)`](#fn-linkwithicon) + * [`fn withTooltip(value)`](#fn-linkwithtooltip) + * [`obj options`](#obj-linkoptions) + * [`fn withAsDropdown(value=true)`](#fn-linkoptionswithasdropdown) + * [`fn withIncludeVars(value=true)`](#fn-linkoptionswithincludevars) + * [`fn withKeepTime(value=true)`](#fn-linkoptionswithkeeptime) + * [`fn withTargetBlank(value=true)`](#fn-linkoptionswithtargetblank) + +## Fields + +### obj dashboards + + +#### fn dashboards.new + +```jsonnet +dashboards.new(title, tags) +``` + +PARAMETERS: + +* **title** (`string`) +* **tags** (`array`) + +Create links to dashboards based on `tags`. + +#### obj dashboards.options + + +##### fn dashboards.options.withAsDropdown + +```jsonnet +dashboards.options.withAsDropdown(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn dashboards.options.withIncludeVars + +```jsonnet +dashboards.options.withIncludeVars(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn dashboards.options.withKeepTime + +```jsonnet +dashboards.options.withKeepTime(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn dashboards.options.withTargetBlank + +```jsonnet +dashboards.options.withTargetBlank(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### obj link + + +#### fn link.new + +```jsonnet +link.new(title, url) +``` + +PARAMETERS: + +* **title** (`string`) +* **url** (`string`) + +Create link to an arbitrary URL. + +#### fn link.withIcon + +```jsonnet +link.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn link.withTooltip + +```jsonnet +link.withTooltip(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj link.options + + +##### fn link.options.withAsDropdown + +```jsonnet +link.options.withAsDropdown(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn link.options.withIncludeVars + +```jsonnet +link.options.withIncludeVars(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn link.options.withKeepTime + +```jsonnet +link.options.withKeepTime(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn link.options.withTargetBlank + +```jsonnet +link.options.withTargetBlank(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/dashboard/variable.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/dashboard/variable.md new file mode 100644 index 0000000000..95ea78b86a --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/dashboard/variable.md @@ -0,0 +1,1042 @@ +# variable + +Example usage: + +```jsonnet +local g = import 'g.libsonnet'; +local var = g.dashboard.variable; + +local customVar = + var.custom.new( + 'myOptions', + values=['a', 'b', 'c', 'd'], + ) + + var.custom.generalOptions.withDescription( + 'This is a variable for my custom options.' + ) + + var.custom.selectionOptions.withMulti(); + +local queryVar = + var.query.new('queryOptions') + + var.query.queryTypes.withLabelValues( + 'up', + 'instance', + ) + + var.query.withDatasource( + type='prometheus', + uid='mimir-prod', + ) + + var.query.selectionOptions.withIncludeAll(); + + +g.dashboard.new('my dashboard') ++ g.dashboard.withVariables([ + customVar, + queryVar, +]) +``` + + +## Index + +* [`obj adhoc`](#obj-adhoc) + * [`fn new(name, type, uid)`](#fn-adhocnew) + * [`fn newFromDatasourceVariable(name, variable)`](#fn-adhocnewfromdatasourcevariable) + * [`obj generalOptions`](#obj-adhocgeneraloptions) + * [`fn withCurrent(key, value="")`](#fn-adhocgeneraloptionswithcurrent) + * [`fn withDescription(value)`](#fn-adhocgeneraloptionswithdescription) + * [`fn withLabel(value)`](#fn-adhocgeneraloptionswithlabel) + * [`fn withName(value)`](#fn-adhocgeneraloptionswithname) + * [`obj showOnDashboard`](#obj-adhocgeneraloptionsshowondashboard) + * [`fn withLabelAndValue()`](#fn-adhocgeneraloptionsshowondashboardwithlabelandvalue) + * [`fn withNothing()`](#fn-adhocgeneraloptionsshowondashboardwithnothing) + * [`fn withValueOnly()`](#fn-adhocgeneraloptionsshowondashboardwithvalueonly) +* [`obj constant`](#obj-constant) + * [`fn new(name, value)`](#fn-constantnew) + * [`obj generalOptions`](#obj-constantgeneraloptions) + * [`fn withCurrent(key, value="")`](#fn-constantgeneraloptionswithcurrent) + * [`fn withDescription(value)`](#fn-constantgeneraloptionswithdescription) + * [`fn withLabel(value)`](#fn-constantgeneraloptionswithlabel) + * [`fn withName(value)`](#fn-constantgeneraloptionswithname) + * [`obj showOnDashboard`](#obj-constantgeneraloptionsshowondashboard) + * [`fn withLabelAndValue()`](#fn-constantgeneraloptionsshowondashboardwithlabelandvalue) + * [`fn withNothing()`](#fn-constantgeneraloptionsshowondashboardwithnothing) + * [`fn withValueOnly()`](#fn-constantgeneraloptionsshowondashboardwithvalueonly) +* [`obj custom`](#obj-custom) + * [`fn new(name, values)`](#fn-customnew) + * [`obj generalOptions`](#obj-customgeneraloptions) + * [`fn withCurrent(key, value="")`](#fn-customgeneraloptionswithcurrent) + * [`fn withDescription(value)`](#fn-customgeneraloptionswithdescription) + * [`fn withLabel(value)`](#fn-customgeneraloptionswithlabel) + * [`fn withName(value)`](#fn-customgeneraloptionswithname) + * [`obj showOnDashboard`](#obj-customgeneraloptionsshowondashboard) + * [`fn withLabelAndValue()`](#fn-customgeneraloptionsshowondashboardwithlabelandvalue) + * [`fn withNothing()`](#fn-customgeneraloptionsshowondashboardwithnothing) + * [`fn withValueOnly()`](#fn-customgeneraloptionsshowondashboardwithvalueonly) + * [`obj selectionOptions`](#obj-customselectionoptions) + * [`fn withIncludeAll(value=true, customAllValue)`](#fn-customselectionoptionswithincludeall) + * [`fn withMulti(value=true)`](#fn-customselectionoptionswithmulti) +* [`obj datasource`](#obj-datasource) + * [`fn new(name, type)`](#fn-datasourcenew) + * [`fn withRegex(value)`](#fn-datasourcewithregex) + * [`obj generalOptions`](#obj-datasourcegeneraloptions) + * [`fn withCurrent(key, value="")`](#fn-datasourcegeneraloptionswithcurrent) + * [`fn withDescription(value)`](#fn-datasourcegeneraloptionswithdescription) + * [`fn withLabel(value)`](#fn-datasourcegeneraloptionswithlabel) + * [`fn withName(value)`](#fn-datasourcegeneraloptionswithname) + * [`obj showOnDashboard`](#obj-datasourcegeneraloptionsshowondashboard) + * [`fn withLabelAndValue()`](#fn-datasourcegeneraloptionsshowondashboardwithlabelandvalue) + * [`fn withNothing()`](#fn-datasourcegeneraloptionsshowondashboardwithnothing) + * [`fn withValueOnly()`](#fn-datasourcegeneraloptionsshowondashboardwithvalueonly) + * [`obj selectionOptions`](#obj-datasourceselectionoptions) + * [`fn withIncludeAll(value=true, customAllValue)`](#fn-datasourceselectionoptionswithincludeall) + * [`fn withMulti(value=true)`](#fn-datasourceselectionoptionswithmulti) +* [`obj interval`](#obj-interval) + * [`fn new(name, values)`](#fn-intervalnew) + * [`fn withAutoOption(count, minInterval)`](#fn-intervalwithautooption) + * [`obj generalOptions`](#obj-intervalgeneraloptions) + * [`fn withCurrent(key, value="")`](#fn-intervalgeneraloptionswithcurrent) + * [`fn withDescription(value)`](#fn-intervalgeneraloptionswithdescription) + * [`fn withLabel(value)`](#fn-intervalgeneraloptionswithlabel) + * [`fn withName(value)`](#fn-intervalgeneraloptionswithname) + * [`obj showOnDashboard`](#obj-intervalgeneraloptionsshowondashboard) + * [`fn withLabelAndValue()`](#fn-intervalgeneraloptionsshowondashboardwithlabelandvalue) + * [`fn withNothing()`](#fn-intervalgeneraloptionsshowondashboardwithnothing) + * [`fn withValueOnly()`](#fn-intervalgeneraloptionsshowondashboardwithvalueonly) +* [`obj query`](#obj-query) + * [`fn new(name, query="")`](#fn-querynew) + * [`fn withDatasource(type, uid)`](#fn-querywithdatasource) + * [`fn withDatasourceFromVariable(variable)`](#fn-querywithdatasourcefromvariable) + * [`fn withRegex(value)`](#fn-querywithregex) + * [`fn withSort(i=0, type="alphabetical", asc=true, caseInsensitive=false)`](#fn-querywithsort) + * [`obj generalOptions`](#obj-querygeneraloptions) + * [`fn withCurrent(key, value="")`](#fn-querygeneraloptionswithcurrent) + * [`fn withDescription(value)`](#fn-querygeneraloptionswithdescription) + * [`fn withLabel(value)`](#fn-querygeneraloptionswithlabel) + * [`fn withName(value)`](#fn-querygeneraloptionswithname) + * [`obj showOnDashboard`](#obj-querygeneraloptionsshowondashboard) + * [`fn withLabelAndValue()`](#fn-querygeneraloptionsshowondashboardwithlabelandvalue) + * [`fn withNothing()`](#fn-querygeneraloptionsshowondashboardwithnothing) + * [`fn withValueOnly()`](#fn-querygeneraloptionsshowondashboardwithvalueonly) + * [`obj queryTypes`](#obj-queryquerytypes) + * [`fn withLabelValues(label, metric="")`](#fn-queryquerytypeswithlabelvalues) + * [`obj refresh`](#obj-queryrefresh) + * [`fn onLoad()`](#fn-queryrefreshonload) + * [`fn onTime()`](#fn-queryrefreshontime) + * [`obj selectionOptions`](#obj-queryselectionoptions) + * [`fn withIncludeAll(value=true, customAllValue)`](#fn-queryselectionoptionswithincludeall) + * [`fn withMulti(value=true)`](#fn-queryselectionoptionswithmulti) +* [`obj textbox`](#obj-textbox) + * [`fn new(name, default="")`](#fn-textboxnew) + * [`obj generalOptions`](#obj-textboxgeneraloptions) + * [`fn withCurrent(key, value="")`](#fn-textboxgeneraloptionswithcurrent) + * [`fn withDescription(value)`](#fn-textboxgeneraloptionswithdescription) + * [`fn withLabel(value)`](#fn-textboxgeneraloptionswithlabel) + * [`fn withName(value)`](#fn-textboxgeneraloptionswithname) + * [`obj showOnDashboard`](#obj-textboxgeneraloptionsshowondashboard) + * [`fn withLabelAndValue()`](#fn-textboxgeneraloptionsshowondashboardwithlabelandvalue) + * [`fn withNothing()`](#fn-textboxgeneraloptionsshowondashboardwithnothing) + * [`fn withValueOnly()`](#fn-textboxgeneraloptionsshowondashboardwithvalueonly) + +## Fields + +### obj adhoc + + +#### fn adhoc.new + +```jsonnet +adhoc.new(name, type, uid) +``` + +PARAMETERS: + +* **name** (`string`) +* **type** (`string`) +* **uid** (`string`) + +`new` creates an adhoc template variable for datasource with `type` and `uid`. +#### fn adhoc.newFromDatasourceVariable + +```jsonnet +adhoc.newFromDatasourceVariable(name, variable) +``` + +PARAMETERS: + +* **name** (`string`) +* **variable** (`object`) + +Same as `new` but selecting the datasource from another template variable. +#### obj adhoc.generalOptions + + +##### fn adhoc.generalOptions.withCurrent + +```jsonnet +adhoc.generalOptions.withCurrent(key, value="") +``` + +PARAMETERS: + +* **key** (`any`) +* **value** (`any`) + - default value: `""` + +`withCurrent` sets the currently selected value of a variable. If key and value are different, both need to be given. + +##### fn adhoc.generalOptions.withDescription + +```jsonnet +adhoc.generalOptions.withDescription(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn adhoc.generalOptions.withLabel + +```jsonnet +adhoc.generalOptions.withLabel(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn adhoc.generalOptions.withName + +```jsonnet +adhoc.generalOptions.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### obj adhoc.generalOptions.showOnDashboard + + +###### fn adhoc.generalOptions.showOnDashboard.withLabelAndValue + +```jsonnet +adhoc.generalOptions.showOnDashboard.withLabelAndValue() +``` + + + +###### fn adhoc.generalOptions.showOnDashboard.withNothing + +```jsonnet +adhoc.generalOptions.showOnDashboard.withNothing() +``` + + + +###### fn adhoc.generalOptions.showOnDashboard.withValueOnly + +```jsonnet +adhoc.generalOptions.showOnDashboard.withValueOnly() +``` + + + +### obj constant + + +#### fn constant.new + +```jsonnet +constant.new(name, value) +``` + +PARAMETERS: + +* **name** (`string`) +* **value** (`string`) + +`new` creates a hidden constant template variable. +#### obj constant.generalOptions + + +##### fn constant.generalOptions.withCurrent + +```jsonnet +constant.generalOptions.withCurrent(key, value="") +``` + +PARAMETERS: + +* **key** (`any`) +* **value** (`any`) + - default value: `""` + +`withCurrent` sets the currently selected value of a variable. If key and value are different, both need to be given. + +##### fn constant.generalOptions.withDescription + +```jsonnet +constant.generalOptions.withDescription(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn constant.generalOptions.withLabel + +```jsonnet +constant.generalOptions.withLabel(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn constant.generalOptions.withName + +```jsonnet +constant.generalOptions.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### obj constant.generalOptions.showOnDashboard + + +###### fn constant.generalOptions.showOnDashboard.withLabelAndValue + +```jsonnet +constant.generalOptions.showOnDashboard.withLabelAndValue() +``` + + + +###### fn constant.generalOptions.showOnDashboard.withNothing + +```jsonnet +constant.generalOptions.showOnDashboard.withNothing() +``` + + + +###### fn constant.generalOptions.showOnDashboard.withValueOnly + +```jsonnet +constant.generalOptions.showOnDashboard.withValueOnly() +``` + + + +### obj custom + + +#### fn custom.new + +```jsonnet +custom.new(name, values) +``` + +PARAMETERS: + +* **name** (`string`) +* **values** (`array`) + +`new` creates a custom template variable. + +The `values` array accepts an object with key/value keys, if it's not an object +then it will be added as a string. + +Example: +``` +[ + { key: 'mykey', value: 'myvalue' }, + 'myvalue', + 12, +] + +#### obj custom.generalOptions + + +##### fn custom.generalOptions.withCurrent + +```jsonnet +custom.generalOptions.withCurrent(key, value="") +``` + +PARAMETERS: + +* **key** (`any`) +* **value** (`any`) + - default value: `""` + +`withCurrent` sets the currently selected value of a variable. If key and value are different, both need to be given. + +##### fn custom.generalOptions.withDescription + +```jsonnet +custom.generalOptions.withDescription(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn custom.generalOptions.withLabel + +```jsonnet +custom.generalOptions.withLabel(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn custom.generalOptions.withName + +```jsonnet +custom.generalOptions.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### obj custom.generalOptions.showOnDashboard + + +###### fn custom.generalOptions.showOnDashboard.withLabelAndValue + +```jsonnet +custom.generalOptions.showOnDashboard.withLabelAndValue() +``` + + + +###### fn custom.generalOptions.showOnDashboard.withNothing + +```jsonnet +custom.generalOptions.showOnDashboard.withNothing() +``` + + + +###### fn custom.generalOptions.showOnDashboard.withValueOnly + +```jsonnet +custom.generalOptions.showOnDashboard.withValueOnly() +``` + + + +#### obj custom.selectionOptions + + +##### fn custom.selectionOptions.withIncludeAll + +```jsonnet +custom.selectionOptions.withIncludeAll(value=true, customAllValue) +``` + +PARAMETERS: + +* **value** (`bool`) + - default value: `true` +* **customAllValue** (`bool`) + +`withIncludeAll` enables an option to include all variables. + +Optionally you can set a `customAllValue`. + +##### fn custom.selectionOptions.withMulti + +```jsonnet +custom.selectionOptions.withMulti(value=true) +``` + +PARAMETERS: + +* **value** (`bool`) + - default value: `true` + +Enable selecting multiple values. +### obj datasource + + +#### fn datasource.new + +```jsonnet +datasource.new(name, type) +``` + +PARAMETERS: + +* **name** (`string`) +* **type** (`string`) + +`new` creates a datasource template variable. +#### fn datasource.withRegex + +```jsonnet +datasource.withRegex(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`withRegex` filter for which data source instances to choose from in the +variable value list. Example: `/^prod/` + +#### obj datasource.generalOptions + + +##### fn datasource.generalOptions.withCurrent + +```jsonnet +datasource.generalOptions.withCurrent(key, value="") +``` + +PARAMETERS: + +* **key** (`any`) +* **value** (`any`) + - default value: `""` + +`withCurrent` sets the currently selected value of a variable. If key and value are different, both need to be given. + +##### fn datasource.generalOptions.withDescription + +```jsonnet +datasource.generalOptions.withDescription(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn datasource.generalOptions.withLabel + +```jsonnet +datasource.generalOptions.withLabel(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn datasource.generalOptions.withName + +```jsonnet +datasource.generalOptions.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### obj datasource.generalOptions.showOnDashboard + + +###### fn datasource.generalOptions.showOnDashboard.withLabelAndValue + +```jsonnet +datasource.generalOptions.showOnDashboard.withLabelAndValue() +``` + + + +###### fn datasource.generalOptions.showOnDashboard.withNothing + +```jsonnet +datasource.generalOptions.showOnDashboard.withNothing() +``` + + + +###### fn datasource.generalOptions.showOnDashboard.withValueOnly + +```jsonnet +datasource.generalOptions.showOnDashboard.withValueOnly() +``` + + + +#### obj datasource.selectionOptions + + +##### fn datasource.selectionOptions.withIncludeAll + +```jsonnet +datasource.selectionOptions.withIncludeAll(value=true, customAllValue) +``` + +PARAMETERS: + +* **value** (`bool`) + - default value: `true` +* **customAllValue** (`bool`) + +`withIncludeAll` enables an option to include all variables. + +Optionally you can set a `customAllValue`. + +##### fn datasource.selectionOptions.withMulti + +```jsonnet +datasource.selectionOptions.withMulti(value=true) +``` + +PARAMETERS: + +* **value** (`bool`) + - default value: `true` + +Enable selecting multiple values. +### obj interval + + +#### fn interval.new + +```jsonnet +interval.new(name, values) +``` + +PARAMETERS: + +* **name** (`string`) +* **values** (`array`) + +`new` creates an interval template variable. +#### fn interval.withAutoOption + +```jsonnet +interval.withAutoOption(count, minInterval) +``` + +PARAMETERS: + +* **count** (`number`) +* **minInterval** (`string`) + +`withAutoOption` adds an options to dynamically calculate interval by dividing +time range by the count specified. + +`minInterval' has to be either unit-less or end with one of the following units: +"y, M, w, d, h, m, s, ms". + +#### obj interval.generalOptions + + +##### fn interval.generalOptions.withCurrent + +```jsonnet +interval.generalOptions.withCurrent(key, value="") +``` + +PARAMETERS: + +* **key** (`any`) +* **value** (`any`) + - default value: `""` + +`withCurrent` sets the currently selected value of a variable. If key and value are different, both need to be given. + +##### fn interval.generalOptions.withDescription + +```jsonnet +interval.generalOptions.withDescription(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn interval.generalOptions.withLabel + +```jsonnet +interval.generalOptions.withLabel(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn interval.generalOptions.withName + +```jsonnet +interval.generalOptions.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### obj interval.generalOptions.showOnDashboard + + +###### fn interval.generalOptions.showOnDashboard.withLabelAndValue + +```jsonnet +interval.generalOptions.showOnDashboard.withLabelAndValue() +``` + + + +###### fn interval.generalOptions.showOnDashboard.withNothing + +```jsonnet +interval.generalOptions.showOnDashboard.withNothing() +``` + + + +###### fn interval.generalOptions.showOnDashboard.withValueOnly + +```jsonnet +interval.generalOptions.showOnDashboard.withValueOnly() +``` + + + +### obj query + + +#### fn query.new + +```jsonnet +query.new(name, query="") +``` + +PARAMETERS: + +* **name** (`string`) +* **query** (`string`) + - default value: `""` + +Create a query template variable. + +`query` argument is optional, this can also be set with `query.queryTypes`. + +#### fn query.withDatasource + +```jsonnet +query.withDatasource(type, uid) +``` + +PARAMETERS: + +* **type** (`string`) +* **uid** (`string`) + +Select a datasource for the variable template query. +#### fn query.withDatasourceFromVariable + +```jsonnet +query.withDatasourceFromVariable(variable) +``` + +PARAMETERS: + +* **variable** (`object`) + +Select the datasource from another template variable. +#### fn query.withRegex + +```jsonnet +query.withRegex(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`withRegex` can extract part of a series name or metric node segment. Named +capture groups can be used to separate the display text and value +([see examples](https://grafana.com/docs/grafana/latest/variables/filter-variables-with-regex#filter-and-modify-using-named-text-and-value-capture-groups)). + +#### fn query.withSort + +```jsonnet +query.withSort(i=0, type="alphabetical", asc=true, caseInsensitive=false) +``` + +PARAMETERS: + +* **i** (`number`) + - default value: `0` +* **type** (`string`) + - default value: `"alphabetical"` +* **asc** (`bool`) + - default value: `true` +* **caseInsensitive** (`bool`) + - default value: `false` + +Choose how to sort the values in the dropdown. + +This can be called as `withSort() to use the integer values for each +option. If `i==0` then it will be ignored and the other arguments will take +precedence. + +The numerical values are: + +- 1 - Alphabetical (asc) +- 2 - Alphabetical (desc) +- 3 - Numerical (asc) +- 4 - Numerical (desc) +- 5 - Alphabetical (case-insensitive, asc) +- 6 - Alphabetical (case-insensitive, desc) + +#### obj query.generalOptions + + +##### fn query.generalOptions.withCurrent + +```jsonnet +query.generalOptions.withCurrent(key, value="") +``` + +PARAMETERS: + +* **key** (`any`) +* **value** (`any`) + - default value: `""` + +`withCurrent` sets the currently selected value of a variable. If key and value are different, both need to be given. + +##### fn query.generalOptions.withDescription + +```jsonnet +query.generalOptions.withDescription(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn query.generalOptions.withLabel + +```jsonnet +query.generalOptions.withLabel(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn query.generalOptions.withName + +```jsonnet +query.generalOptions.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### obj query.generalOptions.showOnDashboard + + +###### fn query.generalOptions.showOnDashboard.withLabelAndValue + +```jsonnet +query.generalOptions.showOnDashboard.withLabelAndValue() +``` + + + +###### fn query.generalOptions.showOnDashboard.withNothing + +```jsonnet +query.generalOptions.showOnDashboard.withNothing() +``` + + + +###### fn query.generalOptions.showOnDashboard.withValueOnly + +```jsonnet +query.generalOptions.showOnDashboard.withValueOnly() +``` + + + +#### obj query.queryTypes + + +##### fn query.queryTypes.withLabelValues + +```jsonnet +query.queryTypes.withLabelValues(label, metric="") +``` + +PARAMETERS: + +* **label** (`string`) +* **metric** (`string`) + - default value: `""` + +Construct a Prometheus template variable using `label_values()`. +#### obj query.refresh + + +##### fn query.refresh.onLoad + +```jsonnet +query.refresh.onLoad() +``` + + +Refresh label values on dashboard load. +##### fn query.refresh.onTime + +```jsonnet +query.refresh.onTime() +``` + + +Refresh label values on time range change. +#### obj query.selectionOptions + + +##### fn query.selectionOptions.withIncludeAll + +```jsonnet +query.selectionOptions.withIncludeAll(value=true, customAllValue) +``` + +PARAMETERS: + +* **value** (`bool`) + - default value: `true` +* **customAllValue** (`bool`) + +`withIncludeAll` enables an option to include all variables. + +Optionally you can set a `customAllValue`. + +##### fn query.selectionOptions.withMulti + +```jsonnet +query.selectionOptions.withMulti(value=true) +``` + +PARAMETERS: + +* **value** (`bool`) + - default value: `true` + +Enable selecting multiple values. +### obj textbox + + +#### fn textbox.new + +```jsonnet +textbox.new(name, default="") +``` + +PARAMETERS: + +* **name** (`string`) +* **default** (`string`) + - default value: `""` + +`new` creates a textbox template variable. +#### obj textbox.generalOptions + + +##### fn textbox.generalOptions.withCurrent + +```jsonnet +textbox.generalOptions.withCurrent(key, value="") +``` + +PARAMETERS: + +* **key** (`any`) +* **value** (`any`) + - default value: `""` + +`withCurrent` sets the currently selected value of a variable. If key and value are different, both need to be given. + +##### fn textbox.generalOptions.withDescription + +```jsonnet +textbox.generalOptions.withDescription(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn textbox.generalOptions.withLabel + +```jsonnet +textbox.generalOptions.withLabel(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn textbox.generalOptions.withName + +```jsonnet +textbox.generalOptions.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### obj textbox.generalOptions.showOnDashboard + + +###### fn textbox.generalOptions.showOnDashboard.withLabelAndValue + +```jsonnet +textbox.generalOptions.showOnDashboard.withLabelAndValue() +``` + + + +###### fn textbox.generalOptions.showOnDashboard.withNothing + +```jsonnet +textbox.generalOptions.showOnDashboard.withNothing() +``` + + + +###### fn textbox.generalOptions.showOnDashboard.withValueOnly + +```jsonnet +textbox.generalOptions.showOnDashboard.withValueOnly() +``` + + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/librarypanel.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/librarypanel.md new file mode 100644 index 0000000000..c4244ce4ba --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/librarypanel.md @@ -0,0 +1,334 @@ +# librarypanel + +grafonnet.librarypanel + +## Index + +* [`fn withDescription(value)`](#fn-withdescription) +* [`fn withFolderUid(value)`](#fn-withfolderuid) +* [`fn withMeta(value)`](#fn-withmeta) +* [`fn withMetaMixin(value)`](#fn-withmetamixin) +* [`fn withModel(value)`](#fn-withmodel) +* [`fn withModelMixin(value)`](#fn-withmodelmixin) +* [`fn withName(value)`](#fn-withname) +* [`fn withSchemaVersion(value)`](#fn-withschemaversion) +* [`fn withType(value)`](#fn-withtype) +* [`fn withUid(value)`](#fn-withuid) +* [`fn withVersion(value)`](#fn-withversion) +* [`obj meta`](#obj-meta) + * [`fn withConnectedDashboards(value)`](#fn-metawithconnecteddashboards) + * [`fn withCreated(value)`](#fn-metawithcreated) + * [`fn withCreatedBy(value)`](#fn-metawithcreatedby) + * [`fn withCreatedByMixin(value)`](#fn-metawithcreatedbymixin) + * [`fn withFolderName(value)`](#fn-metawithfoldername) + * [`fn withFolderUid(value)`](#fn-metawithfolderuid) + * [`fn withUpdated(value)`](#fn-metawithupdated) + * [`fn withUpdatedBy(value)`](#fn-metawithupdatedby) + * [`fn withUpdatedByMixin(value)`](#fn-metawithupdatedbymixin) + * [`obj createdBy`](#obj-metacreatedby) + * [`fn withAvatarUrl(value)`](#fn-metacreatedbywithavatarurl) + * [`fn withId(value)`](#fn-metacreatedbywithid) + * [`fn withName(value)`](#fn-metacreatedbywithname) + * [`obj updatedBy`](#obj-metaupdatedby) + * [`fn withAvatarUrl(value)`](#fn-metaupdatedbywithavatarurl) + * [`fn withId(value)`](#fn-metaupdatedbywithid) + * [`fn withName(value)`](#fn-metaupdatedbywithname) + +## Fields + +### fn withDescription + +```jsonnet +withDescription(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Panel description +### fn withFolderUid + +```jsonnet +withFolderUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Folder UID +### fn withMeta + +```jsonnet +withMeta(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withMetaMixin + +```jsonnet +withMetaMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withModel + +```jsonnet +withModel(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO: should be the same panel schema defined in dashboard +Typescript: Omit; +### fn withModelMixin + +```jsonnet +withModelMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO: should be the same panel schema defined in dashboard +Typescript: Omit; +### fn withName + +```jsonnet +withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Panel name (also saved in the model) +### fn withSchemaVersion + +```jsonnet +withSchemaVersion(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Dashboard version when this was saved (zero if unknown) +### fn withType + +```jsonnet +withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The panel type (from inside the model) +### fn withUid + +```jsonnet +withUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Library element UID +### fn withVersion + +```jsonnet +withVersion(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +panel version, incremented each time the dashboard is updated. +### obj meta + + +#### fn meta.withConnectedDashboards + +```jsonnet +meta.withConnectedDashboards(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +#### fn meta.withCreated + +```jsonnet +meta.withCreated(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn meta.withCreatedBy + +```jsonnet +meta.withCreatedBy(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn meta.withCreatedByMixin + +```jsonnet +meta.withCreatedByMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn meta.withFolderName + +```jsonnet +meta.withFolderName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn meta.withFolderUid + +```jsonnet +meta.withFolderUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn meta.withUpdated + +```jsonnet +meta.withUpdated(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn meta.withUpdatedBy + +```jsonnet +meta.withUpdatedBy(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn meta.withUpdatedByMixin + +```jsonnet +meta.withUpdatedByMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### obj meta.createdBy + + +##### fn meta.createdBy.withAvatarUrl + +```jsonnet +meta.createdBy.withAvatarUrl(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn meta.createdBy.withId + +```jsonnet +meta.createdBy.withId(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +##### fn meta.createdBy.withName + +```jsonnet +meta.createdBy.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj meta.updatedBy + + +##### fn meta.updatedBy.withAvatarUrl + +```jsonnet +meta.updatedBy.withAvatarUrl(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn meta.updatedBy.withId + +```jsonnet +meta.updatedBy.withId(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +##### fn meta.updatedBy.withName + +```jsonnet +meta.updatedBy.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/alertGroups/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/alertGroups/index.md new file mode 100644 index 0000000000..1c3e3945db --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/alertGroups/index.md @@ -0,0 +1,605 @@ +# alertGroups + +grafonnet.panel.alertGroups + +## Subpackages + +* [panelOptions.link](panelOptions/link.md) +* [queryOptions.transformation](queryOptions/transformation.md) +* [standardOptions.mapping](standardOptions/mapping.md) +* [standardOptions.override](standardOptions/override.md) +* [standardOptions.threshold.step](standardOptions/threshold/step.md) + +## Index + +* [`fn new(title)`](#fn-new) +* [`obj libraryPanel`](#obj-librarypanel) + * [`fn withName(value)`](#fn-librarypanelwithname) + * [`fn withUid(value)`](#fn-librarypanelwithuid) +* [`obj options`](#obj-options) + * [`fn withAlertmanager(value)`](#fn-optionswithalertmanager) + * [`fn withExpandAll(value=true)`](#fn-optionswithexpandall) + * [`fn withLabels(value)`](#fn-optionswithlabels) +* [`obj panelOptions`](#obj-paneloptions) + * [`fn withDescription(value)`](#fn-paneloptionswithdescription) + * [`fn withGridPos(h="null", w="null", x="null", y="null")`](#fn-paneloptionswithgridpos) + * [`fn withLinks(value)`](#fn-paneloptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-paneloptionswithlinksmixin) + * [`fn withRepeat(value)`](#fn-paneloptionswithrepeat) + * [`fn withRepeatDirection(value="h")`](#fn-paneloptionswithrepeatdirection) + * [`fn withTitle(value)`](#fn-paneloptionswithtitle) + * [`fn withTransparent(value=true)`](#fn-paneloptionswithtransparent) +* [`obj queryOptions`](#obj-queryoptions) + * [`fn withDatasource(type, uid)`](#fn-queryoptionswithdatasource) + * [`fn withDatasourceMixin(value)`](#fn-queryoptionswithdatasourcemixin) + * [`fn withInterval(value)`](#fn-queryoptionswithinterval) + * [`fn withMaxDataPoints(value)`](#fn-queryoptionswithmaxdatapoints) + * [`fn withTargets(value)`](#fn-queryoptionswithtargets) + * [`fn withTargetsMixin(value)`](#fn-queryoptionswithtargetsmixin) + * [`fn withTimeFrom(value)`](#fn-queryoptionswithtimefrom) + * [`fn withTimeShift(value)`](#fn-queryoptionswithtimeshift) + * [`fn withTransformations(value)`](#fn-queryoptionswithtransformations) + * [`fn withTransformationsMixin(value)`](#fn-queryoptionswithtransformationsmixin) +* [`obj standardOptions`](#obj-standardoptions) + * [`fn withDecimals(value)`](#fn-standardoptionswithdecimals) + * [`fn withDisplayName(value)`](#fn-standardoptionswithdisplayname) + * [`fn withFilterable(value=true)`](#fn-standardoptionswithfilterable) + * [`fn withLinks(value)`](#fn-standardoptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-standardoptionswithlinksmixin) + * [`fn withMappings(value)`](#fn-standardoptionswithmappings) + * [`fn withMappingsMixin(value)`](#fn-standardoptionswithmappingsmixin) + * [`fn withMax(value)`](#fn-standardoptionswithmax) + * [`fn withMin(value)`](#fn-standardoptionswithmin) + * [`fn withNoValue(value)`](#fn-standardoptionswithnovalue) + * [`fn withOverrides(value)`](#fn-standardoptionswithoverrides) + * [`fn withOverridesMixin(value)`](#fn-standardoptionswithoverridesmixin) + * [`fn withPath(value)`](#fn-standardoptionswithpath) + * [`fn withUnit(value)`](#fn-standardoptionswithunit) + * [`obj color`](#obj-standardoptionscolor) + * [`fn withFixedColor(value)`](#fn-standardoptionscolorwithfixedcolor) + * [`fn withMode(value)`](#fn-standardoptionscolorwithmode) + * [`fn withSeriesBy(value)`](#fn-standardoptionscolorwithseriesby) + * [`obj thresholds`](#obj-standardoptionsthresholds) + * [`fn withMode(value)`](#fn-standardoptionsthresholdswithmode) + * [`fn withSteps(value)`](#fn-standardoptionsthresholdswithsteps) + * [`fn withStepsMixin(value)`](#fn-standardoptionsthresholdswithstepsmixin) + +## Fields + +### fn new + +```jsonnet +new(title) +``` + +PARAMETERS: + +* **title** (`string`) + +Creates a new alertGroups panel with a title. +### obj libraryPanel + + +#### fn libraryPanel.withName + +```jsonnet +libraryPanel.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn libraryPanel.withUid + +```jsonnet +libraryPanel.withUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj options + + +#### fn options.withAlertmanager + +```jsonnet +options.withAlertmanager(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of the alertmanager used as a source for alerts +#### fn options.withExpandAll + +```jsonnet +options.withExpandAll(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Expand all alert groups by default +#### fn options.withLabels + +```jsonnet +options.withLabels(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Comma-separated list of values used to filter alert results +### obj panelOptions + + +#### fn panelOptions.withDescription + +```jsonnet +panelOptions.withDescription(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Description. +#### fn panelOptions.withGridPos + +```jsonnet +panelOptions.withGridPos(h="null", w="null", x="null", y="null") +``` + +PARAMETERS: + +* **h** (`number`) + - default value: `"null"` +* **w** (`number`) + - default value: `"null"` +* **x** (`number`) + - default value: `"null"` +* **y** (`number`) + - default value: `"null"` + +`withGridPos` configures the height, width and xy coordinates of the panel. Also see `grafonnet.util.grid` for helper functions to calculate these fields. + +All arguments default to `null`, which means they will remain unchanged or unset. + +#### fn panelOptions.withLinks + +```jsonnet +panelOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withLinksMixin + +```jsonnet +panelOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withRepeat + +```jsonnet +panelOptions.withRepeat(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of template variable to repeat for. +#### fn panelOptions.withRepeatDirection + +```jsonnet +panelOptions.withRepeatDirection(value="h") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"h"` + - valid values: `"h"`, `"v"` + +Direction to repeat in if 'repeat' is set. +"h" for horizontal, "v" for vertical. +TODO this is probably optional +#### fn panelOptions.withTitle + +```jsonnet +panelOptions.withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Panel title. +#### fn panelOptions.withTransparent + +```jsonnet +panelOptions.withTransparent(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Whether to display the panel without a background. +### obj queryOptions + + +#### fn queryOptions.withDatasource + +```jsonnet +queryOptions.withDatasource(type, uid) +``` + +PARAMETERS: + +* **type** (`string`) +* **uid** (`string`) + +`withDatasource` sets the datasource for all queries in a panel. + +The default datasource for a panel is set to 'Mixed datasource' so panels can be datasource agnostic, which is a lot more interesting from a reusability standpoint. Note that this requires query targets to explicitly set datasource for the same reason. + +#### fn queryOptions.withDatasourceMixin + +```jsonnet +queryOptions.withDatasourceMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +The datasource used in all targets. +#### fn queryOptions.withInterval + +```jsonnet +queryOptions.withInterval(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withMaxDataPoints + +```jsonnet +queryOptions.withMaxDataPoints(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +#### fn queryOptions.withTargets + +```jsonnet +queryOptions.withTargets(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTargetsMixin + +```jsonnet +queryOptions.withTargetsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTimeFrom + +```jsonnet +queryOptions.withTimeFrom(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTimeShift + +```jsonnet +queryOptions.withTimeShift(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTransformations + +```jsonnet +queryOptions.withTransformations(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn queryOptions.withTransformationsMixin + +```jsonnet +queryOptions.withTransformationsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### obj standardOptions + + +#### fn standardOptions.withDecimals + +```jsonnet +standardOptions.withDecimals(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Significant digits (for display) +#### fn standardOptions.withDisplayName + +```jsonnet +standardOptions.withDisplayName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The display value for this field. This supports template variables blank is auto +#### fn standardOptions.withFilterable + +```jsonnet +standardOptions.withFilterable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +True if data source field supports ad-hoc filters +#### fn standardOptions.withLinks + +```jsonnet +standardOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withLinksMixin + +```jsonnet +standardOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withMappings + +```jsonnet +standardOptions.withMappings(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMappingsMixin + +```jsonnet +standardOptions.withMappingsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMax + +```jsonnet +standardOptions.withMax(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withMin + +```jsonnet +standardOptions.withMin(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withNoValue + +```jsonnet +standardOptions.withNoValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Alternative to empty string +#### fn standardOptions.withOverrides + +```jsonnet +standardOptions.withOverrides(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withOverridesMixin + +```jsonnet +standardOptions.withOverridesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withPath + +```jsonnet +standardOptions.withPath(value) +``` + +PARAMETERS: + +* **value** (`string`) + +An explicit path to the field in the datasource. When the frame meta includes a path, +This will default to `${frame.meta.path}/${field.name} + +When defined, this value can be used as an identifier within the datasource scope, and +may be used to update the results +#### fn standardOptions.withUnit + +```jsonnet +standardOptions.withUnit(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Numeric Options +#### obj standardOptions.color + + +##### fn standardOptions.color.withFixedColor + +```jsonnet +standardOptions.color.withFixedColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Stores the fixed color value if mode is fixed +##### fn standardOptions.color.withMode + +```jsonnet +standardOptions.color.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The main color scheme mode +##### fn standardOptions.color.withSeriesBy + +```jsonnet +standardOptions.color.withSeriesBy(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"min"`, `"max"`, `"last"` + +TODO docs +#### obj standardOptions.thresholds + + +##### fn standardOptions.thresholds.withMode + +```jsonnet +standardOptions.thresholds.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"absolute"`, `"percentage"` + + +##### fn standardOptions.thresholds.withSteps + +```jsonnet +standardOptions.thresholds.withSteps(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity +##### fn standardOptions.thresholds.withStepsMixin + +```jsonnet +standardOptions.thresholds.withStepsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/alertGroups/panelOptions/link.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/alertGroups/panelOptions/link.md new file mode 100644 index 0000000000..106f9d2edb --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/alertGroups/panelOptions/link.md @@ -0,0 +1,145 @@ +# link + + + +## Index + +* [`fn withAsDropdown(value=true)`](#fn-withasdropdown) +* [`fn withIcon(value)`](#fn-withicon) +* [`fn withIncludeVars(value=true)`](#fn-withincludevars) +* [`fn withKeepTime(value=true)`](#fn-withkeeptime) +* [`fn withTags(value)`](#fn-withtags) +* [`fn withTagsMixin(value)`](#fn-withtagsmixin) +* [`fn withTargetBlank(value=true)`](#fn-withtargetblank) +* [`fn withTitle(value)`](#fn-withtitle) +* [`fn withTooltip(value)`](#fn-withtooltip) +* [`fn withType(value)`](#fn-withtype) +* [`fn withUrl(value)`](#fn-withurl) + +## Fields + +### fn withAsDropdown + +```jsonnet +withAsDropdown(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withIcon + +```jsonnet +withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withIncludeVars + +```jsonnet +withIncludeVars(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withKeepTime + +```jsonnet +withKeepTime(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTags + +```jsonnet +withTags(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTagsMixin + +```jsonnet +withTagsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTargetBlank + +```jsonnet +withTargetBlank(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTitle + +```jsonnet +withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withTooltip + +```jsonnet +withTooltip(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withType + +```jsonnet +withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"link"`, `"dashboards"` + +TODO docs +### fn withUrl + +```jsonnet +withUrl(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/alertGroups/queryOptions/transformation.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/alertGroups/queryOptions/transformation.md new file mode 100644 index 0000000000..dc832f653d --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/alertGroups/queryOptions/transformation.md @@ -0,0 +1,99 @@ +# transformation + + + +## Index + +* [`fn withDisabled(value=true)`](#fn-withdisabled) +* [`fn withFilter(value)`](#fn-withfilter) +* [`fn withFilterMixin(value)`](#fn-withfiltermixin) +* [`fn withId(value)`](#fn-withid) +* [`fn withOptions(value)`](#fn-withoptions) +* [`obj filter`](#obj-filter) + * [`fn withId(value="")`](#fn-filterwithid) + * [`fn withOptions(value)`](#fn-filterwithoptions) + +## Fields + +### fn withDisabled + +```jsonnet +withDisabled(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Disabled transformations are skipped +### fn withFilter + +```jsonnet +withFilter(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withFilterMixin + +```jsonnet +withFilterMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withId + +```jsonnet +withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Unique identifier of transformer +### fn withOptions + +```jsonnet +withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Options to be passed to the transformer +Valid options depend on the transformer id +### obj filter + + +#### fn filter.withId + +```jsonnet +filter.withId(value="") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `""` + + +#### fn filter.withOptions + +```jsonnet +filter.withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/alertGroups/standardOptions/mapping.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/alertGroups/standardOptions/mapping.md new file mode 100644 index 0000000000..93296972e8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/alertGroups/standardOptions/mapping.md @@ -0,0 +1,469 @@ +# mapping + + + +## Index + +* [`obj RangeMap`](#obj-rangemap) + * [`fn withOptions(value)`](#fn-rangemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-rangemapwithoptionsmixin) + * [`fn withType(value)`](#fn-rangemapwithtype) + * [`obj options`](#obj-rangemapoptions) + * [`fn withFrom(value)`](#fn-rangemapoptionswithfrom) + * [`fn withResult(value)`](#fn-rangemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-rangemapoptionswithresultmixin) + * [`fn withTo(value)`](#fn-rangemapoptionswithto) + * [`obj result`](#obj-rangemapoptionsresult) + * [`fn withColor(value)`](#fn-rangemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-rangemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-rangemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-rangemapoptionsresultwithtext) +* [`obj RegexMap`](#obj-regexmap) + * [`fn withOptions(value)`](#fn-regexmapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-regexmapwithoptionsmixin) + * [`fn withType(value)`](#fn-regexmapwithtype) + * [`obj options`](#obj-regexmapoptions) + * [`fn withPattern(value)`](#fn-regexmapoptionswithpattern) + * [`fn withResult(value)`](#fn-regexmapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-regexmapoptionswithresultmixin) + * [`obj result`](#obj-regexmapoptionsresult) + * [`fn withColor(value)`](#fn-regexmapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-regexmapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-regexmapoptionsresultwithindex) + * [`fn withText(value)`](#fn-regexmapoptionsresultwithtext) +* [`obj SpecialValueMap`](#obj-specialvaluemap) + * [`fn withOptions(value)`](#fn-specialvaluemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-specialvaluemapwithoptionsmixin) + * [`fn withType(value)`](#fn-specialvaluemapwithtype) + * [`obj options`](#obj-specialvaluemapoptions) + * [`fn withMatch(value)`](#fn-specialvaluemapoptionswithmatch) + * [`fn withPattern(value)`](#fn-specialvaluemapoptionswithpattern) + * [`fn withResult(value)`](#fn-specialvaluemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-specialvaluemapoptionswithresultmixin) + * [`obj result`](#obj-specialvaluemapoptionsresult) + * [`fn withColor(value)`](#fn-specialvaluemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-specialvaluemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-specialvaluemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-specialvaluemapoptionsresultwithtext) +* [`obj ValueMap`](#obj-valuemap) + * [`fn withOptions(value)`](#fn-valuemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-valuemapwithoptionsmixin) + * [`fn withType(value)`](#fn-valuemapwithtype) + +## Fields + +### obj RangeMap + + +#### fn RangeMap.withOptions + +```jsonnet +RangeMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withOptionsMixin + +```jsonnet +RangeMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withType + +```jsonnet +RangeMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RangeMap.options + + +##### fn RangeMap.options.withFrom + +```jsonnet +RangeMap.options.withFrom(value) +``` + +PARAMETERS: + +* **value** (`number`) + +to and from are `number | null` in current ts, really not sure what to do +##### fn RangeMap.options.withResult + +```jsonnet +RangeMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withResultMixin + +```jsonnet +RangeMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withTo + +```jsonnet +RangeMap.options.withTo(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +##### obj RangeMap.options.result + + +###### fn RangeMap.options.result.withColor + +```jsonnet +RangeMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIcon + +```jsonnet +RangeMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIndex + +```jsonnet +RangeMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RangeMap.options.result.withText + +```jsonnet +RangeMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj RegexMap + + +#### fn RegexMap.withOptions + +```jsonnet +RegexMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withOptionsMixin + +```jsonnet +RegexMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withType + +```jsonnet +RegexMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RegexMap.options + + +##### fn RegexMap.options.withPattern + +```jsonnet +RegexMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn RegexMap.options.withResult + +```jsonnet +RegexMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RegexMap.options.withResultMixin + +```jsonnet +RegexMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj RegexMap.options.result + + +###### fn RegexMap.options.result.withColor + +```jsonnet +RegexMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIcon + +```jsonnet +RegexMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIndex + +```jsonnet +RegexMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RegexMap.options.result.withText + +```jsonnet +RegexMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj SpecialValueMap + + +#### fn SpecialValueMap.withOptions + +```jsonnet +SpecialValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withOptionsMixin + +```jsonnet +SpecialValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withType + +```jsonnet +SpecialValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj SpecialValueMap.options + + +##### fn SpecialValueMap.options.withMatch + +```jsonnet +SpecialValueMap.options.withMatch(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"true"`, `"false"` + + +##### fn SpecialValueMap.options.withPattern + +```jsonnet +SpecialValueMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn SpecialValueMap.options.withResult + +```jsonnet +SpecialValueMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn SpecialValueMap.options.withResultMixin + +```jsonnet +SpecialValueMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj SpecialValueMap.options.result + + +###### fn SpecialValueMap.options.result.withColor + +```jsonnet +SpecialValueMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIcon + +```jsonnet +SpecialValueMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIndex + +```jsonnet +SpecialValueMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn SpecialValueMap.options.result.withText + +```jsonnet +SpecialValueMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj ValueMap + + +#### fn ValueMap.withOptions + +```jsonnet +ValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withOptionsMixin + +```jsonnet +ValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withType + +```jsonnet +ValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/alertGroups/standardOptions/override.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/alertGroups/standardOptions/override.md new file mode 100644 index 0000000000..154f3dbdac --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/alertGroups/standardOptions/override.md @@ -0,0 +1,244 @@ +# override + +Overrides allow you to customize visualization settings for specific fields or +series. This is accomplished by adding an override rule that targets +a particular set of fields and that can each define multiple options. + +```jsonnet +override.byType.new('number') ++ override.byType.withPropertiesFromOptions( + panel.standardOptions.withDecimals(2) + + panel.standardOptions.withUnit('s') +) +``` + + +## Index + +* [`obj byName`](#obj-byname) + * [`fn new(value)`](#fn-bynamenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bynamewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bynamewithproperty) +* [`obj byQuery`](#obj-byquery) + * [`fn new(value)`](#fn-byquerynew) + * [`fn withPropertiesFromOptions(options)`](#fn-byquerywithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byquerywithproperty) +* [`obj byRegexp`](#obj-byregexp) + * [`fn new(value)`](#fn-byregexpnew) + * [`fn withPropertiesFromOptions(options)`](#fn-byregexpwithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byregexpwithproperty) +* [`obj byType`](#obj-bytype) + * [`fn new(value)`](#fn-bytypenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bytypewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bytypewithproperty) +* [`obj byValue`](#obj-byvalue) + * [`fn new(value)`](#fn-byvaluenew) + * [`fn withPropertiesFromOptions(options)`](#fn-byvaluewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byvaluewithproperty) + +## Fields + +### obj byName + + +#### fn byName.new + +```jsonnet +byName.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byName`. +#### fn byName.withPropertiesFromOptions + +```jsonnet +byName.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byName.withProperty + +```jsonnet +byName.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byQuery + + +#### fn byQuery.new + +```jsonnet +byQuery.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byQuery`. +#### fn byQuery.withPropertiesFromOptions + +```jsonnet +byQuery.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byQuery.withProperty + +```jsonnet +byQuery.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byRegexp + + +#### fn byRegexp.new + +```jsonnet +byRegexp.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byRegexp`. +#### fn byRegexp.withPropertiesFromOptions + +```jsonnet +byRegexp.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byRegexp.withProperty + +```jsonnet +byRegexp.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byType + + +#### fn byType.new + +```jsonnet +byType.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byType`. +#### fn byType.withPropertiesFromOptions + +```jsonnet +byType.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byType.withProperty + +```jsonnet +byType.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byValue + + +#### fn byValue.new + +```jsonnet +byValue.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byValue`. +#### fn byValue.withPropertiesFromOptions + +```jsonnet +byValue.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byValue.withProperty + +```jsonnet +byValue.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/alertGroups/standardOptions/threshold/step.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/alertGroups/standardOptions/threshold/step.md new file mode 100644 index 0000000000..dd2dd227ff --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/alertGroups/standardOptions/threshold/step.md @@ -0,0 +1,60 @@ +# threshold.step + + + +## Index + +* [`fn withColor(value)`](#fn-withcolor) +* [`fn withIndex(value)`](#fn-withindex) +* [`fn withState(value)`](#fn-withstate) +* [`fn withValue(value)`](#fn-withvalue) + +## Fields + +### fn withColor + +```jsonnet +withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +### fn withIndex + +```jsonnet +withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Threshold index, an old property that is not needed an should only appear in older dashboards +### fn withState + +```jsonnet +withState(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO are the values here enumerable into a disjunction? +Some seem to be listed in typescript comment +### fn withValue + +```jsonnet +withValue(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +FIXME the corresponding typescript field is required/non-optional, but nulls currently appear here when serializing -Infinity to JSON \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/alertList/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/alertList/index.md new file mode 100644 index 0000000000..e02b39b6cd --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/alertList/index.md @@ -0,0 +1,1136 @@ +# alertList + +grafonnet.panel.alertList + +## Subpackages + +* [panelOptions.link](panelOptions/link.md) +* [queryOptions.transformation](queryOptions/transformation.md) +* [standardOptions.mapping](standardOptions/mapping.md) +* [standardOptions.override](standardOptions/override.md) +* [standardOptions.threshold.step](standardOptions/threshold/step.md) + +## Index + +* [`fn new(title)`](#fn-new) +* [`obj libraryPanel`](#obj-librarypanel) + * [`fn withName(value)`](#fn-librarypanelwithname) + * [`fn withUid(value)`](#fn-librarypanelwithuid) +* [`obj options`](#obj-options) + * [`fn withAlertListOptions(value)`](#fn-optionswithalertlistoptions) + * [`fn withAlertListOptionsMixin(value)`](#fn-optionswithalertlistoptionsmixin) + * [`fn withUnifiedAlertListOptions(value)`](#fn-optionswithunifiedalertlistoptions) + * [`fn withUnifiedAlertListOptionsMixin(value)`](#fn-optionswithunifiedalertlistoptionsmixin) + * [`obj AlertListOptions`](#obj-optionsalertlistoptions) + * [`fn withAlertName(value)`](#fn-optionsalertlistoptionswithalertname) + * [`fn withDashboardAlerts(value=true)`](#fn-optionsalertlistoptionswithdashboardalerts) + * [`fn withDashboardTitle(value)`](#fn-optionsalertlistoptionswithdashboardtitle) + * [`fn withFolderId(value)`](#fn-optionsalertlistoptionswithfolderid) + * [`fn withMaxItems(value)`](#fn-optionsalertlistoptionswithmaxitems) + * [`fn withShowOptions(value)`](#fn-optionsalertlistoptionswithshowoptions) + * [`fn withSortOrder(value)`](#fn-optionsalertlistoptionswithsortorder) + * [`fn withStateFilter(value)`](#fn-optionsalertlistoptionswithstatefilter) + * [`fn withStateFilterMixin(value)`](#fn-optionsalertlistoptionswithstatefiltermixin) + * [`fn withTags(value)`](#fn-optionsalertlistoptionswithtags) + * [`fn withTagsMixin(value)`](#fn-optionsalertlistoptionswithtagsmixin) + * [`obj stateFilter`](#obj-optionsalertlistoptionsstatefilter) + * [`fn withAlerting(value=true)`](#fn-optionsalertlistoptionsstatefilterwithalerting) + * [`fn withExecutionError(value=true)`](#fn-optionsalertlistoptionsstatefilterwithexecutionerror) + * [`fn withNoData(value=true)`](#fn-optionsalertlistoptionsstatefilterwithnodata) + * [`fn withOk(value=true)`](#fn-optionsalertlistoptionsstatefilterwithok) + * [`fn withPaused(value=true)`](#fn-optionsalertlistoptionsstatefilterwithpaused) + * [`fn withPending(value=true)`](#fn-optionsalertlistoptionsstatefilterwithpending) + * [`obj UnifiedAlertListOptions`](#obj-optionsunifiedalertlistoptions) + * [`fn withAlertInstanceLabelFilter(value)`](#fn-optionsunifiedalertlistoptionswithalertinstancelabelfilter) + * [`fn withAlertName(value)`](#fn-optionsunifiedalertlistoptionswithalertname) + * [`fn withDashboardAlerts(value=true)`](#fn-optionsunifiedalertlistoptionswithdashboardalerts) + * [`fn withDatasource(value)`](#fn-optionsunifiedalertlistoptionswithdatasource) + * [`fn withFolder(value)`](#fn-optionsunifiedalertlistoptionswithfolder) + * [`fn withFolderMixin(value)`](#fn-optionsunifiedalertlistoptionswithfoldermixin) + * [`fn withGroupBy(value)`](#fn-optionsunifiedalertlistoptionswithgroupby) + * [`fn withGroupByMixin(value)`](#fn-optionsunifiedalertlistoptionswithgroupbymixin) + * [`fn withGroupMode(value)`](#fn-optionsunifiedalertlistoptionswithgroupmode) + * [`fn withMaxItems(value)`](#fn-optionsunifiedalertlistoptionswithmaxitems) + * [`fn withShowInstances(value=true)`](#fn-optionsunifiedalertlistoptionswithshowinstances) + * [`fn withSortOrder(value)`](#fn-optionsunifiedalertlistoptionswithsortorder) + * [`fn withStateFilter(value)`](#fn-optionsunifiedalertlistoptionswithstatefilter) + * [`fn withStateFilterMixin(value)`](#fn-optionsunifiedalertlistoptionswithstatefiltermixin) + * [`fn withViewMode(value)`](#fn-optionsunifiedalertlistoptionswithviewmode) + * [`obj folder`](#obj-optionsunifiedalertlistoptionsfolder) + * [`fn withId(value)`](#fn-optionsunifiedalertlistoptionsfolderwithid) + * [`fn withTitle(value)`](#fn-optionsunifiedalertlistoptionsfolderwithtitle) + * [`obj stateFilter`](#obj-optionsunifiedalertlistoptionsstatefilter) + * [`fn withError(value=true)`](#fn-optionsunifiedalertlistoptionsstatefilterwitherror) + * [`fn withFiring(value=true)`](#fn-optionsunifiedalertlistoptionsstatefilterwithfiring) + * [`fn withInactive(value=true)`](#fn-optionsunifiedalertlistoptionsstatefilterwithinactive) + * [`fn withNoData(value=true)`](#fn-optionsunifiedalertlistoptionsstatefilterwithnodata) + * [`fn withNormal(value=true)`](#fn-optionsunifiedalertlistoptionsstatefilterwithnormal) + * [`fn withPending(value=true)`](#fn-optionsunifiedalertlistoptionsstatefilterwithpending) +* [`obj panelOptions`](#obj-paneloptions) + * [`fn withDescription(value)`](#fn-paneloptionswithdescription) + * [`fn withGridPos(h="null", w="null", x="null", y="null")`](#fn-paneloptionswithgridpos) + * [`fn withLinks(value)`](#fn-paneloptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-paneloptionswithlinksmixin) + * [`fn withRepeat(value)`](#fn-paneloptionswithrepeat) + * [`fn withRepeatDirection(value="h")`](#fn-paneloptionswithrepeatdirection) + * [`fn withTitle(value)`](#fn-paneloptionswithtitle) + * [`fn withTransparent(value=true)`](#fn-paneloptionswithtransparent) +* [`obj queryOptions`](#obj-queryoptions) + * [`fn withDatasource(type, uid)`](#fn-queryoptionswithdatasource) + * [`fn withDatasourceMixin(value)`](#fn-queryoptionswithdatasourcemixin) + * [`fn withInterval(value)`](#fn-queryoptionswithinterval) + * [`fn withMaxDataPoints(value)`](#fn-queryoptionswithmaxdatapoints) + * [`fn withTargets(value)`](#fn-queryoptionswithtargets) + * [`fn withTargetsMixin(value)`](#fn-queryoptionswithtargetsmixin) + * [`fn withTimeFrom(value)`](#fn-queryoptionswithtimefrom) + * [`fn withTimeShift(value)`](#fn-queryoptionswithtimeshift) + * [`fn withTransformations(value)`](#fn-queryoptionswithtransformations) + * [`fn withTransformationsMixin(value)`](#fn-queryoptionswithtransformationsmixin) +* [`obj standardOptions`](#obj-standardoptions) + * [`fn withDecimals(value)`](#fn-standardoptionswithdecimals) + * [`fn withDisplayName(value)`](#fn-standardoptionswithdisplayname) + * [`fn withFilterable(value=true)`](#fn-standardoptionswithfilterable) + * [`fn withLinks(value)`](#fn-standardoptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-standardoptionswithlinksmixin) + * [`fn withMappings(value)`](#fn-standardoptionswithmappings) + * [`fn withMappingsMixin(value)`](#fn-standardoptionswithmappingsmixin) + * [`fn withMax(value)`](#fn-standardoptionswithmax) + * [`fn withMin(value)`](#fn-standardoptionswithmin) + * [`fn withNoValue(value)`](#fn-standardoptionswithnovalue) + * [`fn withOverrides(value)`](#fn-standardoptionswithoverrides) + * [`fn withOverridesMixin(value)`](#fn-standardoptionswithoverridesmixin) + * [`fn withPath(value)`](#fn-standardoptionswithpath) + * [`fn withUnit(value)`](#fn-standardoptionswithunit) + * [`obj color`](#obj-standardoptionscolor) + * [`fn withFixedColor(value)`](#fn-standardoptionscolorwithfixedcolor) + * [`fn withMode(value)`](#fn-standardoptionscolorwithmode) + * [`fn withSeriesBy(value)`](#fn-standardoptionscolorwithseriesby) + * [`obj thresholds`](#obj-standardoptionsthresholds) + * [`fn withMode(value)`](#fn-standardoptionsthresholdswithmode) + * [`fn withSteps(value)`](#fn-standardoptionsthresholdswithsteps) + * [`fn withStepsMixin(value)`](#fn-standardoptionsthresholdswithstepsmixin) + +## Fields + +### fn new + +```jsonnet +new(title) +``` + +PARAMETERS: + +* **title** (`string`) + +Creates a new alertlist panel with a title. +### obj libraryPanel + + +#### fn libraryPanel.withName + +```jsonnet +libraryPanel.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn libraryPanel.withUid + +```jsonnet +libraryPanel.withUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj options + + +#### fn options.withAlertListOptions + +```jsonnet +options.withAlertListOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn options.withAlertListOptionsMixin + +```jsonnet +options.withAlertListOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn options.withUnifiedAlertListOptions + +```jsonnet +options.withUnifiedAlertListOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn options.withUnifiedAlertListOptionsMixin + +```jsonnet +options.withUnifiedAlertListOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### obj options.AlertListOptions + + +##### fn options.AlertListOptions.withAlertName + +```jsonnet +options.AlertListOptions.withAlertName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn options.AlertListOptions.withDashboardAlerts + +```jsonnet +options.AlertListOptions.withDashboardAlerts(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.AlertListOptions.withDashboardTitle + +```jsonnet +options.AlertListOptions.withDashboardTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn options.AlertListOptions.withFolderId + +```jsonnet +options.AlertListOptions.withFolderId(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +##### fn options.AlertListOptions.withMaxItems + +```jsonnet +options.AlertListOptions.withMaxItems(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +##### fn options.AlertListOptions.withShowOptions + +```jsonnet +options.AlertListOptions.withShowOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"current"`, `"changes"` + + +##### fn options.AlertListOptions.withSortOrder + +```jsonnet +options.AlertListOptions.withSortOrder(value) +``` + +PARAMETERS: + +* **value** (`number`) + - valid values: `1`, `2`, `3`, `4`, `5` + + +##### fn options.AlertListOptions.withStateFilter + +```jsonnet +options.AlertListOptions.withStateFilter(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn options.AlertListOptions.withStateFilterMixin + +```jsonnet +options.AlertListOptions.withStateFilterMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn options.AlertListOptions.withTags + +```jsonnet +options.AlertListOptions.withTags(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +##### fn options.AlertListOptions.withTagsMixin + +```jsonnet +options.AlertListOptions.withTagsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +##### obj options.AlertListOptions.stateFilter + + +###### fn options.AlertListOptions.stateFilter.withAlerting + +```jsonnet +options.AlertListOptions.stateFilter.withAlerting(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +###### fn options.AlertListOptions.stateFilter.withExecutionError + +```jsonnet +options.AlertListOptions.stateFilter.withExecutionError(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +###### fn options.AlertListOptions.stateFilter.withNoData + +```jsonnet +options.AlertListOptions.stateFilter.withNoData(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +###### fn options.AlertListOptions.stateFilter.withOk + +```jsonnet +options.AlertListOptions.stateFilter.withOk(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +###### fn options.AlertListOptions.stateFilter.withPaused + +```jsonnet +options.AlertListOptions.stateFilter.withPaused(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +###### fn options.AlertListOptions.stateFilter.withPending + +```jsonnet +options.AlertListOptions.stateFilter.withPending(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +#### obj options.UnifiedAlertListOptions + + +##### fn options.UnifiedAlertListOptions.withAlertInstanceLabelFilter + +```jsonnet +options.UnifiedAlertListOptions.withAlertInstanceLabelFilter(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn options.UnifiedAlertListOptions.withAlertName + +```jsonnet +options.UnifiedAlertListOptions.withAlertName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn options.UnifiedAlertListOptions.withDashboardAlerts + +```jsonnet +options.UnifiedAlertListOptions.withDashboardAlerts(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.UnifiedAlertListOptions.withDatasource + +```jsonnet +options.UnifiedAlertListOptions.withDatasource(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn options.UnifiedAlertListOptions.withFolder + +```jsonnet +options.UnifiedAlertListOptions.withFolder(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn options.UnifiedAlertListOptions.withFolderMixin + +```jsonnet +options.UnifiedAlertListOptions.withFolderMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn options.UnifiedAlertListOptions.withGroupBy + +```jsonnet +options.UnifiedAlertListOptions.withGroupBy(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +##### fn options.UnifiedAlertListOptions.withGroupByMixin + +```jsonnet +options.UnifiedAlertListOptions.withGroupByMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +##### fn options.UnifiedAlertListOptions.withGroupMode + +```jsonnet +options.UnifiedAlertListOptions.withGroupMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"default"`, `"custom"` + + +##### fn options.UnifiedAlertListOptions.withMaxItems + +```jsonnet +options.UnifiedAlertListOptions.withMaxItems(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +##### fn options.UnifiedAlertListOptions.withShowInstances + +```jsonnet +options.UnifiedAlertListOptions.withShowInstances(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.UnifiedAlertListOptions.withSortOrder + +```jsonnet +options.UnifiedAlertListOptions.withSortOrder(value) +``` + +PARAMETERS: + +* **value** (`number`) + - valid values: `1`, `2`, `3`, `4`, `5` + + +##### fn options.UnifiedAlertListOptions.withStateFilter + +```jsonnet +options.UnifiedAlertListOptions.withStateFilter(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn options.UnifiedAlertListOptions.withStateFilterMixin + +```jsonnet +options.UnifiedAlertListOptions.withStateFilterMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn options.UnifiedAlertListOptions.withViewMode + +```jsonnet +options.UnifiedAlertListOptions.withViewMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"list"`, `"stat"` + + +##### obj options.UnifiedAlertListOptions.folder + + +###### fn options.UnifiedAlertListOptions.folder.withId + +```jsonnet +options.UnifiedAlertListOptions.folder.withId(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +###### fn options.UnifiedAlertListOptions.folder.withTitle + +```jsonnet +options.UnifiedAlertListOptions.folder.withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### obj options.UnifiedAlertListOptions.stateFilter + + +###### fn options.UnifiedAlertListOptions.stateFilter.withError + +```jsonnet +options.UnifiedAlertListOptions.stateFilter.withError(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +###### fn options.UnifiedAlertListOptions.stateFilter.withFiring + +```jsonnet +options.UnifiedAlertListOptions.stateFilter.withFiring(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +###### fn options.UnifiedAlertListOptions.stateFilter.withInactive + +```jsonnet +options.UnifiedAlertListOptions.stateFilter.withInactive(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +###### fn options.UnifiedAlertListOptions.stateFilter.withNoData + +```jsonnet +options.UnifiedAlertListOptions.stateFilter.withNoData(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +###### fn options.UnifiedAlertListOptions.stateFilter.withNormal + +```jsonnet +options.UnifiedAlertListOptions.stateFilter.withNormal(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +###### fn options.UnifiedAlertListOptions.stateFilter.withPending + +```jsonnet +options.UnifiedAlertListOptions.stateFilter.withPending(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### obj panelOptions + + +#### fn panelOptions.withDescription + +```jsonnet +panelOptions.withDescription(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Description. +#### fn panelOptions.withGridPos + +```jsonnet +panelOptions.withGridPos(h="null", w="null", x="null", y="null") +``` + +PARAMETERS: + +* **h** (`number`) + - default value: `"null"` +* **w** (`number`) + - default value: `"null"` +* **x** (`number`) + - default value: `"null"` +* **y** (`number`) + - default value: `"null"` + +`withGridPos` configures the height, width and xy coordinates of the panel. Also see `grafonnet.util.grid` for helper functions to calculate these fields. + +All arguments default to `null`, which means they will remain unchanged or unset. + +#### fn panelOptions.withLinks + +```jsonnet +panelOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withLinksMixin + +```jsonnet +panelOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withRepeat + +```jsonnet +panelOptions.withRepeat(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of template variable to repeat for. +#### fn panelOptions.withRepeatDirection + +```jsonnet +panelOptions.withRepeatDirection(value="h") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"h"` + - valid values: `"h"`, `"v"` + +Direction to repeat in if 'repeat' is set. +"h" for horizontal, "v" for vertical. +TODO this is probably optional +#### fn panelOptions.withTitle + +```jsonnet +panelOptions.withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Panel title. +#### fn panelOptions.withTransparent + +```jsonnet +panelOptions.withTransparent(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Whether to display the panel without a background. +### obj queryOptions + + +#### fn queryOptions.withDatasource + +```jsonnet +queryOptions.withDatasource(type, uid) +``` + +PARAMETERS: + +* **type** (`string`) +* **uid** (`string`) + +`withDatasource` sets the datasource for all queries in a panel. + +The default datasource for a panel is set to 'Mixed datasource' so panels can be datasource agnostic, which is a lot more interesting from a reusability standpoint. Note that this requires query targets to explicitly set datasource for the same reason. + +#### fn queryOptions.withDatasourceMixin + +```jsonnet +queryOptions.withDatasourceMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +The datasource used in all targets. +#### fn queryOptions.withInterval + +```jsonnet +queryOptions.withInterval(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withMaxDataPoints + +```jsonnet +queryOptions.withMaxDataPoints(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +#### fn queryOptions.withTargets + +```jsonnet +queryOptions.withTargets(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTargetsMixin + +```jsonnet +queryOptions.withTargetsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTimeFrom + +```jsonnet +queryOptions.withTimeFrom(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTimeShift + +```jsonnet +queryOptions.withTimeShift(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTransformations + +```jsonnet +queryOptions.withTransformations(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn queryOptions.withTransformationsMixin + +```jsonnet +queryOptions.withTransformationsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### obj standardOptions + + +#### fn standardOptions.withDecimals + +```jsonnet +standardOptions.withDecimals(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Significant digits (for display) +#### fn standardOptions.withDisplayName + +```jsonnet +standardOptions.withDisplayName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The display value for this field. This supports template variables blank is auto +#### fn standardOptions.withFilterable + +```jsonnet +standardOptions.withFilterable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +True if data source field supports ad-hoc filters +#### fn standardOptions.withLinks + +```jsonnet +standardOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withLinksMixin + +```jsonnet +standardOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withMappings + +```jsonnet +standardOptions.withMappings(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMappingsMixin + +```jsonnet +standardOptions.withMappingsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMax + +```jsonnet +standardOptions.withMax(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withMin + +```jsonnet +standardOptions.withMin(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withNoValue + +```jsonnet +standardOptions.withNoValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Alternative to empty string +#### fn standardOptions.withOverrides + +```jsonnet +standardOptions.withOverrides(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withOverridesMixin + +```jsonnet +standardOptions.withOverridesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withPath + +```jsonnet +standardOptions.withPath(value) +``` + +PARAMETERS: + +* **value** (`string`) + +An explicit path to the field in the datasource. When the frame meta includes a path, +This will default to `${frame.meta.path}/${field.name} + +When defined, this value can be used as an identifier within the datasource scope, and +may be used to update the results +#### fn standardOptions.withUnit + +```jsonnet +standardOptions.withUnit(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Numeric Options +#### obj standardOptions.color + + +##### fn standardOptions.color.withFixedColor + +```jsonnet +standardOptions.color.withFixedColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Stores the fixed color value if mode is fixed +##### fn standardOptions.color.withMode + +```jsonnet +standardOptions.color.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The main color scheme mode +##### fn standardOptions.color.withSeriesBy + +```jsonnet +standardOptions.color.withSeriesBy(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"min"`, `"max"`, `"last"` + +TODO docs +#### obj standardOptions.thresholds + + +##### fn standardOptions.thresholds.withMode + +```jsonnet +standardOptions.thresholds.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"absolute"`, `"percentage"` + + +##### fn standardOptions.thresholds.withSteps + +```jsonnet +standardOptions.thresholds.withSteps(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity +##### fn standardOptions.thresholds.withStepsMixin + +```jsonnet +standardOptions.thresholds.withStepsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/alertList/panelOptions/link.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/alertList/panelOptions/link.md new file mode 100644 index 0000000000..106f9d2edb --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/alertList/panelOptions/link.md @@ -0,0 +1,145 @@ +# link + + + +## Index + +* [`fn withAsDropdown(value=true)`](#fn-withasdropdown) +* [`fn withIcon(value)`](#fn-withicon) +* [`fn withIncludeVars(value=true)`](#fn-withincludevars) +* [`fn withKeepTime(value=true)`](#fn-withkeeptime) +* [`fn withTags(value)`](#fn-withtags) +* [`fn withTagsMixin(value)`](#fn-withtagsmixin) +* [`fn withTargetBlank(value=true)`](#fn-withtargetblank) +* [`fn withTitle(value)`](#fn-withtitle) +* [`fn withTooltip(value)`](#fn-withtooltip) +* [`fn withType(value)`](#fn-withtype) +* [`fn withUrl(value)`](#fn-withurl) + +## Fields + +### fn withAsDropdown + +```jsonnet +withAsDropdown(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withIcon + +```jsonnet +withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withIncludeVars + +```jsonnet +withIncludeVars(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withKeepTime + +```jsonnet +withKeepTime(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTags + +```jsonnet +withTags(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTagsMixin + +```jsonnet +withTagsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTargetBlank + +```jsonnet +withTargetBlank(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTitle + +```jsonnet +withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withTooltip + +```jsonnet +withTooltip(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withType + +```jsonnet +withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"link"`, `"dashboards"` + +TODO docs +### fn withUrl + +```jsonnet +withUrl(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/alertList/queryOptions/transformation.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/alertList/queryOptions/transformation.md new file mode 100644 index 0000000000..dc832f653d --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/alertList/queryOptions/transformation.md @@ -0,0 +1,99 @@ +# transformation + + + +## Index + +* [`fn withDisabled(value=true)`](#fn-withdisabled) +* [`fn withFilter(value)`](#fn-withfilter) +* [`fn withFilterMixin(value)`](#fn-withfiltermixin) +* [`fn withId(value)`](#fn-withid) +* [`fn withOptions(value)`](#fn-withoptions) +* [`obj filter`](#obj-filter) + * [`fn withId(value="")`](#fn-filterwithid) + * [`fn withOptions(value)`](#fn-filterwithoptions) + +## Fields + +### fn withDisabled + +```jsonnet +withDisabled(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Disabled transformations are skipped +### fn withFilter + +```jsonnet +withFilter(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withFilterMixin + +```jsonnet +withFilterMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withId + +```jsonnet +withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Unique identifier of transformer +### fn withOptions + +```jsonnet +withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Options to be passed to the transformer +Valid options depend on the transformer id +### obj filter + + +#### fn filter.withId + +```jsonnet +filter.withId(value="") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `""` + + +#### fn filter.withOptions + +```jsonnet +filter.withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/alertList/standardOptions/mapping.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/alertList/standardOptions/mapping.md new file mode 100644 index 0000000000..93296972e8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/alertList/standardOptions/mapping.md @@ -0,0 +1,469 @@ +# mapping + + + +## Index + +* [`obj RangeMap`](#obj-rangemap) + * [`fn withOptions(value)`](#fn-rangemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-rangemapwithoptionsmixin) + * [`fn withType(value)`](#fn-rangemapwithtype) + * [`obj options`](#obj-rangemapoptions) + * [`fn withFrom(value)`](#fn-rangemapoptionswithfrom) + * [`fn withResult(value)`](#fn-rangemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-rangemapoptionswithresultmixin) + * [`fn withTo(value)`](#fn-rangemapoptionswithto) + * [`obj result`](#obj-rangemapoptionsresult) + * [`fn withColor(value)`](#fn-rangemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-rangemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-rangemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-rangemapoptionsresultwithtext) +* [`obj RegexMap`](#obj-regexmap) + * [`fn withOptions(value)`](#fn-regexmapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-regexmapwithoptionsmixin) + * [`fn withType(value)`](#fn-regexmapwithtype) + * [`obj options`](#obj-regexmapoptions) + * [`fn withPattern(value)`](#fn-regexmapoptionswithpattern) + * [`fn withResult(value)`](#fn-regexmapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-regexmapoptionswithresultmixin) + * [`obj result`](#obj-regexmapoptionsresult) + * [`fn withColor(value)`](#fn-regexmapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-regexmapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-regexmapoptionsresultwithindex) + * [`fn withText(value)`](#fn-regexmapoptionsresultwithtext) +* [`obj SpecialValueMap`](#obj-specialvaluemap) + * [`fn withOptions(value)`](#fn-specialvaluemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-specialvaluemapwithoptionsmixin) + * [`fn withType(value)`](#fn-specialvaluemapwithtype) + * [`obj options`](#obj-specialvaluemapoptions) + * [`fn withMatch(value)`](#fn-specialvaluemapoptionswithmatch) + * [`fn withPattern(value)`](#fn-specialvaluemapoptionswithpattern) + * [`fn withResult(value)`](#fn-specialvaluemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-specialvaluemapoptionswithresultmixin) + * [`obj result`](#obj-specialvaluemapoptionsresult) + * [`fn withColor(value)`](#fn-specialvaluemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-specialvaluemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-specialvaluemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-specialvaluemapoptionsresultwithtext) +* [`obj ValueMap`](#obj-valuemap) + * [`fn withOptions(value)`](#fn-valuemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-valuemapwithoptionsmixin) + * [`fn withType(value)`](#fn-valuemapwithtype) + +## Fields + +### obj RangeMap + + +#### fn RangeMap.withOptions + +```jsonnet +RangeMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withOptionsMixin + +```jsonnet +RangeMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withType + +```jsonnet +RangeMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RangeMap.options + + +##### fn RangeMap.options.withFrom + +```jsonnet +RangeMap.options.withFrom(value) +``` + +PARAMETERS: + +* **value** (`number`) + +to and from are `number | null` in current ts, really not sure what to do +##### fn RangeMap.options.withResult + +```jsonnet +RangeMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withResultMixin + +```jsonnet +RangeMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withTo + +```jsonnet +RangeMap.options.withTo(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +##### obj RangeMap.options.result + + +###### fn RangeMap.options.result.withColor + +```jsonnet +RangeMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIcon + +```jsonnet +RangeMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIndex + +```jsonnet +RangeMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RangeMap.options.result.withText + +```jsonnet +RangeMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj RegexMap + + +#### fn RegexMap.withOptions + +```jsonnet +RegexMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withOptionsMixin + +```jsonnet +RegexMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withType + +```jsonnet +RegexMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RegexMap.options + + +##### fn RegexMap.options.withPattern + +```jsonnet +RegexMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn RegexMap.options.withResult + +```jsonnet +RegexMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RegexMap.options.withResultMixin + +```jsonnet +RegexMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj RegexMap.options.result + + +###### fn RegexMap.options.result.withColor + +```jsonnet +RegexMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIcon + +```jsonnet +RegexMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIndex + +```jsonnet +RegexMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RegexMap.options.result.withText + +```jsonnet +RegexMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj SpecialValueMap + + +#### fn SpecialValueMap.withOptions + +```jsonnet +SpecialValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withOptionsMixin + +```jsonnet +SpecialValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withType + +```jsonnet +SpecialValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj SpecialValueMap.options + + +##### fn SpecialValueMap.options.withMatch + +```jsonnet +SpecialValueMap.options.withMatch(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"true"`, `"false"` + + +##### fn SpecialValueMap.options.withPattern + +```jsonnet +SpecialValueMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn SpecialValueMap.options.withResult + +```jsonnet +SpecialValueMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn SpecialValueMap.options.withResultMixin + +```jsonnet +SpecialValueMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj SpecialValueMap.options.result + + +###### fn SpecialValueMap.options.result.withColor + +```jsonnet +SpecialValueMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIcon + +```jsonnet +SpecialValueMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIndex + +```jsonnet +SpecialValueMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn SpecialValueMap.options.result.withText + +```jsonnet +SpecialValueMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj ValueMap + + +#### fn ValueMap.withOptions + +```jsonnet +ValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withOptionsMixin + +```jsonnet +ValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withType + +```jsonnet +ValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/alertList/standardOptions/override.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/alertList/standardOptions/override.md new file mode 100644 index 0000000000..154f3dbdac --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/alertList/standardOptions/override.md @@ -0,0 +1,244 @@ +# override + +Overrides allow you to customize visualization settings for specific fields or +series. This is accomplished by adding an override rule that targets +a particular set of fields and that can each define multiple options. + +```jsonnet +override.byType.new('number') ++ override.byType.withPropertiesFromOptions( + panel.standardOptions.withDecimals(2) + + panel.standardOptions.withUnit('s') +) +``` + + +## Index + +* [`obj byName`](#obj-byname) + * [`fn new(value)`](#fn-bynamenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bynamewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bynamewithproperty) +* [`obj byQuery`](#obj-byquery) + * [`fn new(value)`](#fn-byquerynew) + * [`fn withPropertiesFromOptions(options)`](#fn-byquerywithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byquerywithproperty) +* [`obj byRegexp`](#obj-byregexp) + * [`fn new(value)`](#fn-byregexpnew) + * [`fn withPropertiesFromOptions(options)`](#fn-byregexpwithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byregexpwithproperty) +* [`obj byType`](#obj-bytype) + * [`fn new(value)`](#fn-bytypenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bytypewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bytypewithproperty) +* [`obj byValue`](#obj-byvalue) + * [`fn new(value)`](#fn-byvaluenew) + * [`fn withPropertiesFromOptions(options)`](#fn-byvaluewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byvaluewithproperty) + +## Fields + +### obj byName + + +#### fn byName.new + +```jsonnet +byName.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byName`. +#### fn byName.withPropertiesFromOptions + +```jsonnet +byName.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byName.withProperty + +```jsonnet +byName.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byQuery + + +#### fn byQuery.new + +```jsonnet +byQuery.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byQuery`. +#### fn byQuery.withPropertiesFromOptions + +```jsonnet +byQuery.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byQuery.withProperty + +```jsonnet +byQuery.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byRegexp + + +#### fn byRegexp.new + +```jsonnet +byRegexp.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byRegexp`. +#### fn byRegexp.withPropertiesFromOptions + +```jsonnet +byRegexp.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byRegexp.withProperty + +```jsonnet +byRegexp.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byType + + +#### fn byType.new + +```jsonnet +byType.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byType`. +#### fn byType.withPropertiesFromOptions + +```jsonnet +byType.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byType.withProperty + +```jsonnet +byType.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byValue + + +#### fn byValue.new + +```jsonnet +byValue.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byValue`. +#### fn byValue.withPropertiesFromOptions + +```jsonnet +byValue.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byValue.withProperty + +```jsonnet +byValue.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/alertList/standardOptions/threshold/step.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/alertList/standardOptions/threshold/step.md new file mode 100644 index 0000000000..dd2dd227ff --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/alertList/standardOptions/threshold/step.md @@ -0,0 +1,60 @@ +# threshold.step + + + +## Index + +* [`fn withColor(value)`](#fn-withcolor) +* [`fn withIndex(value)`](#fn-withindex) +* [`fn withState(value)`](#fn-withstate) +* [`fn withValue(value)`](#fn-withvalue) + +## Fields + +### fn withColor + +```jsonnet +withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +### fn withIndex + +```jsonnet +withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Threshold index, an old property that is not needed an should only appear in older dashboards +### fn withState + +```jsonnet +withState(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO are the values here enumerable into a disjunction? +Some seem to be listed in typescript comment +### fn withValue + +```jsonnet +withValue(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +FIXME the corresponding typescript field is required/non-optional, but nulls currently appear here when serializing -Infinity to JSON \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/annotationsList/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/annotationsList/index.md new file mode 100644 index 0000000000..dc21cba61e --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/annotationsList/index.md @@ -0,0 +1,709 @@ +# annotationsList + +grafonnet.panel.annotationsList + +## Subpackages + +* [panelOptions.link](panelOptions/link.md) +* [queryOptions.transformation](queryOptions/transformation.md) +* [standardOptions.mapping](standardOptions/mapping.md) +* [standardOptions.override](standardOptions/override.md) +* [standardOptions.threshold.step](standardOptions/threshold/step.md) + +## Index + +* [`fn new(title)`](#fn-new) +* [`obj libraryPanel`](#obj-librarypanel) + * [`fn withName(value)`](#fn-librarypanelwithname) + * [`fn withUid(value)`](#fn-librarypanelwithuid) +* [`obj options`](#obj-options) + * [`fn withLimit(value=10)`](#fn-optionswithlimit) + * [`fn withNavigateAfter(value="10m")`](#fn-optionswithnavigateafter) + * [`fn withNavigateBefore(value="10m")`](#fn-optionswithnavigatebefore) + * [`fn withNavigateToPanel(value=true)`](#fn-optionswithnavigatetopanel) + * [`fn withOnlyFromThisDashboard(value=true)`](#fn-optionswithonlyfromthisdashboard) + * [`fn withOnlyInTimeRange(value=true)`](#fn-optionswithonlyintimerange) + * [`fn withShowTags(value=true)`](#fn-optionswithshowtags) + * [`fn withShowTime(value=true)`](#fn-optionswithshowtime) + * [`fn withShowUser(value=true)`](#fn-optionswithshowuser) + * [`fn withTags(value)`](#fn-optionswithtags) + * [`fn withTagsMixin(value)`](#fn-optionswithtagsmixin) +* [`obj panelOptions`](#obj-paneloptions) + * [`fn withDescription(value)`](#fn-paneloptionswithdescription) + * [`fn withGridPos(h="null", w="null", x="null", y="null")`](#fn-paneloptionswithgridpos) + * [`fn withLinks(value)`](#fn-paneloptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-paneloptionswithlinksmixin) + * [`fn withRepeat(value)`](#fn-paneloptionswithrepeat) + * [`fn withRepeatDirection(value="h")`](#fn-paneloptionswithrepeatdirection) + * [`fn withTitle(value)`](#fn-paneloptionswithtitle) + * [`fn withTransparent(value=true)`](#fn-paneloptionswithtransparent) +* [`obj queryOptions`](#obj-queryoptions) + * [`fn withDatasource(type, uid)`](#fn-queryoptionswithdatasource) + * [`fn withDatasourceMixin(value)`](#fn-queryoptionswithdatasourcemixin) + * [`fn withInterval(value)`](#fn-queryoptionswithinterval) + * [`fn withMaxDataPoints(value)`](#fn-queryoptionswithmaxdatapoints) + * [`fn withTargets(value)`](#fn-queryoptionswithtargets) + * [`fn withTargetsMixin(value)`](#fn-queryoptionswithtargetsmixin) + * [`fn withTimeFrom(value)`](#fn-queryoptionswithtimefrom) + * [`fn withTimeShift(value)`](#fn-queryoptionswithtimeshift) + * [`fn withTransformations(value)`](#fn-queryoptionswithtransformations) + * [`fn withTransformationsMixin(value)`](#fn-queryoptionswithtransformationsmixin) +* [`obj standardOptions`](#obj-standardoptions) + * [`fn withDecimals(value)`](#fn-standardoptionswithdecimals) + * [`fn withDisplayName(value)`](#fn-standardoptionswithdisplayname) + * [`fn withFilterable(value=true)`](#fn-standardoptionswithfilterable) + * [`fn withLinks(value)`](#fn-standardoptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-standardoptionswithlinksmixin) + * [`fn withMappings(value)`](#fn-standardoptionswithmappings) + * [`fn withMappingsMixin(value)`](#fn-standardoptionswithmappingsmixin) + * [`fn withMax(value)`](#fn-standardoptionswithmax) + * [`fn withMin(value)`](#fn-standardoptionswithmin) + * [`fn withNoValue(value)`](#fn-standardoptionswithnovalue) + * [`fn withOverrides(value)`](#fn-standardoptionswithoverrides) + * [`fn withOverridesMixin(value)`](#fn-standardoptionswithoverridesmixin) + * [`fn withPath(value)`](#fn-standardoptionswithpath) + * [`fn withUnit(value)`](#fn-standardoptionswithunit) + * [`obj color`](#obj-standardoptionscolor) + * [`fn withFixedColor(value)`](#fn-standardoptionscolorwithfixedcolor) + * [`fn withMode(value)`](#fn-standardoptionscolorwithmode) + * [`fn withSeriesBy(value)`](#fn-standardoptionscolorwithseriesby) + * [`obj thresholds`](#obj-standardoptionsthresholds) + * [`fn withMode(value)`](#fn-standardoptionsthresholdswithmode) + * [`fn withSteps(value)`](#fn-standardoptionsthresholdswithsteps) + * [`fn withStepsMixin(value)`](#fn-standardoptionsthresholdswithstepsmixin) + +## Fields + +### fn new + +```jsonnet +new(title) +``` + +PARAMETERS: + +* **title** (`string`) + +Creates a new annotationsList panel with a title. +### obj libraryPanel + + +#### fn libraryPanel.withName + +```jsonnet +libraryPanel.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn libraryPanel.withUid + +```jsonnet +libraryPanel.withUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj options + + +#### fn options.withLimit + +```jsonnet +options.withLimit(value=10) +``` + +PARAMETERS: + +* **value** (`integer`) + - default value: `10` + + +#### fn options.withNavigateAfter + +```jsonnet +options.withNavigateAfter(value="10m") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"10m"` + + +#### fn options.withNavigateBefore + +```jsonnet +options.withNavigateBefore(value="10m") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"10m"` + + +#### fn options.withNavigateToPanel + +```jsonnet +options.withNavigateToPanel(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +#### fn options.withOnlyFromThisDashboard + +```jsonnet +options.withOnlyFromThisDashboard(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +#### fn options.withOnlyInTimeRange + +```jsonnet +options.withOnlyInTimeRange(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +#### fn options.withShowTags + +```jsonnet +options.withShowTags(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +#### fn options.withShowTime + +```jsonnet +options.withShowTime(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +#### fn options.withShowUser + +```jsonnet +options.withShowUser(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +#### fn options.withTags + +```jsonnet +options.withTags(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn options.withTagsMixin + +```jsonnet +options.withTagsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### obj panelOptions + + +#### fn panelOptions.withDescription + +```jsonnet +panelOptions.withDescription(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Description. +#### fn panelOptions.withGridPos + +```jsonnet +panelOptions.withGridPos(h="null", w="null", x="null", y="null") +``` + +PARAMETERS: + +* **h** (`number`) + - default value: `"null"` +* **w** (`number`) + - default value: `"null"` +* **x** (`number`) + - default value: `"null"` +* **y** (`number`) + - default value: `"null"` + +`withGridPos` configures the height, width and xy coordinates of the panel. Also see `grafonnet.util.grid` for helper functions to calculate these fields. + +All arguments default to `null`, which means they will remain unchanged or unset. + +#### fn panelOptions.withLinks + +```jsonnet +panelOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withLinksMixin + +```jsonnet +panelOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withRepeat + +```jsonnet +panelOptions.withRepeat(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of template variable to repeat for. +#### fn panelOptions.withRepeatDirection + +```jsonnet +panelOptions.withRepeatDirection(value="h") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"h"` + - valid values: `"h"`, `"v"` + +Direction to repeat in if 'repeat' is set. +"h" for horizontal, "v" for vertical. +TODO this is probably optional +#### fn panelOptions.withTitle + +```jsonnet +panelOptions.withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Panel title. +#### fn panelOptions.withTransparent + +```jsonnet +panelOptions.withTransparent(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Whether to display the panel without a background. +### obj queryOptions + + +#### fn queryOptions.withDatasource + +```jsonnet +queryOptions.withDatasource(type, uid) +``` + +PARAMETERS: + +* **type** (`string`) +* **uid** (`string`) + +`withDatasource` sets the datasource for all queries in a panel. + +The default datasource for a panel is set to 'Mixed datasource' so panels can be datasource agnostic, which is a lot more interesting from a reusability standpoint. Note that this requires query targets to explicitly set datasource for the same reason. + +#### fn queryOptions.withDatasourceMixin + +```jsonnet +queryOptions.withDatasourceMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +The datasource used in all targets. +#### fn queryOptions.withInterval + +```jsonnet +queryOptions.withInterval(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withMaxDataPoints + +```jsonnet +queryOptions.withMaxDataPoints(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +#### fn queryOptions.withTargets + +```jsonnet +queryOptions.withTargets(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTargetsMixin + +```jsonnet +queryOptions.withTargetsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTimeFrom + +```jsonnet +queryOptions.withTimeFrom(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTimeShift + +```jsonnet +queryOptions.withTimeShift(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTransformations + +```jsonnet +queryOptions.withTransformations(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn queryOptions.withTransformationsMixin + +```jsonnet +queryOptions.withTransformationsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### obj standardOptions + + +#### fn standardOptions.withDecimals + +```jsonnet +standardOptions.withDecimals(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Significant digits (for display) +#### fn standardOptions.withDisplayName + +```jsonnet +standardOptions.withDisplayName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The display value for this field. This supports template variables blank is auto +#### fn standardOptions.withFilterable + +```jsonnet +standardOptions.withFilterable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +True if data source field supports ad-hoc filters +#### fn standardOptions.withLinks + +```jsonnet +standardOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withLinksMixin + +```jsonnet +standardOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withMappings + +```jsonnet +standardOptions.withMappings(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMappingsMixin + +```jsonnet +standardOptions.withMappingsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMax + +```jsonnet +standardOptions.withMax(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withMin + +```jsonnet +standardOptions.withMin(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withNoValue + +```jsonnet +standardOptions.withNoValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Alternative to empty string +#### fn standardOptions.withOverrides + +```jsonnet +standardOptions.withOverrides(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withOverridesMixin + +```jsonnet +standardOptions.withOverridesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withPath + +```jsonnet +standardOptions.withPath(value) +``` + +PARAMETERS: + +* **value** (`string`) + +An explicit path to the field in the datasource. When the frame meta includes a path, +This will default to `${frame.meta.path}/${field.name} + +When defined, this value can be used as an identifier within the datasource scope, and +may be used to update the results +#### fn standardOptions.withUnit + +```jsonnet +standardOptions.withUnit(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Numeric Options +#### obj standardOptions.color + + +##### fn standardOptions.color.withFixedColor + +```jsonnet +standardOptions.color.withFixedColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Stores the fixed color value if mode is fixed +##### fn standardOptions.color.withMode + +```jsonnet +standardOptions.color.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The main color scheme mode +##### fn standardOptions.color.withSeriesBy + +```jsonnet +standardOptions.color.withSeriesBy(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"min"`, `"max"`, `"last"` + +TODO docs +#### obj standardOptions.thresholds + + +##### fn standardOptions.thresholds.withMode + +```jsonnet +standardOptions.thresholds.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"absolute"`, `"percentage"` + + +##### fn standardOptions.thresholds.withSteps + +```jsonnet +standardOptions.thresholds.withSteps(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity +##### fn standardOptions.thresholds.withStepsMixin + +```jsonnet +standardOptions.thresholds.withStepsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/annotationsList/panelOptions/link.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/annotationsList/panelOptions/link.md new file mode 100644 index 0000000000..106f9d2edb --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/annotationsList/panelOptions/link.md @@ -0,0 +1,145 @@ +# link + + + +## Index + +* [`fn withAsDropdown(value=true)`](#fn-withasdropdown) +* [`fn withIcon(value)`](#fn-withicon) +* [`fn withIncludeVars(value=true)`](#fn-withincludevars) +* [`fn withKeepTime(value=true)`](#fn-withkeeptime) +* [`fn withTags(value)`](#fn-withtags) +* [`fn withTagsMixin(value)`](#fn-withtagsmixin) +* [`fn withTargetBlank(value=true)`](#fn-withtargetblank) +* [`fn withTitle(value)`](#fn-withtitle) +* [`fn withTooltip(value)`](#fn-withtooltip) +* [`fn withType(value)`](#fn-withtype) +* [`fn withUrl(value)`](#fn-withurl) + +## Fields + +### fn withAsDropdown + +```jsonnet +withAsDropdown(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withIcon + +```jsonnet +withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withIncludeVars + +```jsonnet +withIncludeVars(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withKeepTime + +```jsonnet +withKeepTime(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTags + +```jsonnet +withTags(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTagsMixin + +```jsonnet +withTagsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTargetBlank + +```jsonnet +withTargetBlank(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTitle + +```jsonnet +withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withTooltip + +```jsonnet +withTooltip(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withType + +```jsonnet +withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"link"`, `"dashboards"` + +TODO docs +### fn withUrl + +```jsonnet +withUrl(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/annotationsList/queryOptions/transformation.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/annotationsList/queryOptions/transformation.md new file mode 100644 index 0000000000..dc832f653d --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/annotationsList/queryOptions/transformation.md @@ -0,0 +1,99 @@ +# transformation + + + +## Index + +* [`fn withDisabled(value=true)`](#fn-withdisabled) +* [`fn withFilter(value)`](#fn-withfilter) +* [`fn withFilterMixin(value)`](#fn-withfiltermixin) +* [`fn withId(value)`](#fn-withid) +* [`fn withOptions(value)`](#fn-withoptions) +* [`obj filter`](#obj-filter) + * [`fn withId(value="")`](#fn-filterwithid) + * [`fn withOptions(value)`](#fn-filterwithoptions) + +## Fields + +### fn withDisabled + +```jsonnet +withDisabled(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Disabled transformations are skipped +### fn withFilter + +```jsonnet +withFilter(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withFilterMixin + +```jsonnet +withFilterMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withId + +```jsonnet +withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Unique identifier of transformer +### fn withOptions + +```jsonnet +withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Options to be passed to the transformer +Valid options depend on the transformer id +### obj filter + + +#### fn filter.withId + +```jsonnet +filter.withId(value="") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `""` + + +#### fn filter.withOptions + +```jsonnet +filter.withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/annotationsList/standardOptions/mapping.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/annotationsList/standardOptions/mapping.md new file mode 100644 index 0000000000..93296972e8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/annotationsList/standardOptions/mapping.md @@ -0,0 +1,469 @@ +# mapping + + + +## Index + +* [`obj RangeMap`](#obj-rangemap) + * [`fn withOptions(value)`](#fn-rangemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-rangemapwithoptionsmixin) + * [`fn withType(value)`](#fn-rangemapwithtype) + * [`obj options`](#obj-rangemapoptions) + * [`fn withFrom(value)`](#fn-rangemapoptionswithfrom) + * [`fn withResult(value)`](#fn-rangemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-rangemapoptionswithresultmixin) + * [`fn withTo(value)`](#fn-rangemapoptionswithto) + * [`obj result`](#obj-rangemapoptionsresult) + * [`fn withColor(value)`](#fn-rangemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-rangemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-rangemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-rangemapoptionsresultwithtext) +* [`obj RegexMap`](#obj-regexmap) + * [`fn withOptions(value)`](#fn-regexmapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-regexmapwithoptionsmixin) + * [`fn withType(value)`](#fn-regexmapwithtype) + * [`obj options`](#obj-regexmapoptions) + * [`fn withPattern(value)`](#fn-regexmapoptionswithpattern) + * [`fn withResult(value)`](#fn-regexmapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-regexmapoptionswithresultmixin) + * [`obj result`](#obj-regexmapoptionsresult) + * [`fn withColor(value)`](#fn-regexmapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-regexmapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-regexmapoptionsresultwithindex) + * [`fn withText(value)`](#fn-regexmapoptionsresultwithtext) +* [`obj SpecialValueMap`](#obj-specialvaluemap) + * [`fn withOptions(value)`](#fn-specialvaluemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-specialvaluemapwithoptionsmixin) + * [`fn withType(value)`](#fn-specialvaluemapwithtype) + * [`obj options`](#obj-specialvaluemapoptions) + * [`fn withMatch(value)`](#fn-specialvaluemapoptionswithmatch) + * [`fn withPattern(value)`](#fn-specialvaluemapoptionswithpattern) + * [`fn withResult(value)`](#fn-specialvaluemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-specialvaluemapoptionswithresultmixin) + * [`obj result`](#obj-specialvaluemapoptionsresult) + * [`fn withColor(value)`](#fn-specialvaluemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-specialvaluemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-specialvaluemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-specialvaluemapoptionsresultwithtext) +* [`obj ValueMap`](#obj-valuemap) + * [`fn withOptions(value)`](#fn-valuemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-valuemapwithoptionsmixin) + * [`fn withType(value)`](#fn-valuemapwithtype) + +## Fields + +### obj RangeMap + + +#### fn RangeMap.withOptions + +```jsonnet +RangeMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withOptionsMixin + +```jsonnet +RangeMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withType + +```jsonnet +RangeMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RangeMap.options + + +##### fn RangeMap.options.withFrom + +```jsonnet +RangeMap.options.withFrom(value) +``` + +PARAMETERS: + +* **value** (`number`) + +to and from are `number | null` in current ts, really not sure what to do +##### fn RangeMap.options.withResult + +```jsonnet +RangeMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withResultMixin + +```jsonnet +RangeMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withTo + +```jsonnet +RangeMap.options.withTo(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +##### obj RangeMap.options.result + + +###### fn RangeMap.options.result.withColor + +```jsonnet +RangeMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIcon + +```jsonnet +RangeMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIndex + +```jsonnet +RangeMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RangeMap.options.result.withText + +```jsonnet +RangeMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj RegexMap + + +#### fn RegexMap.withOptions + +```jsonnet +RegexMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withOptionsMixin + +```jsonnet +RegexMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withType + +```jsonnet +RegexMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RegexMap.options + + +##### fn RegexMap.options.withPattern + +```jsonnet +RegexMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn RegexMap.options.withResult + +```jsonnet +RegexMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RegexMap.options.withResultMixin + +```jsonnet +RegexMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj RegexMap.options.result + + +###### fn RegexMap.options.result.withColor + +```jsonnet +RegexMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIcon + +```jsonnet +RegexMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIndex + +```jsonnet +RegexMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RegexMap.options.result.withText + +```jsonnet +RegexMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj SpecialValueMap + + +#### fn SpecialValueMap.withOptions + +```jsonnet +SpecialValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withOptionsMixin + +```jsonnet +SpecialValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withType + +```jsonnet +SpecialValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj SpecialValueMap.options + + +##### fn SpecialValueMap.options.withMatch + +```jsonnet +SpecialValueMap.options.withMatch(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"true"`, `"false"` + + +##### fn SpecialValueMap.options.withPattern + +```jsonnet +SpecialValueMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn SpecialValueMap.options.withResult + +```jsonnet +SpecialValueMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn SpecialValueMap.options.withResultMixin + +```jsonnet +SpecialValueMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj SpecialValueMap.options.result + + +###### fn SpecialValueMap.options.result.withColor + +```jsonnet +SpecialValueMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIcon + +```jsonnet +SpecialValueMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIndex + +```jsonnet +SpecialValueMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn SpecialValueMap.options.result.withText + +```jsonnet +SpecialValueMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj ValueMap + + +#### fn ValueMap.withOptions + +```jsonnet +ValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withOptionsMixin + +```jsonnet +ValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withType + +```jsonnet +ValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/annotationsList/standardOptions/override.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/annotationsList/standardOptions/override.md new file mode 100644 index 0000000000..154f3dbdac --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/annotationsList/standardOptions/override.md @@ -0,0 +1,244 @@ +# override + +Overrides allow you to customize visualization settings for specific fields or +series. This is accomplished by adding an override rule that targets +a particular set of fields and that can each define multiple options. + +```jsonnet +override.byType.new('number') ++ override.byType.withPropertiesFromOptions( + panel.standardOptions.withDecimals(2) + + panel.standardOptions.withUnit('s') +) +``` + + +## Index + +* [`obj byName`](#obj-byname) + * [`fn new(value)`](#fn-bynamenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bynamewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bynamewithproperty) +* [`obj byQuery`](#obj-byquery) + * [`fn new(value)`](#fn-byquerynew) + * [`fn withPropertiesFromOptions(options)`](#fn-byquerywithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byquerywithproperty) +* [`obj byRegexp`](#obj-byregexp) + * [`fn new(value)`](#fn-byregexpnew) + * [`fn withPropertiesFromOptions(options)`](#fn-byregexpwithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byregexpwithproperty) +* [`obj byType`](#obj-bytype) + * [`fn new(value)`](#fn-bytypenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bytypewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bytypewithproperty) +* [`obj byValue`](#obj-byvalue) + * [`fn new(value)`](#fn-byvaluenew) + * [`fn withPropertiesFromOptions(options)`](#fn-byvaluewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byvaluewithproperty) + +## Fields + +### obj byName + + +#### fn byName.new + +```jsonnet +byName.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byName`. +#### fn byName.withPropertiesFromOptions + +```jsonnet +byName.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byName.withProperty + +```jsonnet +byName.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byQuery + + +#### fn byQuery.new + +```jsonnet +byQuery.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byQuery`. +#### fn byQuery.withPropertiesFromOptions + +```jsonnet +byQuery.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byQuery.withProperty + +```jsonnet +byQuery.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byRegexp + + +#### fn byRegexp.new + +```jsonnet +byRegexp.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byRegexp`. +#### fn byRegexp.withPropertiesFromOptions + +```jsonnet +byRegexp.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byRegexp.withProperty + +```jsonnet +byRegexp.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byType + + +#### fn byType.new + +```jsonnet +byType.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byType`. +#### fn byType.withPropertiesFromOptions + +```jsonnet +byType.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byType.withProperty + +```jsonnet +byType.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byValue + + +#### fn byValue.new + +```jsonnet +byValue.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byValue`. +#### fn byValue.withPropertiesFromOptions + +```jsonnet +byValue.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byValue.withProperty + +```jsonnet +byValue.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/annotationsList/standardOptions/threshold/step.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/annotationsList/standardOptions/threshold/step.md new file mode 100644 index 0000000000..dd2dd227ff --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/annotationsList/standardOptions/threshold/step.md @@ -0,0 +1,60 @@ +# threshold.step + + + +## Index + +* [`fn withColor(value)`](#fn-withcolor) +* [`fn withIndex(value)`](#fn-withindex) +* [`fn withState(value)`](#fn-withstate) +* [`fn withValue(value)`](#fn-withvalue) + +## Fields + +### fn withColor + +```jsonnet +withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +### fn withIndex + +```jsonnet +withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Threshold index, an old property that is not needed an should only appear in older dashboards +### fn withState + +```jsonnet +withState(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO are the values here enumerable into a disjunction? +Some seem to be listed in typescript comment +### fn withValue + +```jsonnet +withValue(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +FIXME the corresponding typescript field is required/non-optional, but nulls currently appear here when serializing -Infinity to JSON \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/barChart/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/barChart/index.md new file mode 100644 index 0000000000..8eaa9bd99f --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/barChart/index.md @@ -0,0 +1,1305 @@ +# barChart + +grafonnet.panel.barChart + +## Subpackages + +* [panelOptions.link](panelOptions/link.md) +* [queryOptions.transformation](queryOptions/transformation.md) +* [standardOptions.mapping](standardOptions/mapping.md) +* [standardOptions.override](standardOptions/override.md) +* [standardOptions.threshold.step](standardOptions/threshold/step.md) + +## Index + +* [`fn new(title)`](#fn-new) +* [`obj fieldConfig`](#obj-fieldconfig) + * [`obj defaults`](#obj-fieldconfigdefaults) + * [`obj custom`](#obj-fieldconfigdefaultscustom) + * [`fn withAxisCenteredZero(value=true)`](#fn-fieldconfigdefaultscustomwithaxiscenteredzero) + * [`fn withAxisColorMode(value)`](#fn-fieldconfigdefaultscustomwithaxiscolormode) + * [`fn withAxisGridShow(value=true)`](#fn-fieldconfigdefaultscustomwithaxisgridshow) + * [`fn withAxisLabel(value)`](#fn-fieldconfigdefaultscustomwithaxislabel) + * [`fn withAxisPlacement(value)`](#fn-fieldconfigdefaultscustomwithaxisplacement) + * [`fn withAxisSoftMax(value)`](#fn-fieldconfigdefaultscustomwithaxissoftmax) + * [`fn withAxisSoftMin(value)`](#fn-fieldconfigdefaultscustomwithaxissoftmin) + * [`fn withAxisWidth(value)`](#fn-fieldconfigdefaultscustomwithaxiswidth) + * [`fn withFillOpacity(value=80)`](#fn-fieldconfigdefaultscustomwithfillopacity) + * [`fn withGradientMode(value)`](#fn-fieldconfigdefaultscustomwithgradientmode) + * [`fn withHideFrom(value)`](#fn-fieldconfigdefaultscustomwithhidefrom) + * [`fn withHideFromMixin(value)`](#fn-fieldconfigdefaultscustomwithhidefrommixin) + * [`fn withLineWidth(value=1)`](#fn-fieldconfigdefaultscustomwithlinewidth) + * [`fn withScaleDistribution(value)`](#fn-fieldconfigdefaultscustomwithscaledistribution) + * [`fn withScaleDistributionMixin(value)`](#fn-fieldconfigdefaultscustomwithscaledistributionmixin) + * [`fn withThresholdsStyle(value)`](#fn-fieldconfigdefaultscustomwiththresholdsstyle) + * [`fn withThresholdsStyleMixin(value)`](#fn-fieldconfigdefaultscustomwiththresholdsstylemixin) + * [`obj hideFrom`](#obj-fieldconfigdefaultscustomhidefrom) + * [`fn withLegend(value=true)`](#fn-fieldconfigdefaultscustomhidefromwithlegend) + * [`fn withTooltip(value=true)`](#fn-fieldconfigdefaultscustomhidefromwithtooltip) + * [`fn withViz(value=true)`](#fn-fieldconfigdefaultscustomhidefromwithviz) + * [`obj scaleDistribution`](#obj-fieldconfigdefaultscustomscaledistribution) + * [`fn withLinearThreshold(value)`](#fn-fieldconfigdefaultscustomscaledistributionwithlinearthreshold) + * [`fn withLog(value)`](#fn-fieldconfigdefaultscustomscaledistributionwithlog) + * [`fn withType(value)`](#fn-fieldconfigdefaultscustomscaledistributionwithtype) + * [`obj thresholdsStyle`](#obj-fieldconfigdefaultscustomthresholdsstyle) + * [`fn withMode(value)`](#fn-fieldconfigdefaultscustomthresholdsstylewithmode) +* [`obj libraryPanel`](#obj-librarypanel) + * [`fn withName(value)`](#fn-librarypanelwithname) + * [`fn withUid(value)`](#fn-librarypanelwithuid) +* [`obj options`](#obj-options) + * [`fn withBarRadius(value=0)`](#fn-optionswithbarradius) + * [`fn withBarWidth(value=0.97)`](#fn-optionswithbarwidth) + * [`fn withColorByField(value)`](#fn-optionswithcolorbyfield) + * [`fn withFullHighlight(value=true)`](#fn-optionswithfullhighlight) + * [`fn withGroupWidth(value=0.7)`](#fn-optionswithgroupwidth) + * [`fn withLegend(value)`](#fn-optionswithlegend) + * [`fn withLegendMixin(value)`](#fn-optionswithlegendmixin) + * [`fn withOrientation(value)`](#fn-optionswithorientation) + * [`fn withShowValue(value)`](#fn-optionswithshowvalue) + * [`fn withStacking(value)`](#fn-optionswithstacking) + * [`fn withText(value)`](#fn-optionswithtext) + * [`fn withTextMixin(value)`](#fn-optionswithtextmixin) + * [`fn withTooltip(value)`](#fn-optionswithtooltip) + * [`fn withTooltipMixin(value)`](#fn-optionswithtooltipmixin) + * [`fn withXField(value)`](#fn-optionswithxfield) + * [`fn withXTickLabelMaxLength(value)`](#fn-optionswithxticklabelmaxlength) + * [`fn withXTickLabelRotation(value=0)`](#fn-optionswithxticklabelrotation) + * [`fn withXTickLabelSpacing(value=0)`](#fn-optionswithxticklabelspacing) + * [`obj legend`](#obj-optionslegend) + * [`fn withAsTable(value=true)`](#fn-optionslegendwithastable) + * [`fn withCalcs(value)`](#fn-optionslegendwithcalcs) + * [`fn withCalcsMixin(value)`](#fn-optionslegendwithcalcsmixin) + * [`fn withDisplayMode(value)`](#fn-optionslegendwithdisplaymode) + * [`fn withIsVisible(value=true)`](#fn-optionslegendwithisvisible) + * [`fn withPlacement(value)`](#fn-optionslegendwithplacement) + * [`fn withShowLegend(value=true)`](#fn-optionslegendwithshowlegend) + * [`fn withSortBy(value)`](#fn-optionslegendwithsortby) + * [`fn withSortDesc(value=true)`](#fn-optionslegendwithsortdesc) + * [`fn withWidth(value)`](#fn-optionslegendwithwidth) + * [`obj text`](#obj-optionstext) + * [`fn withTitleSize(value)`](#fn-optionstextwithtitlesize) + * [`fn withValueSize(value)`](#fn-optionstextwithvaluesize) + * [`obj tooltip`](#obj-optionstooltip) + * [`fn withMode(value)`](#fn-optionstooltipwithmode) + * [`fn withSort(value)`](#fn-optionstooltipwithsort) +* [`obj panelOptions`](#obj-paneloptions) + * [`fn withDescription(value)`](#fn-paneloptionswithdescription) + * [`fn withGridPos(h="null", w="null", x="null", y="null")`](#fn-paneloptionswithgridpos) + * [`fn withLinks(value)`](#fn-paneloptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-paneloptionswithlinksmixin) + * [`fn withRepeat(value)`](#fn-paneloptionswithrepeat) + * [`fn withRepeatDirection(value="h")`](#fn-paneloptionswithrepeatdirection) + * [`fn withTitle(value)`](#fn-paneloptionswithtitle) + * [`fn withTransparent(value=true)`](#fn-paneloptionswithtransparent) +* [`obj queryOptions`](#obj-queryoptions) + * [`fn withDatasource(type, uid)`](#fn-queryoptionswithdatasource) + * [`fn withDatasourceMixin(value)`](#fn-queryoptionswithdatasourcemixin) + * [`fn withInterval(value)`](#fn-queryoptionswithinterval) + * [`fn withMaxDataPoints(value)`](#fn-queryoptionswithmaxdatapoints) + * [`fn withTargets(value)`](#fn-queryoptionswithtargets) + * [`fn withTargetsMixin(value)`](#fn-queryoptionswithtargetsmixin) + * [`fn withTimeFrom(value)`](#fn-queryoptionswithtimefrom) + * [`fn withTimeShift(value)`](#fn-queryoptionswithtimeshift) + * [`fn withTransformations(value)`](#fn-queryoptionswithtransformations) + * [`fn withTransformationsMixin(value)`](#fn-queryoptionswithtransformationsmixin) +* [`obj standardOptions`](#obj-standardoptions) + * [`fn withDecimals(value)`](#fn-standardoptionswithdecimals) + * [`fn withDisplayName(value)`](#fn-standardoptionswithdisplayname) + * [`fn withFilterable(value=true)`](#fn-standardoptionswithfilterable) + * [`fn withLinks(value)`](#fn-standardoptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-standardoptionswithlinksmixin) + * [`fn withMappings(value)`](#fn-standardoptionswithmappings) + * [`fn withMappingsMixin(value)`](#fn-standardoptionswithmappingsmixin) + * [`fn withMax(value)`](#fn-standardoptionswithmax) + * [`fn withMin(value)`](#fn-standardoptionswithmin) + * [`fn withNoValue(value)`](#fn-standardoptionswithnovalue) + * [`fn withOverrides(value)`](#fn-standardoptionswithoverrides) + * [`fn withOverridesMixin(value)`](#fn-standardoptionswithoverridesmixin) + * [`fn withPath(value)`](#fn-standardoptionswithpath) + * [`fn withUnit(value)`](#fn-standardoptionswithunit) + * [`obj color`](#obj-standardoptionscolor) + * [`fn withFixedColor(value)`](#fn-standardoptionscolorwithfixedcolor) + * [`fn withMode(value)`](#fn-standardoptionscolorwithmode) + * [`fn withSeriesBy(value)`](#fn-standardoptionscolorwithseriesby) + * [`obj thresholds`](#obj-standardoptionsthresholds) + * [`fn withMode(value)`](#fn-standardoptionsthresholdswithmode) + * [`fn withSteps(value)`](#fn-standardoptionsthresholdswithsteps) + * [`fn withStepsMixin(value)`](#fn-standardoptionsthresholdswithstepsmixin) + +## Fields + +### fn new + +```jsonnet +new(title) +``` + +PARAMETERS: + +* **title** (`string`) + +Creates a new barChart panel with a title. +### obj fieldConfig + + +#### obj fieldConfig.defaults + + +##### obj fieldConfig.defaults.custom + + +###### fn fieldConfig.defaults.custom.withAxisCenteredZero + +```jsonnet +fieldConfig.defaults.custom.withAxisCenteredZero(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +###### fn fieldConfig.defaults.custom.withAxisColorMode + +```jsonnet +fieldConfig.defaults.custom.withAxisColorMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"text"`, `"series"` + +TODO docs +###### fn fieldConfig.defaults.custom.withAxisGridShow + +```jsonnet +fieldConfig.defaults.custom.withAxisGridShow(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +###### fn fieldConfig.defaults.custom.withAxisLabel + +```jsonnet +fieldConfig.defaults.custom.withAxisLabel(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn fieldConfig.defaults.custom.withAxisPlacement + +```jsonnet +fieldConfig.defaults.custom.withAxisPlacement(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"auto"`, `"top"`, `"right"`, `"bottom"`, `"left"`, `"hidden"` + +TODO docs +###### fn fieldConfig.defaults.custom.withAxisSoftMax + +```jsonnet +fieldConfig.defaults.custom.withAxisSoftMax(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +###### fn fieldConfig.defaults.custom.withAxisSoftMin + +```jsonnet +fieldConfig.defaults.custom.withAxisSoftMin(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +###### fn fieldConfig.defaults.custom.withAxisWidth + +```jsonnet +fieldConfig.defaults.custom.withAxisWidth(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +###### fn fieldConfig.defaults.custom.withFillOpacity + +```jsonnet +fieldConfig.defaults.custom.withFillOpacity(value=80) +``` + +PARAMETERS: + +* **value** (`integer`) + - default value: `80` + +Controls the fill opacity of the bars. +###### fn fieldConfig.defaults.custom.withGradientMode + +```jsonnet +fieldConfig.defaults.custom.withGradientMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Set the mode of the gradient fill. Fill gradient is based on the line color. To change the color, use the standard color scheme field option. +Gradient appearance is influenced by the Fill opacity setting. +###### fn fieldConfig.defaults.custom.withHideFrom + +```jsonnet +fieldConfig.defaults.custom.withHideFrom(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn fieldConfig.defaults.custom.withHideFromMixin + +```jsonnet +fieldConfig.defaults.custom.withHideFromMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn fieldConfig.defaults.custom.withLineWidth + +```jsonnet +fieldConfig.defaults.custom.withLineWidth(value=1) +``` + +PARAMETERS: + +* **value** (`integer`) + - default value: `1` + +Controls line width of the bars. +###### fn fieldConfig.defaults.custom.withScaleDistribution + +```jsonnet +fieldConfig.defaults.custom.withScaleDistribution(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn fieldConfig.defaults.custom.withScaleDistributionMixin + +```jsonnet +fieldConfig.defaults.custom.withScaleDistributionMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn fieldConfig.defaults.custom.withThresholdsStyle + +```jsonnet +fieldConfig.defaults.custom.withThresholdsStyle(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn fieldConfig.defaults.custom.withThresholdsStyleMixin + +```jsonnet +fieldConfig.defaults.custom.withThresholdsStyleMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### obj fieldConfig.defaults.custom.hideFrom + + +####### fn fieldConfig.defaults.custom.hideFrom.withLegend + +```jsonnet +fieldConfig.defaults.custom.hideFrom.withLegend(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +####### fn fieldConfig.defaults.custom.hideFrom.withTooltip + +```jsonnet +fieldConfig.defaults.custom.hideFrom.withTooltip(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +####### fn fieldConfig.defaults.custom.hideFrom.withViz + +```jsonnet +fieldConfig.defaults.custom.hideFrom.withViz(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +###### obj fieldConfig.defaults.custom.scaleDistribution + + +####### fn fieldConfig.defaults.custom.scaleDistribution.withLinearThreshold + +```jsonnet +fieldConfig.defaults.custom.scaleDistribution.withLinearThreshold(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +####### fn fieldConfig.defaults.custom.scaleDistribution.withLog + +```jsonnet +fieldConfig.defaults.custom.scaleDistribution.withLog(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +####### fn fieldConfig.defaults.custom.scaleDistribution.withType + +```jsonnet +fieldConfig.defaults.custom.scaleDistribution.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"linear"`, `"log"`, `"ordinal"`, `"symlog"` + +TODO docs +###### obj fieldConfig.defaults.custom.thresholdsStyle + + +####### fn fieldConfig.defaults.custom.thresholdsStyle.withMode + +```jsonnet +fieldConfig.defaults.custom.thresholdsStyle.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"off"`, `"line"`, `"dashed"`, `"area"`, `"line+area"`, `"dashed+area"`, `"series"` + +TODO docs +### obj libraryPanel + + +#### fn libraryPanel.withName + +```jsonnet +libraryPanel.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn libraryPanel.withUid + +```jsonnet +libraryPanel.withUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj options + + +#### fn options.withBarRadius + +```jsonnet +options.withBarRadius(value=0) +``` + +PARAMETERS: + +* **value** (`number`) + - default value: `0` + +Controls the radius of each bar. +#### fn options.withBarWidth + +```jsonnet +options.withBarWidth(value=0.97) +``` + +PARAMETERS: + +* **value** (`number`) + - default value: `0.97` + +Controls the width of bars. 1 = Max width, 0 = Min width. +#### fn options.withColorByField + +```jsonnet +options.withColorByField(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Use the color value for a sibling field to color each bar value. +#### fn options.withFullHighlight + +```jsonnet +options.withFullHighlight(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Enables mode which highlights the entire bar area and shows tooltip when cursor +hovers over highlighted area +#### fn options.withGroupWidth + +```jsonnet +options.withGroupWidth(value=0.7) +``` + +PARAMETERS: + +* **value** (`number`) + - default value: `0.7` + +Controls the width of groups. 1 = max with, 0 = min width. +#### fn options.withLegend + +```jsonnet +options.withLegend(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withLegendMixin + +```jsonnet +options.withLegendMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withOrientation + +```jsonnet +options.withOrientation(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Controls the orientation of the bar chart, either vertical or horizontal. +#### fn options.withShowValue + +```jsonnet +options.withShowValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + +This controls whether values are shown on top or to the left of bars. +#### fn options.withStacking + +```jsonnet +options.withStacking(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Controls whether bars are stacked or not, either normally or in percent mode. +#### fn options.withText + +```jsonnet +options.withText(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withTextMixin + +```jsonnet +options.withTextMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withTooltip + +```jsonnet +options.withTooltip(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withTooltipMixin + +```jsonnet +options.withTooltipMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withXField + +```jsonnet +options.withXField(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Manually select which field from the dataset to represent the x field. +#### fn options.withXTickLabelMaxLength + +```jsonnet +options.withXTickLabelMaxLength(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Sets the max length that a label can have before it is truncated. +#### fn options.withXTickLabelRotation + +```jsonnet +options.withXTickLabelRotation(value=0) +``` + +PARAMETERS: + +* **value** (`integer`) + - default value: `0` + +Controls the rotation of the x axis labels. +#### fn options.withXTickLabelSpacing + +```jsonnet +options.withXTickLabelSpacing(value=0) +``` + +PARAMETERS: + +* **value** (`integer`) + - default value: `0` + +Controls the spacing between x axis labels. +negative values indicate backwards skipping behavior +#### obj options.legend + + +##### fn options.legend.withAsTable + +```jsonnet +options.legend.withAsTable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.legend.withCalcs + +```jsonnet +options.legend.withCalcs(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +##### fn options.legend.withCalcsMixin + +```jsonnet +options.legend.withCalcsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +##### fn options.legend.withDisplayMode + +```jsonnet +options.legend.withDisplayMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"list"`, `"table"`, `"hidden"` + +TODO docs +Note: "hidden" needs to remain as an option for plugins compatibility +##### fn options.legend.withIsVisible + +```jsonnet +options.legend.withIsVisible(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.legend.withPlacement + +```jsonnet +options.legend.withPlacement(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"bottom"`, `"right"` + +TODO docs +##### fn options.legend.withShowLegend + +```jsonnet +options.legend.withShowLegend(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.legend.withSortBy + +```jsonnet +options.legend.withSortBy(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn options.legend.withSortDesc + +```jsonnet +options.legend.withSortDesc(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.legend.withWidth + +```jsonnet +options.legend.withWidth(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### obj options.text + + +##### fn options.text.withTitleSize + +```jsonnet +options.text.withTitleSize(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Explicit title text size +##### fn options.text.withValueSize + +```jsonnet +options.text.withValueSize(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Explicit value text size +#### obj options.tooltip + + +##### fn options.tooltip.withMode + +```jsonnet +options.tooltip.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"single"`, `"multi"`, `"none"` + +TODO docs +##### fn options.tooltip.withSort + +```jsonnet +options.tooltip.withSort(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"asc"`, `"desc"`, `"none"` + +TODO docs +### obj panelOptions + + +#### fn panelOptions.withDescription + +```jsonnet +panelOptions.withDescription(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Description. +#### fn panelOptions.withGridPos + +```jsonnet +panelOptions.withGridPos(h="null", w="null", x="null", y="null") +``` + +PARAMETERS: + +* **h** (`number`) + - default value: `"null"` +* **w** (`number`) + - default value: `"null"` +* **x** (`number`) + - default value: `"null"` +* **y** (`number`) + - default value: `"null"` + +`withGridPos` configures the height, width and xy coordinates of the panel. Also see `grafonnet.util.grid` for helper functions to calculate these fields. + +All arguments default to `null`, which means they will remain unchanged or unset. + +#### fn panelOptions.withLinks + +```jsonnet +panelOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withLinksMixin + +```jsonnet +panelOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withRepeat + +```jsonnet +panelOptions.withRepeat(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of template variable to repeat for. +#### fn panelOptions.withRepeatDirection + +```jsonnet +panelOptions.withRepeatDirection(value="h") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"h"` + - valid values: `"h"`, `"v"` + +Direction to repeat in if 'repeat' is set. +"h" for horizontal, "v" for vertical. +TODO this is probably optional +#### fn panelOptions.withTitle + +```jsonnet +panelOptions.withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Panel title. +#### fn panelOptions.withTransparent + +```jsonnet +panelOptions.withTransparent(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Whether to display the panel without a background. +### obj queryOptions + + +#### fn queryOptions.withDatasource + +```jsonnet +queryOptions.withDatasource(type, uid) +``` + +PARAMETERS: + +* **type** (`string`) +* **uid** (`string`) + +`withDatasource` sets the datasource for all queries in a panel. + +The default datasource for a panel is set to 'Mixed datasource' so panels can be datasource agnostic, which is a lot more interesting from a reusability standpoint. Note that this requires query targets to explicitly set datasource for the same reason. + +#### fn queryOptions.withDatasourceMixin + +```jsonnet +queryOptions.withDatasourceMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +The datasource used in all targets. +#### fn queryOptions.withInterval + +```jsonnet +queryOptions.withInterval(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withMaxDataPoints + +```jsonnet +queryOptions.withMaxDataPoints(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +#### fn queryOptions.withTargets + +```jsonnet +queryOptions.withTargets(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTargetsMixin + +```jsonnet +queryOptions.withTargetsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTimeFrom + +```jsonnet +queryOptions.withTimeFrom(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTimeShift + +```jsonnet +queryOptions.withTimeShift(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTransformations + +```jsonnet +queryOptions.withTransformations(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn queryOptions.withTransformationsMixin + +```jsonnet +queryOptions.withTransformationsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### obj standardOptions + + +#### fn standardOptions.withDecimals + +```jsonnet +standardOptions.withDecimals(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Significant digits (for display) +#### fn standardOptions.withDisplayName + +```jsonnet +standardOptions.withDisplayName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The display value for this field. This supports template variables blank is auto +#### fn standardOptions.withFilterable + +```jsonnet +standardOptions.withFilterable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +True if data source field supports ad-hoc filters +#### fn standardOptions.withLinks + +```jsonnet +standardOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withLinksMixin + +```jsonnet +standardOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withMappings + +```jsonnet +standardOptions.withMappings(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMappingsMixin + +```jsonnet +standardOptions.withMappingsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMax + +```jsonnet +standardOptions.withMax(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withMin + +```jsonnet +standardOptions.withMin(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withNoValue + +```jsonnet +standardOptions.withNoValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Alternative to empty string +#### fn standardOptions.withOverrides + +```jsonnet +standardOptions.withOverrides(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withOverridesMixin + +```jsonnet +standardOptions.withOverridesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withPath + +```jsonnet +standardOptions.withPath(value) +``` + +PARAMETERS: + +* **value** (`string`) + +An explicit path to the field in the datasource. When the frame meta includes a path, +This will default to `${frame.meta.path}/${field.name} + +When defined, this value can be used as an identifier within the datasource scope, and +may be used to update the results +#### fn standardOptions.withUnit + +```jsonnet +standardOptions.withUnit(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Numeric Options +#### obj standardOptions.color + + +##### fn standardOptions.color.withFixedColor + +```jsonnet +standardOptions.color.withFixedColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Stores the fixed color value if mode is fixed +##### fn standardOptions.color.withMode + +```jsonnet +standardOptions.color.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The main color scheme mode +##### fn standardOptions.color.withSeriesBy + +```jsonnet +standardOptions.color.withSeriesBy(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"min"`, `"max"`, `"last"` + +TODO docs +#### obj standardOptions.thresholds + + +##### fn standardOptions.thresholds.withMode + +```jsonnet +standardOptions.thresholds.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"absolute"`, `"percentage"` + + +##### fn standardOptions.thresholds.withSteps + +```jsonnet +standardOptions.thresholds.withSteps(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity +##### fn standardOptions.thresholds.withStepsMixin + +```jsonnet +standardOptions.thresholds.withStepsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/barChart/panelOptions/link.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/barChart/panelOptions/link.md new file mode 100644 index 0000000000..106f9d2edb --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/barChart/panelOptions/link.md @@ -0,0 +1,145 @@ +# link + + + +## Index + +* [`fn withAsDropdown(value=true)`](#fn-withasdropdown) +* [`fn withIcon(value)`](#fn-withicon) +* [`fn withIncludeVars(value=true)`](#fn-withincludevars) +* [`fn withKeepTime(value=true)`](#fn-withkeeptime) +* [`fn withTags(value)`](#fn-withtags) +* [`fn withTagsMixin(value)`](#fn-withtagsmixin) +* [`fn withTargetBlank(value=true)`](#fn-withtargetblank) +* [`fn withTitle(value)`](#fn-withtitle) +* [`fn withTooltip(value)`](#fn-withtooltip) +* [`fn withType(value)`](#fn-withtype) +* [`fn withUrl(value)`](#fn-withurl) + +## Fields + +### fn withAsDropdown + +```jsonnet +withAsDropdown(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withIcon + +```jsonnet +withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withIncludeVars + +```jsonnet +withIncludeVars(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withKeepTime + +```jsonnet +withKeepTime(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTags + +```jsonnet +withTags(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTagsMixin + +```jsonnet +withTagsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTargetBlank + +```jsonnet +withTargetBlank(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTitle + +```jsonnet +withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withTooltip + +```jsonnet +withTooltip(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withType + +```jsonnet +withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"link"`, `"dashboards"` + +TODO docs +### fn withUrl + +```jsonnet +withUrl(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/barChart/queryOptions/transformation.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/barChart/queryOptions/transformation.md new file mode 100644 index 0000000000..dc832f653d --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/barChart/queryOptions/transformation.md @@ -0,0 +1,99 @@ +# transformation + + + +## Index + +* [`fn withDisabled(value=true)`](#fn-withdisabled) +* [`fn withFilter(value)`](#fn-withfilter) +* [`fn withFilterMixin(value)`](#fn-withfiltermixin) +* [`fn withId(value)`](#fn-withid) +* [`fn withOptions(value)`](#fn-withoptions) +* [`obj filter`](#obj-filter) + * [`fn withId(value="")`](#fn-filterwithid) + * [`fn withOptions(value)`](#fn-filterwithoptions) + +## Fields + +### fn withDisabled + +```jsonnet +withDisabled(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Disabled transformations are skipped +### fn withFilter + +```jsonnet +withFilter(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withFilterMixin + +```jsonnet +withFilterMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withId + +```jsonnet +withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Unique identifier of transformer +### fn withOptions + +```jsonnet +withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Options to be passed to the transformer +Valid options depend on the transformer id +### obj filter + + +#### fn filter.withId + +```jsonnet +filter.withId(value="") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `""` + + +#### fn filter.withOptions + +```jsonnet +filter.withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/barChart/standardOptions/mapping.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/barChart/standardOptions/mapping.md new file mode 100644 index 0000000000..93296972e8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/barChart/standardOptions/mapping.md @@ -0,0 +1,469 @@ +# mapping + + + +## Index + +* [`obj RangeMap`](#obj-rangemap) + * [`fn withOptions(value)`](#fn-rangemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-rangemapwithoptionsmixin) + * [`fn withType(value)`](#fn-rangemapwithtype) + * [`obj options`](#obj-rangemapoptions) + * [`fn withFrom(value)`](#fn-rangemapoptionswithfrom) + * [`fn withResult(value)`](#fn-rangemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-rangemapoptionswithresultmixin) + * [`fn withTo(value)`](#fn-rangemapoptionswithto) + * [`obj result`](#obj-rangemapoptionsresult) + * [`fn withColor(value)`](#fn-rangemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-rangemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-rangemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-rangemapoptionsresultwithtext) +* [`obj RegexMap`](#obj-regexmap) + * [`fn withOptions(value)`](#fn-regexmapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-regexmapwithoptionsmixin) + * [`fn withType(value)`](#fn-regexmapwithtype) + * [`obj options`](#obj-regexmapoptions) + * [`fn withPattern(value)`](#fn-regexmapoptionswithpattern) + * [`fn withResult(value)`](#fn-regexmapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-regexmapoptionswithresultmixin) + * [`obj result`](#obj-regexmapoptionsresult) + * [`fn withColor(value)`](#fn-regexmapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-regexmapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-regexmapoptionsresultwithindex) + * [`fn withText(value)`](#fn-regexmapoptionsresultwithtext) +* [`obj SpecialValueMap`](#obj-specialvaluemap) + * [`fn withOptions(value)`](#fn-specialvaluemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-specialvaluemapwithoptionsmixin) + * [`fn withType(value)`](#fn-specialvaluemapwithtype) + * [`obj options`](#obj-specialvaluemapoptions) + * [`fn withMatch(value)`](#fn-specialvaluemapoptionswithmatch) + * [`fn withPattern(value)`](#fn-specialvaluemapoptionswithpattern) + * [`fn withResult(value)`](#fn-specialvaluemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-specialvaluemapoptionswithresultmixin) + * [`obj result`](#obj-specialvaluemapoptionsresult) + * [`fn withColor(value)`](#fn-specialvaluemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-specialvaluemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-specialvaluemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-specialvaluemapoptionsresultwithtext) +* [`obj ValueMap`](#obj-valuemap) + * [`fn withOptions(value)`](#fn-valuemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-valuemapwithoptionsmixin) + * [`fn withType(value)`](#fn-valuemapwithtype) + +## Fields + +### obj RangeMap + + +#### fn RangeMap.withOptions + +```jsonnet +RangeMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withOptionsMixin + +```jsonnet +RangeMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withType + +```jsonnet +RangeMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RangeMap.options + + +##### fn RangeMap.options.withFrom + +```jsonnet +RangeMap.options.withFrom(value) +``` + +PARAMETERS: + +* **value** (`number`) + +to and from are `number | null` in current ts, really not sure what to do +##### fn RangeMap.options.withResult + +```jsonnet +RangeMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withResultMixin + +```jsonnet +RangeMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withTo + +```jsonnet +RangeMap.options.withTo(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +##### obj RangeMap.options.result + + +###### fn RangeMap.options.result.withColor + +```jsonnet +RangeMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIcon + +```jsonnet +RangeMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIndex + +```jsonnet +RangeMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RangeMap.options.result.withText + +```jsonnet +RangeMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj RegexMap + + +#### fn RegexMap.withOptions + +```jsonnet +RegexMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withOptionsMixin + +```jsonnet +RegexMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withType + +```jsonnet +RegexMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RegexMap.options + + +##### fn RegexMap.options.withPattern + +```jsonnet +RegexMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn RegexMap.options.withResult + +```jsonnet +RegexMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RegexMap.options.withResultMixin + +```jsonnet +RegexMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj RegexMap.options.result + + +###### fn RegexMap.options.result.withColor + +```jsonnet +RegexMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIcon + +```jsonnet +RegexMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIndex + +```jsonnet +RegexMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RegexMap.options.result.withText + +```jsonnet +RegexMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj SpecialValueMap + + +#### fn SpecialValueMap.withOptions + +```jsonnet +SpecialValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withOptionsMixin + +```jsonnet +SpecialValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withType + +```jsonnet +SpecialValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj SpecialValueMap.options + + +##### fn SpecialValueMap.options.withMatch + +```jsonnet +SpecialValueMap.options.withMatch(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"true"`, `"false"` + + +##### fn SpecialValueMap.options.withPattern + +```jsonnet +SpecialValueMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn SpecialValueMap.options.withResult + +```jsonnet +SpecialValueMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn SpecialValueMap.options.withResultMixin + +```jsonnet +SpecialValueMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj SpecialValueMap.options.result + + +###### fn SpecialValueMap.options.result.withColor + +```jsonnet +SpecialValueMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIcon + +```jsonnet +SpecialValueMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIndex + +```jsonnet +SpecialValueMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn SpecialValueMap.options.result.withText + +```jsonnet +SpecialValueMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj ValueMap + + +#### fn ValueMap.withOptions + +```jsonnet +ValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withOptionsMixin + +```jsonnet +ValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withType + +```jsonnet +ValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/barChart/standardOptions/override.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/barChart/standardOptions/override.md new file mode 100644 index 0000000000..154f3dbdac --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/barChart/standardOptions/override.md @@ -0,0 +1,244 @@ +# override + +Overrides allow you to customize visualization settings for specific fields or +series. This is accomplished by adding an override rule that targets +a particular set of fields and that can each define multiple options. + +```jsonnet +override.byType.new('number') ++ override.byType.withPropertiesFromOptions( + panel.standardOptions.withDecimals(2) + + panel.standardOptions.withUnit('s') +) +``` + + +## Index + +* [`obj byName`](#obj-byname) + * [`fn new(value)`](#fn-bynamenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bynamewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bynamewithproperty) +* [`obj byQuery`](#obj-byquery) + * [`fn new(value)`](#fn-byquerynew) + * [`fn withPropertiesFromOptions(options)`](#fn-byquerywithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byquerywithproperty) +* [`obj byRegexp`](#obj-byregexp) + * [`fn new(value)`](#fn-byregexpnew) + * [`fn withPropertiesFromOptions(options)`](#fn-byregexpwithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byregexpwithproperty) +* [`obj byType`](#obj-bytype) + * [`fn new(value)`](#fn-bytypenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bytypewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bytypewithproperty) +* [`obj byValue`](#obj-byvalue) + * [`fn new(value)`](#fn-byvaluenew) + * [`fn withPropertiesFromOptions(options)`](#fn-byvaluewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byvaluewithproperty) + +## Fields + +### obj byName + + +#### fn byName.new + +```jsonnet +byName.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byName`. +#### fn byName.withPropertiesFromOptions + +```jsonnet +byName.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byName.withProperty + +```jsonnet +byName.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byQuery + + +#### fn byQuery.new + +```jsonnet +byQuery.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byQuery`. +#### fn byQuery.withPropertiesFromOptions + +```jsonnet +byQuery.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byQuery.withProperty + +```jsonnet +byQuery.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byRegexp + + +#### fn byRegexp.new + +```jsonnet +byRegexp.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byRegexp`. +#### fn byRegexp.withPropertiesFromOptions + +```jsonnet +byRegexp.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byRegexp.withProperty + +```jsonnet +byRegexp.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byType + + +#### fn byType.new + +```jsonnet +byType.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byType`. +#### fn byType.withPropertiesFromOptions + +```jsonnet +byType.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byType.withProperty + +```jsonnet +byType.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byValue + + +#### fn byValue.new + +```jsonnet +byValue.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byValue`. +#### fn byValue.withPropertiesFromOptions + +```jsonnet +byValue.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byValue.withProperty + +```jsonnet +byValue.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/barChart/standardOptions/threshold/step.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/barChart/standardOptions/threshold/step.md new file mode 100644 index 0000000000..dd2dd227ff --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/barChart/standardOptions/threshold/step.md @@ -0,0 +1,60 @@ +# threshold.step + + + +## Index + +* [`fn withColor(value)`](#fn-withcolor) +* [`fn withIndex(value)`](#fn-withindex) +* [`fn withState(value)`](#fn-withstate) +* [`fn withValue(value)`](#fn-withvalue) + +## Fields + +### fn withColor + +```jsonnet +withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +### fn withIndex + +```jsonnet +withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Threshold index, an old property that is not needed an should only appear in older dashboards +### fn withState + +```jsonnet +withState(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO are the values here enumerable into a disjunction? +Some seem to be listed in typescript comment +### fn withValue + +```jsonnet +withValue(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +FIXME the corresponding typescript field is required/non-optional, but nulls currently appear here when serializing -Infinity to JSON \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/barGauge/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/barGauge/index.md new file mode 100644 index 0000000000..c9f8277d70 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/barGauge/index.md @@ -0,0 +1,788 @@ +# barGauge + +grafonnet.panel.barGauge + +## Subpackages + +* [panelOptions.link](panelOptions/link.md) +* [queryOptions.transformation](queryOptions/transformation.md) +* [standardOptions.mapping](standardOptions/mapping.md) +* [standardOptions.override](standardOptions/override.md) +* [standardOptions.threshold.step](standardOptions/threshold/step.md) + +## Index + +* [`fn new(title)`](#fn-new) +* [`obj libraryPanel`](#obj-librarypanel) + * [`fn withName(value)`](#fn-librarypanelwithname) + * [`fn withUid(value)`](#fn-librarypanelwithuid) +* [`obj options`](#obj-options) + * [`fn withDisplayMode(value)`](#fn-optionswithdisplaymode) + * [`fn withMinVizHeight(value=10)`](#fn-optionswithminvizheight) + * [`fn withMinVizWidth(value=0)`](#fn-optionswithminvizwidth) + * [`fn withOrientation(value)`](#fn-optionswithorientation) + * [`fn withReduceOptions(value)`](#fn-optionswithreduceoptions) + * [`fn withReduceOptionsMixin(value)`](#fn-optionswithreduceoptionsmixin) + * [`fn withShowUnfilled(value=true)`](#fn-optionswithshowunfilled) + * [`fn withText(value)`](#fn-optionswithtext) + * [`fn withTextMixin(value)`](#fn-optionswithtextmixin) + * [`fn withValueMode(value)`](#fn-optionswithvaluemode) + * [`obj reduceOptions`](#obj-optionsreduceoptions) + * [`fn withCalcs(value)`](#fn-optionsreduceoptionswithcalcs) + * [`fn withCalcsMixin(value)`](#fn-optionsreduceoptionswithcalcsmixin) + * [`fn withFields(value)`](#fn-optionsreduceoptionswithfields) + * [`fn withLimit(value)`](#fn-optionsreduceoptionswithlimit) + * [`fn withValues(value=true)`](#fn-optionsreduceoptionswithvalues) + * [`obj text`](#obj-optionstext) + * [`fn withTitleSize(value)`](#fn-optionstextwithtitlesize) + * [`fn withValueSize(value)`](#fn-optionstextwithvaluesize) +* [`obj panelOptions`](#obj-paneloptions) + * [`fn withDescription(value)`](#fn-paneloptionswithdescription) + * [`fn withGridPos(h="null", w="null", x="null", y="null")`](#fn-paneloptionswithgridpos) + * [`fn withLinks(value)`](#fn-paneloptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-paneloptionswithlinksmixin) + * [`fn withRepeat(value)`](#fn-paneloptionswithrepeat) + * [`fn withRepeatDirection(value="h")`](#fn-paneloptionswithrepeatdirection) + * [`fn withTitle(value)`](#fn-paneloptionswithtitle) + * [`fn withTransparent(value=true)`](#fn-paneloptionswithtransparent) +* [`obj queryOptions`](#obj-queryoptions) + * [`fn withDatasource(type, uid)`](#fn-queryoptionswithdatasource) + * [`fn withDatasourceMixin(value)`](#fn-queryoptionswithdatasourcemixin) + * [`fn withInterval(value)`](#fn-queryoptionswithinterval) + * [`fn withMaxDataPoints(value)`](#fn-queryoptionswithmaxdatapoints) + * [`fn withTargets(value)`](#fn-queryoptionswithtargets) + * [`fn withTargetsMixin(value)`](#fn-queryoptionswithtargetsmixin) + * [`fn withTimeFrom(value)`](#fn-queryoptionswithtimefrom) + * [`fn withTimeShift(value)`](#fn-queryoptionswithtimeshift) + * [`fn withTransformations(value)`](#fn-queryoptionswithtransformations) + * [`fn withTransformationsMixin(value)`](#fn-queryoptionswithtransformationsmixin) +* [`obj standardOptions`](#obj-standardoptions) + * [`fn withDecimals(value)`](#fn-standardoptionswithdecimals) + * [`fn withDisplayName(value)`](#fn-standardoptionswithdisplayname) + * [`fn withFilterable(value=true)`](#fn-standardoptionswithfilterable) + * [`fn withLinks(value)`](#fn-standardoptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-standardoptionswithlinksmixin) + * [`fn withMappings(value)`](#fn-standardoptionswithmappings) + * [`fn withMappingsMixin(value)`](#fn-standardoptionswithmappingsmixin) + * [`fn withMax(value)`](#fn-standardoptionswithmax) + * [`fn withMin(value)`](#fn-standardoptionswithmin) + * [`fn withNoValue(value)`](#fn-standardoptionswithnovalue) + * [`fn withOverrides(value)`](#fn-standardoptionswithoverrides) + * [`fn withOverridesMixin(value)`](#fn-standardoptionswithoverridesmixin) + * [`fn withPath(value)`](#fn-standardoptionswithpath) + * [`fn withUnit(value)`](#fn-standardoptionswithunit) + * [`obj color`](#obj-standardoptionscolor) + * [`fn withFixedColor(value)`](#fn-standardoptionscolorwithfixedcolor) + * [`fn withMode(value)`](#fn-standardoptionscolorwithmode) + * [`fn withSeriesBy(value)`](#fn-standardoptionscolorwithseriesby) + * [`obj thresholds`](#obj-standardoptionsthresholds) + * [`fn withMode(value)`](#fn-standardoptionsthresholdswithmode) + * [`fn withSteps(value)`](#fn-standardoptionsthresholdswithsteps) + * [`fn withStepsMixin(value)`](#fn-standardoptionsthresholdswithstepsmixin) + +## Fields + +### fn new + +```jsonnet +new(title) +``` + +PARAMETERS: + +* **title** (`string`) + +Creates a new barGauge panel with a title. +### obj libraryPanel + + +#### fn libraryPanel.withName + +```jsonnet +libraryPanel.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn libraryPanel.withUid + +```jsonnet +libraryPanel.withUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj options + + +#### fn options.withDisplayMode + +```jsonnet +options.withDisplayMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"basic"`, `"lcd"`, `"gradient"` + +Enum expressing the possible display modes +for the bar gauge component of Grafana UI +#### fn options.withMinVizHeight + +```jsonnet +options.withMinVizHeight(value=10) +``` + +PARAMETERS: + +* **value** (`integer`) + - default value: `10` + + +#### fn options.withMinVizWidth + +```jsonnet +options.withMinVizWidth(value=0) +``` + +PARAMETERS: + +* **value** (`integer`) + - default value: `0` + + +#### fn options.withOrientation + +```jsonnet +options.withOrientation(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"auto"`, `"vertical"`, `"horizontal"` + +TODO docs +#### fn options.withReduceOptions + +```jsonnet +options.withReduceOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withReduceOptionsMixin + +```jsonnet +options.withReduceOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withShowUnfilled + +```jsonnet +options.withShowUnfilled(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +#### fn options.withText + +```jsonnet +options.withText(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withTextMixin + +```jsonnet +options.withTextMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withValueMode + +```jsonnet +options.withValueMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"color"`, `"text"`, `"hidden"` + +Allows for the table cell gauge display type to set the gauge mode. +#### obj options.reduceOptions + + +##### fn options.reduceOptions.withCalcs + +```jsonnet +options.reduceOptions.withCalcs(value) +``` + +PARAMETERS: + +* **value** (`array`) + +When !values, pick one value for the whole field +##### fn options.reduceOptions.withCalcsMixin + +```jsonnet +options.reduceOptions.withCalcsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +When !values, pick one value for the whole field +##### fn options.reduceOptions.withFields + +```jsonnet +options.reduceOptions.withFields(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Which fields to show. By default this is only numeric fields +##### fn options.reduceOptions.withLimit + +```jsonnet +options.reduceOptions.withLimit(value) +``` + +PARAMETERS: + +* **value** (`number`) + +if showing all values limit +##### fn options.reduceOptions.withValues + +```jsonnet +options.reduceOptions.withValues(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +If true show each row value +#### obj options.text + + +##### fn options.text.withTitleSize + +```jsonnet +options.text.withTitleSize(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Explicit title text size +##### fn options.text.withValueSize + +```jsonnet +options.text.withValueSize(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Explicit value text size +### obj panelOptions + + +#### fn panelOptions.withDescription + +```jsonnet +panelOptions.withDescription(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Description. +#### fn panelOptions.withGridPos + +```jsonnet +panelOptions.withGridPos(h="null", w="null", x="null", y="null") +``` + +PARAMETERS: + +* **h** (`number`) + - default value: `"null"` +* **w** (`number`) + - default value: `"null"` +* **x** (`number`) + - default value: `"null"` +* **y** (`number`) + - default value: `"null"` + +`withGridPos` configures the height, width and xy coordinates of the panel. Also see `grafonnet.util.grid` for helper functions to calculate these fields. + +All arguments default to `null`, which means they will remain unchanged or unset. + +#### fn panelOptions.withLinks + +```jsonnet +panelOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withLinksMixin + +```jsonnet +panelOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withRepeat + +```jsonnet +panelOptions.withRepeat(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of template variable to repeat for. +#### fn panelOptions.withRepeatDirection + +```jsonnet +panelOptions.withRepeatDirection(value="h") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"h"` + - valid values: `"h"`, `"v"` + +Direction to repeat in if 'repeat' is set. +"h" for horizontal, "v" for vertical. +TODO this is probably optional +#### fn panelOptions.withTitle + +```jsonnet +panelOptions.withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Panel title. +#### fn panelOptions.withTransparent + +```jsonnet +panelOptions.withTransparent(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Whether to display the panel without a background. +### obj queryOptions + + +#### fn queryOptions.withDatasource + +```jsonnet +queryOptions.withDatasource(type, uid) +``` + +PARAMETERS: + +* **type** (`string`) +* **uid** (`string`) + +`withDatasource` sets the datasource for all queries in a panel. + +The default datasource for a panel is set to 'Mixed datasource' so panels can be datasource agnostic, which is a lot more interesting from a reusability standpoint. Note that this requires query targets to explicitly set datasource for the same reason. + +#### fn queryOptions.withDatasourceMixin + +```jsonnet +queryOptions.withDatasourceMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +The datasource used in all targets. +#### fn queryOptions.withInterval + +```jsonnet +queryOptions.withInterval(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withMaxDataPoints + +```jsonnet +queryOptions.withMaxDataPoints(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +#### fn queryOptions.withTargets + +```jsonnet +queryOptions.withTargets(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTargetsMixin + +```jsonnet +queryOptions.withTargetsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTimeFrom + +```jsonnet +queryOptions.withTimeFrom(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTimeShift + +```jsonnet +queryOptions.withTimeShift(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTransformations + +```jsonnet +queryOptions.withTransformations(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn queryOptions.withTransformationsMixin + +```jsonnet +queryOptions.withTransformationsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### obj standardOptions + + +#### fn standardOptions.withDecimals + +```jsonnet +standardOptions.withDecimals(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Significant digits (for display) +#### fn standardOptions.withDisplayName + +```jsonnet +standardOptions.withDisplayName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The display value for this field. This supports template variables blank is auto +#### fn standardOptions.withFilterable + +```jsonnet +standardOptions.withFilterable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +True if data source field supports ad-hoc filters +#### fn standardOptions.withLinks + +```jsonnet +standardOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withLinksMixin + +```jsonnet +standardOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withMappings + +```jsonnet +standardOptions.withMappings(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMappingsMixin + +```jsonnet +standardOptions.withMappingsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMax + +```jsonnet +standardOptions.withMax(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withMin + +```jsonnet +standardOptions.withMin(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withNoValue + +```jsonnet +standardOptions.withNoValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Alternative to empty string +#### fn standardOptions.withOverrides + +```jsonnet +standardOptions.withOverrides(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withOverridesMixin + +```jsonnet +standardOptions.withOverridesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withPath + +```jsonnet +standardOptions.withPath(value) +``` + +PARAMETERS: + +* **value** (`string`) + +An explicit path to the field in the datasource. When the frame meta includes a path, +This will default to `${frame.meta.path}/${field.name} + +When defined, this value can be used as an identifier within the datasource scope, and +may be used to update the results +#### fn standardOptions.withUnit + +```jsonnet +standardOptions.withUnit(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Numeric Options +#### obj standardOptions.color + + +##### fn standardOptions.color.withFixedColor + +```jsonnet +standardOptions.color.withFixedColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Stores the fixed color value if mode is fixed +##### fn standardOptions.color.withMode + +```jsonnet +standardOptions.color.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The main color scheme mode +##### fn standardOptions.color.withSeriesBy + +```jsonnet +standardOptions.color.withSeriesBy(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"min"`, `"max"`, `"last"` + +TODO docs +#### obj standardOptions.thresholds + + +##### fn standardOptions.thresholds.withMode + +```jsonnet +standardOptions.thresholds.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"absolute"`, `"percentage"` + + +##### fn standardOptions.thresholds.withSteps + +```jsonnet +standardOptions.thresholds.withSteps(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity +##### fn standardOptions.thresholds.withStepsMixin + +```jsonnet +standardOptions.thresholds.withStepsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/barGauge/panelOptions/link.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/barGauge/panelOptions/link.md new file mode 100644 index 0000000000..106f9d2edb --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/barGauge/panelOptions/link.md @@ -0,0 +1,145 @@ +# link + + + +## Index + +* [`fn withAsDropdown(value=true)`](#fn-withasdropdown) +* [`fn withIcon(value)`](#fn-withicon) +* [`fn withIncludeVars(value=true)`](#fn-withincludevars) +* [`fn withKeepTime(value=true)`](#fn-withkeeptime) +* [`fn withTags(value)`](#fn-withtags) +* [`fn withTagsMixin(value)`](#fn-withtagsmixin) +* [`fn withTargetBlank(value=true)`](#fn-withtargetblank) +* [`fn withTitle(value)`](#fn-withtitle) +* [`fn withTooltip(value)`](#fn-withtooltip) +* [`fn withType(value)`](#fn-withtype) +* [`fn withUrl(value)`](#fn-withurl) + +## Fields + +### fn withAsDropdown + +```jsonnet +withAsDropdown(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withIcon + +```jsonnet +withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withIncludeVars + +```jsonnet +withIncludeVars(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withKeepTime + +```jsonnet +withKeepTime(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTags + +```jsonnet +withTags(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTagsMixin + +```jsonnet +withTagsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTargetBlank + +```jsonnet +withTargetBlank(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTitle + +```jsonnet +withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withTooltip + +```jsonnet +withTooltip(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withType + +```jsonnet +withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"link"`, `"dashboards"` + +TODO docs +### fn withUrl + +```jsonnet +withUrl(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/barGauge/queryOptions/transformation.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/barGauge/queryOptions/transformation.md new file mode 100644 index 0000000000..dc832f653d --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/barGauge/queryOptions/transformation.md @@ -0,0 +1,99 @@ +# transformation + + + +## Index + +* [`fn withDisabled(value=true)`](#fn-withdisabled) +* [`fn withFilter(value)`](#fn-withfilter) +* [`fn withFilterMixin(value)`](#fn-withfiltermixin) +* [`fn withId(value)`](#fn-withid) +* [`fn withOptions(value)`](#fn-withoptions) +* [`obj filter`](#obj-filter) + * [`fn withId(value="")`](#fn-filterwithid) + * [`fn withOptions(value)`](#fn-filterwithoptions) + +## Fields + +### fn withDisabled + +```jsonnet +withDisabled(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Disabled transformations are skipped +### fn withFilter + +```jsonnet +withFilter(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withFilterMixin + +```jsonnet +withFilterMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withId + +```jsonnet +withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Unique identifier of transformer +### fn withOptions + +```jsonnet +withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Options to be passed to the transformer +Valid options depend on the transformer id +### obj filter + + +#### fn filter.withId + +```jsonnet +filter.withId(value="") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `""` + + +#### fn filter.withOptions + +```jsonnet +filter.withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/barGauge/standardOptions/mapping.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/barGauge/standardOptions/mapping.md new file mode 100644 index 0000000000..93296972e8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/barGauge/standardOptions/mapping.md @@ -0,0 +1,469 @@ +# mapping + + + +## Index + +* [`obj RangeMap`](#obj-rangemap) + * [`fn withOptions(value)`](#fn-rangemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-rangemapwithoptionsmixin) + * [`fn withType(value)`](#fn-rangemapwithtype) + * [`obj options`](#obj-rangemapoptions) + * [`fn withFrom(value)`](#fn-rangemapoptionswithfrom) + * [`fn withResult(value)`](#fn-rangemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-rangemapoptionswithresultmixin) + * [`fn withTo(value)`](#fn-rangemapoptionswithto) + * [`obj result`](#obj-rangemapoptionsresult) + * [`fn withColor(value)`](#fn-rangemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-rangemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-rangemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-rangemapoptionsresultwithtext) +* [`obj RegexMap`](#obj-regexmap) + * [`fn withOptions(value)`](#fn-regexmapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-regexmapwithoptionsmixin) + * [`fn withType(value)`](#fn-regexmapwithtype) + * [`obj options`](#obj-regexmapoptions) + * [`fn withPattern(value)`](#fn-regexmapoptionswithpattern) + * [`fn withResult(value)`](#fn-regexmapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-regexmapoptionswithresultmixin) + * [`obj result`](#obj-regexmapoptionsresult) + * [`fn withColor(value)`](#fn-regexmapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-regexmapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-regexmapoptionsresultwithindex) + * [`fn withText(value)`](#fn-regexmapoptionsresultwithtext) +* [`obj SpecialValueMap`](#obj-specialvaluemap) + * [`fn withOptions(value)`](#fn-specialvaluemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-specialvaluemapwithoptionsmixin) + * [`fn withType(value)`](#fn-specialvaluemapwithtype) + * [`obj options`](#obj-specialvaluemapoptions) + * [`fn withMatch(value)`](#fn-specialvaluemapoptionswithmatch) + * [`fn withPattern(value)`](#fn-specialvaluemapoptionswithpattern) + * [`fn withResult(value)`](#fn-specialvaluemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-specialvaluemapoptionswithresultmixin) + * [`obj result`](#obj-specialvaluemapoptionsresult) + * [`fn withColor(value)`](#fn-specialvaluemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-specialvaluemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-specialvaluemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-specialvaluemapoptionsresultwithtext) +* [`obj ValueMap`](#obj-valuemap) + * [`fn withOptions(value)`](#fn-valuemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-valuemapwithoptionsmixin) + * [`fn withType(value)`](#fn-valuemapwithtype) + +## Fields + +### obj RangeMap + + +#### fn RangeMap.withOptions + +```jsonnet +RangeMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withOptionsMixin + +```jsonnet +RangeMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withType + +```jsonnet +RangeMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RangeMap.options + + +##### fn RangeMap.options.withFrom + +```jsonnet +RangeMap.options.withFrom(value) +``` + +PARAMETERS: + +* **value** (`number`) + +to and from are `number | null` in current ts, really not sure what to do +##### fn RangeMap.options.withResult + +```jsonnet +RangeMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withResultMixin + +```jsonnet +RangeMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withTo + +```jsonnet +RangeMap.options.withTo(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +##### obj RangeMap.options.result + + +###### fn RangeMap.options.result.withColor + +```jsonnet +RangeMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIcon + +```jsonnet +RangeMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIndex + +```jsonnet +RangeMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RangeMap.options.result.withText + +```jsonnet +RangeMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj RegexMap + + +#### fn RegexMap.withOptions + +```jsonnet +RegexMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withOptionsMixin + +```jsonnet +RegexMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withType + +```jsonnet +RegexMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RegexMap.options + + +##### fn RegexMap.options.withPattern + +```jsonnet +RegexMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn RegexMap.options.withResult + +```jsonnet +RegexMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RegexMap.options.withResultMixin + +```jsonnet +RegexMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj RegexMap.options.result + + +###### fn RegexMap.options.result.withColor + +```jsonnet +RegexMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIcon + +```jsonnet +RegexMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIndex + +```jsonnet +RegexMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RegexMap.options.result.withText + +```jsonnet +RegexMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj SpecialValueMap + + +#### fn SpecialValueMap.withOptions + +```jsonnet +SpecialValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withOptionsMixin + +```jsonnet +SpecialValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withType + +```jsonnet +SpecialValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj SpecialValueMap.options + + +##### fn SpecialValueMap.options.withMatch + +```jsonnet +SpecialValueMap.options.withMatch(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"true"`, `"false"` + + +##### fn SpecialValueMap.options.withPattern + +```jsonnet +SpecialValueMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn SpecialValueMap.options.withResult + +```jsonnet +SpecialValueMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn SpecialValueMap.options.withResultMixin + +```jsonnet +SpecialValueMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj SpecialValueMap.options.result + + +###### fn SpecialValueMap.options.result.withColor + +```jsonnet +SpecialValueMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIcon + +```jsonnet +SpecialValueMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIndex + +```jsonnet +SpecialValueMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn SpecialValueMap.options.result.withText + +```jsonnet +SpecialValueMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj ValueMap + + +#### fn ValueMap.withOptions + +```jsonnet +ValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withOptionsMixin + +```jsonnet +ValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withType + +```jsonnet +ValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/barGauge/standardOptions/override.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/barGauge/standardOptions/override.md new file mode 100644 index 0000000000..154f3dbdac --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/barGauge/standardOptions/override.md @@ -0,0 +1,244 @@ +# override + +Overrides allow you to customize visualization settings for specific fields or +series. This is accomplished by adding an override rule that targets +a particular set of fields and that can each define multiple options. + +```jsonnet +override.byType.new('number') ++ override.byType.withPropertiesFromOptions( + panel.standardOptions.withDecimals(2) + + panel.standardOptions.withUnit('s') +) +``` + + +## Index + +* [`obj byName`](#obj-byname) + * [`fn new(value)`](#fn-bynamenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bynamewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bynamewithproperty) +* [`obj byQuery`](#obj-byquery) + * [`fn new(value)`](#fn-byquerynew) + * [`fn withPropertiesFromOptions(options)`](#fn-byquerywithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byquerywithproperty) +* [`obj byRegexp`](#obj-byregexp) + * [`fn new(value)`](#fn-byregexpnew) + * [`fn withPropertiesFromOptions(options)`](#fn-byregexpwithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byregexpwithproperty) +* [`obj byType`](#obj-bytype) + * [`fn new(value)`](#fn-bytypenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bytypewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bytypewithproperty) +* [`obj byValue`](#obj-byvalue) + * [`fn new(value)`](#fn-byvaluenew) + * [`fn withPropertiesFromOptions(options)`](#fn-byvaluewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byvaluewithproperty) + +## Fields + +### obj byName + + +#### fn byName.new + +```jsonnet +byName.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byName`. +#### fn byName.withPropertiesFromOptions + +```jsonnet +byName.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byName.withProperty + +```jsonnet +byName.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byQuery + + +#### fn byQuery.new + +```jsonnet +byQuery.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byQuery`. +#### fn byQuery.withPropertiesFromOptions + +```jsonnet +byQuery.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byQuery.withProperty + +```jsonnet +byQuery.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byRegexp + + +#### fn byRegexp.new + +```jsonnet +byRegexp.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byRegexp`. +#### fn byRegexp.withPropertiesFromOptions + +```jsonnet +byRegexp.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byRegexp.withProperty + +```jsonnet +byRegexp.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byType + + +#### fn byType.new + +```jsonnet +byType.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byType`. +#### fn byType.withPropertiesFromOptions + +```jsonnet +byType.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byType.withProperty + +```jsonnet +byType.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byValue + + +#### fn byValue.new + +```jsonnet +byValue.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byValue`. +#### fn byValue.withPropertiesFromOptions + +```jsonnet +byValue.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byValue.withProperty + +```jsonnet +byValue.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/barGauge/standardOptions/threshold/step.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/barGauge/standardOptions/threshold/step.md new file mode 100644 index 0000000000..dd2dd227ff --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/barGauge/standardOptions/threshold/step.md @@ -0,0 +1,60 @@ +# threshold.step + + + +## Index + +* [`fn withColor(value)`](#fn-withcolor) +* [`fn withIndex(value)`](#fn-withindex) +* [`fn withState(value)`](#fn-withstate) +* [`fn withValue(value)`](#fn-withvalue) + +## Fields + +### fn withColor + +```jsonnet +withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +### fn withIndex + +```jsonnet +withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Threshold index, an old property that is not needed an should only appear in older dashboards +### fn withState + +```jsonnet +withState(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO are the values here enumerable into a disjunction? +Some seem to be listed in typescript comment +### fn withValue + +```jsonnet +withValue(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +FIXME the corresponding typescript field is required/non-optional, but nulls currently appear here when serializing -Infinity to JSON \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/candlestick/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/candlestick/index.md new file mode 100644 index 0000000000..fc422189df --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/candlestick/index.md @@ -0,0 +1,564 @@ +# candlestick + +grafonnet.panel.candlestick + +## Subpackages + +* [panelOptions.link](panelOptions/link.md) +* [queryOptions.transformation](queryOptions/transformation.md) +* [standardOptions.mapping](standardOptions/mapping.md) +* [standardOptions.override](standardOptions/override.md) +* [standardOptions.threshold.step](standardOptions/threshold/step.md) + +## Index + +* [`fn new(title)`](#fn-new) +* [`obj libraryPanel`](#obj-librarypanel) + * [`fn withName(value)`](#fn-librarypanelwithname) + * [`fn withUid(value)`](#fn-librarypanelwithuid) +* [`obj panelOptions`](#obj-paneloptions) + * [`fn withDescription(value)`](#fn-paneloptionswithdescription) + * [`fn withGridPos(h="null", w="null", x="null", y="null")`](#fn-paneloptionswithgridpos) + * [`fn withLinks(value)`](#fn-paneloptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-paneloptionswithlinksmixin) + * [`fn withRepeat(value)`](#fn-paneloptionswithrepeat) + * [`fn withRepeatDirection(value="h")`](#fn-paneloptionswithrepeatdirection) + * [`fn withTitle(value)`](#fn-paneloptionswithtitle) + * [`fn withTransparent(value=true)`](#fn-paneloptionswithtransparent) +* [`obj queryOptions`](#obj-queryoptions) + * [`fn withDatasource(type, uid)`](#fn-queryoptionswithdatasource) + * [`fn withDatasourceMixin(value)`](#fn-queryoptionswithdatasourcemixin) + * [`fn withInterval(value)`](#fn-queryoptionswithinterval) + * [`fn withMaxDataPoints(value)`](#fn-queryoptionswithmaxdatapoints) + * [`fn withTargets(value)`](#fn-queryoptionswithtargets) + * [`fn withTargetsMixin(value)`](#fn-queryoptionswithtargetsmixin) + * [`fn withTimeFrom(value)`](#fn-queryoptionswithtimefrom) + * [`fn withTimeShift(value)`](#fn-queryoptionswithtimeshift) + * [`fn withTransformations(value)`](#fn-queryoptionswithtransformations) + * [`fn withTransformationsMixin(value)`](#fn-queryoptionswithtransformationsmixin) +* [`obj standardOptions`](#obj-standardoptions) + * [`fn withDecimals(value)`](#fn-standardoptionswithdecimals) + * [`fn withDisplayName(value)`](#fn-standardoptionswithdisplayname) + * [`fn withFilterable(value=true)`](#fn-standardoptionswithfilterable) + * [`fn withLinks(value)`](#fn-standardoptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-standardoptionswithlinksmixin) + * [`fn withMappings(value)`](#fn-standardoptionswithmappings) + * [`fn withMappingsMixin(value)`](#fn-standardoptionswithmappingsmixin) + * [`fn withMax(value)`](#fn-standardoptionswithmax) + * [`fn withMin(value)`](#fn-standardoptionswithmin) + * [`fn withNoValue(value)`](#fn-standardoptionswithnovalue) + * [`fn withOverrides(value)`](#fn-standardoptionswithoverrides) + * [`fn withOverridesMixin(value)`](#fn-standardoptionswithoverridesmixin) + * [`fn withPath(value)`](#fn-standardoptionswithpath) + * [`fn withUnit(value)`](#fn-standardoptionswithunit) + * [`obj color`](#obj-standardoptionscolor) + * [`fn withFixedColor(value)`](#fn-standardoptionscolorwithfixedcolor) + * [`fn withMode(value)`](#fn-standardoptionscolorwithmode) + * [`fn withSeriesBy(value)`](#fn-standardoptionscolorwithseriesby) + * [`obj thresholds`](#obj-standardoptionsthresholds) + * [`fn withMode(value)`](#fn-standardoptionsthresholdswithmode) + * [`fn withSteps(value)`](#fn-standardoptionsthresholdswithsteps) + * [`fn withStepsMixin(value)`](#fn-standardoptionsthresholdswithstepsmixin) + +## Fields + +### fn new + +```jsonnet +new(title) +``` + +PARAMETERS: + +* **title** (`string`) + +Creates a new candlestick panel with a title. +### obj libraryPanel + + +#### fn libraryPanel.withName + +```jsonnet +libraryPanel.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn libraryPanel.withUid + +```jsonnet +libraryPanel.withUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj panelOptions + + +#### fn panelOptions.withDescription + +```jsonnet +panelOptions.withDescription(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Description. +#### fn panelOptions.withGridPos + +```jsonnet +panelOptions.withGridPos(h="null", w="null", x="null", y="null") +``` + +PARAMETERS: + +* **h** (`number`) + - default value: `"null"` +* **w** (`number`) + - default value: `"null"` +* **x** (`number`) + - default value: `"null"` +* **y** (`number`) + - default value: `"null"` + +`withGridPos` configures the height, width and xy coordinates of the panel. Also see `grafonnet.util.grid` for helper functions to calculate these fields. + +All arguments default to `null`, which means they will remain unchanged or unset. + +#### fn panelOptions.withLinks + +```jsonnet +panelOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withLinksMixin + +```jsonnet +panelOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withRepeat + +```jsonnet +panelOptions.withRepeat(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of template variable to repeat for. +#### fn panelOptions.withRepeatDirection + +```jsonnet +panelOptions.withRepeatDirection(value="h") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"h"` + - valid values: `"h"`, `"v"` + +Direction to repeat in if 'repeat' is set. +"h" for horizontal, "v" for vertical. +TODO this is probably optional +#### fn panelOptions.withTitle + +```jsonnet +panelOptions.withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Panel title. +#### fn panelOptions.withTransparent + +```jsonnet +panelOptions.withTransparent(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Whether to display the panel without a background. +### obj queryOptions + + +#### fn queryOptions.withDatasource + +```jsonnet +queryOptions.withDatasource(type, uid) +``` + +PARAMETERS: + +* **type** (`string`) +* **uid** (`string`) + +`withDatasource` sets the datasource for all queries in a panel. + +The default datasource for a panel is set to 'Mixed datasource' so panels can be datasource agnostic, which is a lot more interesting from a reusability standpoint. Note that this requires query targets to explicitly set datasource for the same reason. + +#### fn queryOptions.withDatasourceMixin + +```jsonnet +queryOptions.withDatasourceMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +The datasource used in all targets. +#### fn queryOptions.withInterval + +```jsonnet +queryOptions.withInterval(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withMaxDataPoints + +```jsonnet +queryOptions.withMaxDataPoints(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +#### fn queryOptions.withTargets + +```jsonnet +queryOptions.withTargets(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTargetsMixin + +```jsonnet +queryOptions.withTargetsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTimeFrom + +```jsonnet +queryOptions.withTimeFrom(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTimeShift + +```jsonnet +queryOptions.withTimeShift(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTransformations + +```jsonnet +queryOptions.withTransformations(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn queryOptions.withTransformationsMixin + +```jsonnet +queryOptions.withTransformationsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### obj standardOptions + + +#### fn standardOptions.withDecimals + +```jsonnet +standardOptions.withDecimals(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Significant digits (for display) +#### fn standardOptions.withDisplayName + +```jsonnet +standardOptions.withDisplayName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The display value for this field. This supports template variables blank is auto +#### fn standardOptions.withFilterable + +```jsonnet +standardOptions.withFilterable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +True if data source field supports ad-hoc filters +#### fn standardOptions.withLinks + +```jsonnet +standardOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withLinksMixin + +```jsonnet +standardOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withMappings + +```jsonnet +standardOptions.withMappings(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMappingsMixin + +```jsonnet +standardOptions.withMappingsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMax + +```jsonnet +standardOptions.withMax(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withMin + +```jsonnet +standardOptions.withMin(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withNoValue + +```jsonnet +standardOptions.withNoValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Alternative to empty string +#### fn standardOptions.withOverrides + +```jsonnet +standardOptions.withOverrides(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withOverridesMixin + +```jsonnet +standardOptions.withOverridesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withPath + +```jsonnet +standardOptions.withPath(value) +``` + +PARAMETERS: + +* **value** (`string`) + +An explicit path to the field in the datasource. When the frame meta includes a path, +This will default to `${frame.meta.path}/${field.name} + +When defined, this value can be used as an identifier within the datasource scope, and +may be used to update the results +#### fn standardOptions.withUnit + +```jsonnet +standardOptions.withUnit(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Numeric Options +#### obj standardOptions.color + + +##### fn standardOptions.color.withFixedColor + +```jsonnet +standardOptions.color.withFixedColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Stores the fixed color value if mode is fixed +##### fn standardOptions.color.withMode + +```jsonnet +standardOptions.color.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The main color scheme mode +##### fn standardOptions.color.withSeriesBy + +```jsonnet +standardOptions.color.withSeriesBy(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"min"`, `"max"`, `"last"` + +TODO docs +#### obj standardOptions.thresholds + + +##### fn standardOptions.thresholds.withMode + +```jsonnet +standardOptions.thresholds.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"absolute"`, `"percentage"` + + +##### fn standardOptions.thresholds.withSteps + +```jsonnet +standardOptions.thresholds.withSteps(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity +##### fn standardOptions.thresholds.withStepsMixin + +```jsonnet +standardOptions.thresholds.withStepsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/candlestick/panelOptions/link.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/candlestick/panelOptions/link.md new file mode 100644 index 0000000000..106f9d2edb --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/candlestick/panelOptions/link.md @@ -0,0 +1,145 @@ +# link + + + +## Index + +* [`fn withAsDropdown(value=true)`](#fn-withasdropdown) +* [`fn withIcon(value)`](#fn-withicon) +* [`fn withIncludeVars(value=true)`](#fn-withincludevars) +* [`fn withKeepTime(value=true)`](#fn-withkeeptime) +* [`fn withTags(value)`](#fn-withtags) +* [`fn withTagsMixin(value)`](#fn-withtagsmixin) +* [`fn withTargetBlank(value=true)`](#fn-withtargetblank) +* [`fn withTitle(value)`](#fn-withtitle) +* [`fn withTooltip(value)`](#fn-withtooltip) +* [`fn withType(value)`](#fn-withtype) +* [`fn withUrl(value)`](#fn-withurl) + +## Fields + +### fn withAsDropdown + +```jsonnet +withAsDropdown(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withIcon + +```jsonnet +withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withIncludeVars + +```jsonnet +withIncludeVars(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withKeepTime + +```jsonnet +withKeepTime(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTags + +```jsonnet +withTags(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTagsMixin + +```jsonnet +withTagsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTargetBlank + +```jsonnet +withTargetBlank(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTitle + +```jsonnet +withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withTooltip + +```jsonnet +withTooltip(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withType + +```jsonnet +withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"link"`, `"dashboards"` + +TODO docs +### fn withUrl + +```jsonnet +withUrl(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/candlestick/queryOptions/transformation.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/candlestick/queryOptions/transformation.md new file mode 100644 index 0000000000..dc832f653d --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/candlestick/queryOptions/transformation.md @@ -0,0 +1,99 @@ +# transformation + + + +## Index + +* [`fn withDisabled(value=true)`](#fn-withdisabled) +* [`fn withFilter(value)`](#fn-withfilter) +* [`fn withFilterMixin(value)`](#fn-withfiltermixin) +* [`fn withId(value)`](#fn-withid) +* [`fn withOptions(value)`](#fn-withoptions) +* [`obj filter`](#obj-filter) + * [`fn withId(value="")`](#fn-filterwithid) + * [`fn withOptions(value)`](#fn-filterwithoptions) + +## Fields + +### fn withDisabled + +```jsonnet +withDisabled(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Disabled transformations are skipped +### fn withFilter + +```jsonnet +withFilter(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withFilterMixin + +```jsonnet +withFilterMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withId + +```jsonnet +withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Unique identifier of transformer +### fn withOptions + +```jsonnet +withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Options to be passed to the transformer +Valid options depend on the transformer id +### obj filter + + +#### fn filter.withId + +```jsonnet +filter.withId(value="") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `""` + + +#### fn filter.withOptions + +```jsonnet +filter.withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/candlestick/standardOptions/mapping.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/candlestick/standardOptions/mapping.md new file mode 100644 index 0000000000..93296972e8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/candlestick/standardOptions/mapping.md @@ -0,0 +1,469 @@ +# mapping + + + +## Index + +* [`obj RangeMap`](#obj-rangemap) + * [`fn withOptions(value)`](#fn-rangemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-rangemapwithoptionsmixin) + * [`fn withType(value)`](#fn-rangemapwithtype) + * [`obj options`](#obj-rangemapoptions) + * [`fn withFrom(value)`](#fn-rangemapoptionswithfrom) + * [`fn withResult(value)`](#fn-rangemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-rangemapoptionswithresultmixin) + * [`fn withTo(value)`](#fn-rangemapoptionswithto) + * [`obj result`](#obj-rangemapoptionsresult) + * [`fn withColor(value)`](#fn-rangemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-rangemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-rangemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-rangemapoptionsresultwithtext) +* [`obj RegexMap`](#obj-regexmap) + * [`fn withOptions(value)`](#fn-regexmapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-regexmapwithoptionsmixin) + * [`fn withType(value)`](#fn-regexmapwithtype) + * [`obj options`](#obj-regexmapoptions) + * [`fn withPattern(value)`](#fn-regexmapoptionswithpattern) + * [`fn withResult(value)`](#fn-regexmapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-regexmapoptionswithresultmixin) + * [`obj result`](#obj-regexmapoptionsresult) + * [`fn withColor(value)`](#fn-regexmapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-regexmapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-regexmapoptionsresultwithindex) + * [`fn withText(value)`](#fn-regexmapoptionsresultwithtext) +* [`obj SpecialValueMap`](#obj-specialvaluemap) + * [`fn withOptions(value)`](#fn-specialvaluemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-specialvaluemapwithoptionsmixin) + * [`fn withType(value)`](#fn-specialvaluemapwithtype) + * [`obj options`](#obj-specialvaluemapoptions) + * [`fn withMatch(value)`](#fn-specialvaluemapoptionswithmatch) + * [`fn withPattern(value)`](#fn-specialvaluemapoptionswithpattern) + * [`fn withResult(value)`](#fn-specialvaluemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-specialvaluemapoptionswithresultmixin) + * [`obj result`](#obj-specialvaluemapoptionsresult) + * [`fn withColor(value)`](#fn-specialvaluemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-specialvaluemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-specialvaluemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-specialvaluemapoptionsresultwithtext) +* [`obj ValueMap`](#obj-valuemap) + * [`fn withOptions(value)`](#fn-valuemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-valuemapwithoptionsmixin) + * [`fn withType(value)`](#fn-valuemapwithtype) + +## Fields + +### obj RangeMap + + +#### fn RangeMap.withOptions + +```jsonnet +RangeMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withOptionsMixin + +```jsonnet +RangeMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withType + +```jsonnet +RangeMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RangeMap.options + + +##### fn RangeMap.options.withFrom + +```jsonnet +RangeMap.options.withFrom(value) +``` + +PARAMETERS: + +* **value** (`number`) + +to and from are `number | null` in current ts, really not sure what to do +##### fn RangeMap.options.withResult + +```jsonnet +RangeMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withResultMixin + +```jsonnet +RangeMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withTo + +```jsonnet +RangeMap.options.withTo(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +##### obj RangeMap.options.result + + +###### fn RangeMap.options.result.withColor + +```jsonnet +RangeMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIcon + +```jsonnet +RangeMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIndex + +```jsonnet +RangeMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RangeMap.options.result.withText + +```jsonnet +RangeMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj RegexMap + + +#### fn RegexMap.withOptions + +```jsonnet +RegexMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withOptionsMixin + +```jsonnet +RegexMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withType + +```jsonnet +RegexMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RegexMap.options + + +##### fn RegexMap.options.withPattern + +```jsonnet +RegexMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn RegexMap.options.withResult + +```jsonnet +RegexMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RegexMap.options.withResultMixin + +```jsonnet +RegexMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj RegexMap.options.result + + +###### fn RegexMap.options.result.withColor + +```jsonnet +RegexMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIcon + +```jsonnet +RegexMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIndex + +```jsonnet +RegexMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RegexMap.options.result.withText + +```jsonnet +RegexMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj SpecialValueMap + + +#### fn SpecialValueMap.withOptions + +```jsonnet +SpecialValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withOptionsMixin + +```jsonnet +SpecialValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withType + +```jsonnet +SpecialValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj SpecialValueMap.options + + +##### fn SpecialValueMap.options.withMatch + +```jsonnet +SpecialValueMap.options.withMatch(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"true"`, `"false"` + + +##### fn SpecialValueMap.options.withPattern + +```jsonnet +SpecialValueMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn SpecialValueMap.options.withResult + +```jsonnet +SpecialValueMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn SpecialValueMap.options.withResultMixin + +```jsonnet +SpecialValueMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj SpecialValueMap.options.result + + +###### fn SpecialValueMap.options.result.withColor + +```jsonnet +SpecialValueMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIcon + +```jsonnet +SpecialValueMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIndex + +```jsonnet +SpecialValueMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn SpecialValueMap.options.result.withText + +```jsonnet +SpecialValueMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj ValueMap + + +#### fn ValueMap.withOptions + +```jsonnet +ValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withOptionsMixin + +```jsonnet +ValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withType + +```jsonnet +ValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/candlestick/standardOptions/override.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/candlestick/standardOptions/override.md new file mode 100644 index 0000000000..154f3dbdac --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/candlestick/standardOptions/override.md @@ -0,0 +1,244 @@ +# override + +Overrides allow you to customize visualization settings for specific fields or +series. This is accomplished by adding an override rule that targets +a particular set of fields and that can each define multiple options. + +```jsonnet +override.byType.new('number') ++ override.byType.withPropertiesFromOptions( + panel.standardOptions.withDecimals(2) + + panel.standardOptions.withUnit('s') +) +``` + + +## Index + +* [`obj byName`](#obj-byname) + * [`fn new(value)`](#fn-bynamenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bynamewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bynamewithproperty) +* [`obj byQuery`](#obj-byquery) + * [`fn new(value)`](#fn-byquerynew) + * [`fn withPropertiesFromOptions(options)`](#fn-byquerywithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byquerywithproperty) +* [`obj byRegexp`](#obj-byregexp) + * [`fn new(value)`](#fn-byregexpnew) + * [`fn withPropertiesFromOptions(options)`](#fn-byregexpwithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byregexpwithproperty) +* [`obj byType`](#obj-bytype) + * [`fn new(value)`](#fn-bytypenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bytypewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bytypewithproperty) +* [`obj byValue`](#obj-byvalue) + * [`fn new(value)`](#fn-byvaluenew) + * [`fn withPropertiesFromOptions(options)`](#fn-byvaluewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byvaluewithproperty) + +## Fields + +### obj byName + + +#### fn byName.new + +```jsonnet +byName.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byName`. +#### fn byName.withPropertiesFromOptions + +```jsonnet +byName.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byName.withProperty + +```jsonnet +byName.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byQuery + + +#### fn byQuery.new + +```jsonnet +byQuery.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byQuery`. +#### fn byQuery.withPropertiesFromOptions + +```jsonnet +byQuery.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byQuery.withProperty + +```jsonnet +byQuery.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byRegexp + + +#### fn byRegexp.new + +```jsonnet +byRegexp.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byRegexp`. +#### fn byRegexp.withPropertiesFromOptions + +```jsonnet +byRegexp.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byRegexp.withProperty + +```jsonnet +byRegexp.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byType + + +#### fn byType.new + +```jsonnet +byType.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byType`. +#### fn byType.withPropertiesFromOptions + +```jsonnet +byType.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byType.withProperty + +```jsonnet +byType.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byValue + + +#### fn byValue.new + +```jsonnet +byValue.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byValue`. +#### fn byValue.withPropertiesFromOptions + +```jsonnet +byValue.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byValue.withProperty + +```jsonnet +byValue.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/candlestick/standardOptions/threshold/step.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/candlestick/standardOptions/threshold/step.md new file mode 100644 index 0000000000..dd2dd227ff --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/candlestick/standardOptions/threshold/step.md @@ -0,0 +1,60 @@ +# threshold.step + + + +## Index + +* [`fn withColor(value)`](#fn-withcolor) +* [`fn withIndex(value)`](#fn-withindex) +* [`fn withState(value)`](#fn-withstate) +* [`fn withValue(value)`](#fn-withvalue) + +## Fields + +### fn withColor + +```jsonnet +withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +### fn withIndex + +```jsonnet +withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Threshold index, an old property that is not needed an should only appear in older dashboards +### fn withState + +```jsonnet +withState(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO are the values here enumerable into a disjunction? +Some seem to be listed in typescript comment +### fn withValue + +```jsonnet +withValue(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +FIXME the corresponding typescript field is required/non-optional, but nulls currently appear here when serializing -Infinity to JSON \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/canvas/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/canvas/index.md new file mode 100644 index 0000000000..cffebcaf5a --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/canvas/index.md @@ -0,0 +1,564 @@ +# canvas + +grafonnet.panel.canvas + +## Subpackages + +* [panelOptions.link](panelOptions/link.md) +* [queryOptions.transformation](queryOptions/transformation.md) +* [standardOptions.mapping](standardOptions/mapping.md) +* [standardOptions.override](standardOptions/override.md) +* [standardOptions.threshold.step](standardOptions/threshold/step.md) + +## Index + +* [`fn new(title)`](#fn-new) +* [`obj libraryPanel`](#obj-librarypanel) + * [`fn withName(value)`](#fn-librarypanelwithname) + * [`fn withUid(value)`](#fn-librarypanelwithuid) +* [`obj panelOptions`](#obj-paneloptions) + * [`fn withDescription(value)`](#fn-paneloptionswithdescription) + * [`fn withGridPos(h="null", w="null", x="null", y="null")`](#fn-paneloptionswithgridpos) + * [`fn withLinks(value)`](#fn-paneloptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-paneloptionswithlinksmixin) + * [`fn withRepeat(value)`](#fn-paneloptionswithrepeat) + * [`fn withRepeatDirection(value="h")`](#fn-paneloptionswithrepeatdirection) + * [`fn withTitle(value)`](#fn-paneloptionswithtitle) + * [`fn withTransparent(value=true)`](#fn-paneloptionswithtransparent) +* [`obj queryOptions`](#obj-queryoptions) + * [`fn withDatasource(type, uid)`](#fn-queryoptionswithdatasource) + * [`fn withDatasourceMixin(value)`](#fn-queryoptionswithdatasourcemixin) + * [`fn withInterval(value)`](#fn-queryoptionswithinterval) + * [`fn withMaxDataPoints(value)`](#fn-queryoptionswithmaxdatapoints) + * [`fn withTargets(value)`](#fn-queryoptionswithtargets) + * [`fn withTargetsMixin(value)`](#fn-queryoptionswithtargetsmixin) + * [`fn withTimeFrom(value)`](#fn-queryoptionswithtimefrom) + * [`fn withTimeShift(value)`](#fn-queryoptionswithtimeshift) + * [`fn withTransformations(value)`](#fn-queryoptionswithtransformations) + * [`fn withTransformationsMixin(value)`](#fn-queryoptionswithtransformationsmixin) +* [`obj standardOptions`](#obj-standardoptions) + * [`fn withDecimals(value)`](#fn-standardoptionswithdecimals) + * [`fn withDisplayName(value)`](#fn-standardoptionswithdisplayname) + * [`fn withFilterable(value=true)`](#fn-standardoptionswithfilterable) + * [`fn withLinks(value)`](#fn-standardoptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-standardoptionswithlinksmixin) + * [`fn withMappings(value)`](#fn-standardoptionswithmappings) + * [`fn withMappingsMixin(value)`](#fn-standardoptionswithmappingsmixin) + * [`fn withMax(value)`](#fn-standardoptionswithmax) + * [`fn withMin(value)`](#fn-standardoptionswithmin) + * [`fn withNoValue(value)`](#fn-standardoptionswithnovalue) + * [`fn withOverrides(value)`](#fn-standardoptionswithoverrides) + * [`fn withOverridesMixin(value)`](#fn-standardoptionswithoverridesmixin) + * [`fn withPath(value)`](#fn-standardoptionswithpath) + * [`fn withUnit(value)`](#fn-standardoptionswithunit) + * [`obj color`](#obj-standardoptionscolor) + * [`fn withFixedColor(value)`](#fn-standardoptionscolorwithfixedcolor) + * [`fn withMode(value)`](#fn-standardoptionscolorwithmode) + * [`fn withSeriesBy(value)`](#fn-standardoptionscolorwithseriesby) + * [`obj thresholds`](#obj-standardoptionsthresholds) + * [`fn withMode(value)`](#fn-standardoptionsthresholdswithmode) + * [`fn withSteps(value)`](#fn-standardoptionsthresholdswithsteps) + * [`fn withStepsMixin(value)`](#fn-standardoptionsthresholdswithstepsmixin) + +## Fields + +### fn new + +```jsonnet +new(title) +``` + +PARAMETERS: + +* **title** (`string`) + +Creates a new canvas panel with a title. +### obj libraryPanel + + +#### fn libraryPanel.withName + +```jsonnet +libraryPanel.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn libraryPanel.withUid + +```jsonnet +libraryPanel.withUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj panelOptions + + +#### fn panelOptions.withDescription + +```jsonnet +panelOptions.withDescription(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Description. +#### fn panelOptions.withGridPos + +```jsonnet +panelOptions.withGridPos(h="null", w="null", x="null", y="null") +``` + +PARAMETERS: + +* **h** (`number`) + - default value: `"null"` +* **w** (`number`) + - default value: `"null"` +* **x** (`number`) + - default value: `"null"` +* **y** (`number`) + - default value: `"null"` + +`withGridPos` configures the height, width and xy coordinates of the panel. Also see `grafonnet.util.grid` for helper functions to calculate these fields. + +All arguments default to `null`, which means they will remain unchanged or unset. + +#### fn panelOptions.withLinks + +```jsonnet +panelOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withLinksMixin + +```jsonnet +panelOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withRepeat + +```jsonnet +panelOptions.withRepeat(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of template variable to repeat for. +#### fn panelOptions.withRepeatDirection + +```jsonnet +panelOptions.withRepeatDirection(value="h") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"h"` + - valid values: `"h"`, `"v"` + +Direction to repeat in if 'repeat' is set. +"h" for horizontal, "v" for vertical. +TODO this is probably optional +#### fn panelOptions.withTitle + +```jsonnet +panelOptions.withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Panel title. +#### fn panelOptions.withTransparent + +```jsonnet +panelOptions.withTransparent(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Whether to display the panel without a background. +### obj queryOptions + + +#### fn queryOptions.withDatasource + +```jsonnet +queryOptions.withDatasource(type, uid) +``` + +PARAMETERS: + +* **type** (`string`) +* **uid** (`string`) + +`withDatasource` sets the datasource for all queries in a panel. + +The default datasource for a panel is set to 'Mixed datasource' so panels can be datasource agnostic, which is a lot more interesting from a reusability standpoint. Note that this requires query targets to explicitly set datasource for the same reason. + +#### fn queryOptions.withDatasourceMixin + +```jsonnet +queryOptions.withDatasourceMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +The datasource used in all targets. +#### fn queryOptions.withInterval + +```jsonnet +queryOptions.withInterval(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withMaxDataPoints + +```jsonnet +queryOptions.withMaxDataPoints(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +#### fn queryOptions.withTargets + +```jsonnet +queryOptions.withTargets(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTargetsMixin + +```jsonnet +queryOptions.withTargetsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTimeFrom + +```jsonnet +queryOptions.withTimeFrom(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTimeShift + +```jsonnet +queryOptions.withTimeShift(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTransformations + +```jsonnet +queryOptions.withTransformations(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn queryOptions.withTransformationsMixin + +```jsonnet +queryOptions.withTransformationsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### obj standardOptions + + +#### fn standardOptions.withDecimals + +```jsonnet +standardOptions.withDecimals(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Significant digits (for display) +#### fn standardOptions.withDisplayName + +```jsonnet +standardOptions.withDisplayName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The display value for this field. This supports template variables blank is auto +#### fn standardOptions.withFilterable + +```jsonnet +standardOptions.withFilterable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +True if data source field supports ad-hoc filters +#### fn standardOptions.withLinks + +```jsonnet +standardOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withLinksMixin + +```jsonnet +standardOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withMappings + +```jsonnet +standardOptions.withMappings(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMappingsMixin + +```jsonnet +standardOptions.withMappingsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMax + +```jsonnet +standardOptions.withMax(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withMin + +```jsonnet +standardOptions.withMin(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withNoValue + +```jsonnet +standardOptions.withNoValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Alternative to empty string +#### fn standardOptions.withOverrides + +```jsonnet +standardOptions.withOverrides(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withOverridesMixin + +```jsonnet +standardOptions.withOverridesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withPath + +```jsonnet +standardOptions.withPath(value) +``` + +PARAMETERS: + +* **value** (`string`) + +An explicit path to the field in the datasource. When the frame meta includes a path, +This will default to `${frame.meta.path}/${field.name} + +When defined, this value can be used as an identifier within the datasource scope, and +may be used to update the results +#### fn standardOptions.withUnit + +```jsonnet +standardOptions.withUnit(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Numeric Options +#### obj standardOptions.color + + +##### fn standardOptions.color.withFixedColor + +```jsonnet +standardOptions.color.withFixedColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Stores the fixed color value if mode is fixed +##### fn standardOptions.color.withMode + +```jsonnet +standardOptions.color.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The main color scheme mode +##### fn standardOptions.color.withSeriesBy + +```jsonnet +standardOptions.color.withSeriesBy(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"min"`, `"max"`, `"last"` + +TODO docs +#### obj standardOptions.thresholds + + +##### fn standardOptions.thresholds.withMode + +```jsonnet +standardOptions.thresholds.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"absolute"`, `"percentage"` + + +##### fn standardOptions.thresholds.withSteps + +```jsonnet +standardOptions.thresholds.withSteps(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity +##### fn standardOptions.thresholds.withStepsMixin + +```jsonnet +standardOptions.thresholds.withStepsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/canvas/panelOptions/link.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/canvas/panelOptions/link.md new file mode 100644 index 0000000000..106f9d2edb --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/canvas/panelOptions/link.md @@ -0,0 +1,145 @@ +# link + + + +## Index + +* [`fn withAsDropdown(value=true)`](#fn-withasdropdown) +* [`fn withIcon(value)`](#fn-withicon) +* [`fn withIncludeVars(value=true)`](#fn-withincludevars) +* [`fn withKeepTime(value=true)`](#fn-withkeeptime) +* [`fn withTags(value)`](#fn-withtags) +* [`fn withTagsMixin(value)`](#fn-withtagsmixin) +* [`fn withTargetBlank(value=true)`](#fn-withtargetblank) +* [`fn withTitle(value)`](#fn-withtitle) +* [`fn withTooltip(value)`](#fn-withtooltip) +* [`fn withType(value)`](#fn-withtype) +* [`fn withUrl(value)`](#fn-withurl) + +## Fields + +### fn withAsDropdown + +```jsonnet +withAsDropdown(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withIcon + +```jsonnet +withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withIncludeVars + +```jsonnet +withIncludeVars(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withKeepTime + +```jsonnet +withKeepTime(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTags + +```jsonnet +withTags(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTagsMixin + +```jsonnet +withTagsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTargetBlank + +```jsonnet +withTargetBlank(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTitle + +```jsonnet +withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withTooltip + +```jsonnet +withTooltip(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withType + +```jsonnet +withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"link"`, `"dashboards"` + +TODO docs +### fn withUrl + +```jsonnet +withUrl(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/canvas/queryOptions/transformation.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/canvas/queryOptions/transformation.md new file mode 100644 index 0000000000..dc832f653d --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/canvas/queryOptions/transformation.md @@ -0,0 +1,99 @@ +# transformation + + + +## Index + +* [`fn withDisabled(value=true)`](#fn-withdisabled) +* [`fn withFilter(value)`](#fn-withfilter) +* [`fn withFilterMixin(value)`](#fn-withfiltermixin) +* [`fn withId(value)`](#fn-withid) +* [`fn withOptions(value)`](#fn-withoptions) +* [`obj filter`](#obj-filter) + * [`fn withId(value="")`](#fn-filterwithid) + * [`fn withOptions(value)`](#fn-filterwithoptions) + +## Fields + +### fn withDisabled + +```jsonnet +withDisabled(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Disabled transformations are skipped +### fn withFilter + +```jsonnet +withFilter(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withFilterMixin + +```jsonnet +withFilterMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withId + +```jsonnet +withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Unique identifier of transformer +### fn withOptions + +```jsonnet +withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Options to be passed to the transformer +Valid options depend on the transformer id +### obj filter + + +#### fn filter.withId + +```jsonnet +filter.withId(value="") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `""` + + +#### fn filter.withOptions + +```jsonnet +filter.withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/canvas/standardOptions/mapping.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/canvas/standardOptions/mapping.md new file mode 100644 index 0000000000..93296972e8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/canvas/standardOptions/mapping.md @@ -0,0 +1,469 @@ +# mapping + + + +## Index + +* [`obj RangeMap`](#obj-rangemap) + * [`fn withOptions(value)`](#fn-rangemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-rangemapwithoptionsmixin) + * [`fn withType(value)`](#fn-rangemapwithtype) + * [`obj options`](#obj-rangemapoptions) + * [`fn withFrom(value)`](#fn-rangemapoptionswithfrom) + * [`fn withResult(value)`](#fn-rangemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-rangemapoptionswithresultmixin) + * [`fn withTo(value)`](#fn-rangemapoptionswithto) + * [`obj result`](#obj-rangemapoptionsresult) + * [`fn withColor(value)`](#fn-rangemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-rangemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-rangemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-rangemapoptionsresultwithtext) +* [`obj RegexMap`](#obj-regexmap) + * [`fn withOptions(value)`](#fn-regexmapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-regexmapwithoptionsmixin) + * [`fn withType(value)`](#fn-regexmapwithtype) + * [`obj options`](#obj-regexmapoptions) + * [`fn withPattern(value)`](#fn-regexmapoptionswithpattern) + * [`fn withResult(value)`](#fn-regexmapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-regexmapoptionswithresultmixin) + * [`obj result`](#obj-regexmapoptionsresult) + * [`fn withColor(value)`](#fn-regexmapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-regexmapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-regexmapoptionsresultwithindex) + * [`fn withText(value)`](#fn-regexmapoptionsresultwithtext) +* [`obj SpecialValueMap`](#obj-specialvaluemap) + * [`fn withOptions(value)`](#fn-specialvaluemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-specialvaluemapwithoptionsmixin) + * [`fn withType(value)`](#fn-specialvaluemapwithtype) + * [`obj options`](#obj-specialvaluemapoptions) + * [`fn withMatch(value)`](#fn-specialvaluemapoptionswithmatch) + * [`fn withPattern(value)`](#fn-specialvaluemapoptionswithpattern) + * [`fn withResult(value)`](#fn-specialvaluemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-specialvaluemapoptionswithresultmixin) + * [`obj result`](#obj-specialvaluemapoptionsresult) + * [`fn withColor(value)`](#fn-specialvaluemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-specialvaluemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-specialvaluemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-specialvaluemapoptionsresultwithtext) +* [`obj ValueMap`](#obj-valuemap) + * [`fn withOptions(value)`](#fn-valuemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-valuemapwithoptionsmixin) + * [`fn withType(value)`](#fn-valuemapwithtype) + +## Fields + +### obj RangeMap + + +#### fn RangeMap.withOptions + +```jsonnet +RangeMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withOptionsMixin + +```jsonnet +RangeMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withType + +```jsonnet +RangeMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RangeMap.options + + +##### fn RangeMap.options.withFrom + +```jsonnet +RangeMap.options.withFrom(value) +``` + +PARAMETERS: + +* **value** (`number`) + +to and from are `number | null` in current ts, really not sure what to do +##### fn RangeMap.options.withResult + +```jsonnet +RangeMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withResultMixin + +```jsonnet +RangeMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withTo + +```jsonnet +RangeMap.options.withTo(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +##### obj RangeMap.options.result + + +###### fn RangeMap.options.result.withColor + +```jsonnet +RangeMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIcon + +```jsonnet +RangeMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIndex + +```jsonnet +RangeMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RangeMap.options.result.withText + +```jsonnet +RangeMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj RegexMap + + +#### fn RegexMap.withOptions + +```jsonnet +RegexMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withOptionsMixin + +```jsonnet +RegexMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withType + +```jsonnet +RegexMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RegexMap.options + + +##### fn RegexMap.options.withPattern + +```jsonnet +RegexMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn RegexMap.options.withResult + +```jsonnet +RegexMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RegexMap.options.withResultMixin + +```jsonnet +RegexMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj RegexMap.options.result + + +###### fn RegexMap.options.result.withColor + +```jsonnet +RegexMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIcon + +```jsonnet +RegexMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIndex + +```jsonnet +RegexMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RegexMap.options.result.withText + +```jsonnet +RegexMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj SpecialValueMap + + +#### fn SpecialValueMap.withOptions + +```jsonnet +SpecialValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withOptionsMixin + +```jsonnet +SpecialValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withType + +```jsonnet +SpecialValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj SpecialValueMap.options + + +##### fn SpecialValueMap.options.withMatch + +```jsonnet +SpecialValueMap.options.withMatch(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"true"`, `"false"` + + +##### fn SpecialValueMap.options.withPattern + +```jsonnet +SpecialValueMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn SpecialValueMap.options.withResult + +```jsonnet +SpecialValueMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn SpecialValueMap.options.withResultMixin + +```jsonnet +SpecialValueMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj SpecialValueMap.options.result + + +###### fn SpecialValueMap.options.result.withColor + +```jsonnet +SpecialValueMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIcon + +```jsonnet +SpecialValueMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIndex + +```jsonnet +SpecialValueMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn SpecialValueMap.options.result.withText + +```jsonnet +SpecialValueMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj ValueMap + + +#### fn ValueMap.withOptions + +```jsonnet +ValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withOptionsMixin + +```jsonnet +ValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withType + +```jsonnet +ValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/canvas/standardOptions/override.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/canvas/standardOptions/override.md new file mode 100644 index 0000000000..154f3dbdac --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/canvas/standardOptions/override.md @@ -0,0 +1,244 @@ +# override + +Overrides allow you to customize visualization settings for specific fields or +series. This is accomplished by adding an override rule that targets +a particular set of fields and that can each define multiple options. + +```jsonnet +override.byType.new('number') ++ override.byType.withPropertiesFromOptions( + panel.standardOptions.withDecimals(2) + + panel.standardOptions.withUnit('s') +) +``` + + +## Index + +* [`obj byName`](#obj-byname) + * [`fn new(value)`](#fn-bynamenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bynamewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bynamewithproperty) +* [`obj byQuery`](#obj-byquery) + * [`fn new(value)`](#fn-byquerynew) + * [`fn withPropertiesFromOptions(options)`](#fn-byquerywithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byquerywithproperty) +* [`obj byRegexp`](#obj-byregexp) + * [`fn new(value)`](#fn-byregexpnew) + * [`fn withPropertiesFromOptions(options)`](#fn-byregexpwithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byregexpwithproperty) +* [`obj byType`](#obj-bytype) + * [`fn new(value)`](#fn-bytypenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bytypewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bytypewithproperty) +* [`obj byValue`](#obj-byvalue) + * [`fn new(value)`](#fn-byvaluenew) + * [`fn withPropertiesFromOptions(options)`](#fn-byvaluewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byvaluewithproperty) + +## Fields + +### obj byName + + +#### fn byName.new + +```jsonnet +byName.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byName`. +#### fn byName.withPropertiesFromOptions + +```jsonnet +byName.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byName.withProperty + +```jsonnet +byName.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byQuery + + +#### fn byQuery.new + +```jsonnet +byQuery.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byQuery`. +#### fn byQuery.withPropertiesFromOptions + +```jsonnet +byQuery.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byQuery.withProperty + +```jsonnet +byQuery.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byRegexp + + +#### fn byRegexp.new + +```jsonnet +byRegexp.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byRegexp`. +#### fn byRegexp.withPropertiesFromOptions + +```jsonnet +byRegexp.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byRegexp.withProperty + +```jsonnet +byRegexp.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byType + + +#### fn byType.new + +```jsonnet +byType.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byType`. +#### fn byType.withPropertiesFromOptions + +```jsonnet +byType.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byType.withProperty + +```jsonnet +byType.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byValue + + +#### fn byValue.new + +```jsonnet +byValue.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byValue`. +#### fn byValue.withPropertiesFromOptions + +```jsonnet +byValue.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byValue.withProperty + +```jsonnet +byValue.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/canvas/standardOptions/threshold/step.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/canvas/standardOptions/threshold/step.md new file mode 100644 index 0000000000..dd2dd227ff --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/canvas/standardOptions/threshold/step.md @@ -0,0 +1,60 @@ +# threshold.step + + + +## Index + +* [`fn withColor(value)`](#fn-withcolor) +* [`fn withIndex(value)`](#fn-withindex) +* [`fn withState(value)`](#fn-withstate) +* [`fn withValue(value)`](#fn-withvalue) + +## Fields + +### fn withColor + +```jsonnet +withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +### fn withIndex + +```jsonnet +withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Threshold index, an old property that is not needed an should only appear in older dashboards +### fn withState + +```jsonnet +withState(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO are the values here enumerable into a disjunction? +Some seem to be listed in typescript comment +### fn withValue + +```jsonnet +withValue(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +FIXME the corresponding typescript field is required/non-optional, but nulls currently appear here when serializing -Infinity to JSON \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/dashboardList/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/dashboardList/index.md new file mode 100644 index 0000000000..39ddeedc0e --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/dashboardList/index.md @@ -0,0 +1,708 @@ +# dashboardList + +grafonnet.panel.dashboardList + +## Subpackages + +* [panelOptions.link](panelOptions/link.md) +* [queryOptions.transformation](queryOptions/transformation.md) +* [standardOptions.mapping](standardOptions/mapping.md) +* [standardOptions.override](standardOptions/override.md) +* [standardOptions.threshold.step](standardOptions/threshold/step.md) + +## Index + +* [`fn new(title)`](#fn-new) +* [`obj libraryPanel`](#obj-librarypanel) + * [`fn withName(value)`](#fn-librarypanelwithname) + * [`fn withUid(value)`](#fn-librarypanelwithuid) +* [`obj options`](#obj-options) + * [`fn withFolderId(value)`](#fn-optionswithfolderid) + * [`fn withIncludeVars(value=true)`](#fn-optionswithincludevars) + * [`fn withKeepTime(value=true)`](#fn-optionswithkeeptime) + * [`fn withMaxItems(value=10)`](#fn-optionswithmaxitems) + * [`fn withQuery(value="")`](#fn-optionswithquery) + * [`fn withShowHeadings(value=true)`](#fn-optionswithshowheadings) + * [`fn withShowRecentlyViewed(value=true)`](#fn-optionswithshowrecentlyviewed) + * [`fn withShowSearch(value=true)`](#fn-optionswithshowsearch) + * [`fn withShowStarred(value=true)`](#fn-optionswithshowstarred) + * [`fn withTags(value)`](#fn-optionswithtags) + * [`fn withTagsMixin(value)`](#fn-optionswithtagsmixin) +* [`obj panelOptions`](#obj-paneloptions) + * [`fn withDescription(value)`](#fn-paneloptionswithdescription) + * [`fn withGridPos(h="null", w="null", x="null", y="null")`](#fn-paneloptionswithgridpos) + * [`fn withLinks(value)`](#fn-paneloptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-paneloptionswithlinksmixin) + * [`fn withRepeat(value)`](#fn-paneloptionswithrepeat) + * [`fn withRepeatDirection(value="h")`](#fn-paneloptionswithrepeatdirection) + * [`fn withTitle(value)`](#fn-paneloptionswithtitle) + * [`fn withTransparent(value=true)`](#fn-paneloptionswithtransparent) +* [`obj queryOptions`](#obj-queryoptions) + * [`fn withDatasource(type, uid)`](#fn-queryoptionswithdatasource) + * [`fn withDatasourceMixin(value)`](#fn-queryoptionswithdatasourcemixin) + * [`fn withInterval(value)`](#fn-queryoptionswithinterval) + * [`fn withMaxDataPoints(value)`](#fn-queryoptionswithmaxdatapoints) + * [`fn withTargets(value)`](#fn-queryoptionswithtargets) + * [`fn withTargetsMixin(value)`](#fn-queryoptionswithtargetsmixin) + * [`fn withTimeFrom(value)`](#fn-queryoptionswithtimefrom) + * [`fn withTimeShift(value)`](#fn-queryoptionswithtimeshift) + * [`fn withTransformations(value)`](#fn-queryoptionswithtransformations) + * [`fn withTransformationsMixin(value)`](#fn-queryoptionswithtransformationsmixin) +* [`obj standardOptions`](#obj-standardoptions) + * [`fn withDecimals(value)`](#fn-standardoptionswithdecimals) + * [`fn withDisplayName(value)`](#fn-standardoptionswithdisplayname) + * [`fn withFilterable(value=true)`](#fn-standardoptionswithfilterable) + * [`fn withLinks(value)`](#fn-standardoptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-standardoptionswithlinksmixin) + * [`fn withMappings(value)`](#fn-standardoptionswithmappings) + * [`fn withMappingsMixin(value)`](#fn-standardoptionswithmappingsmixin) + * [`fn withMax(value)`](#fn-standardoptionswithmax) + * [`fn withMin(value)`](#fn-standardoptionswithmin) + * [`fn withNoValue(value)`](#fn-standardoptionswithnovalue) + * [`fn withOverrides(value)`](#fn-standardoptionswithoverrides) + * [`fn withOverridesMixin(value)`](#fn-standardoptionswithoverridesmixin) + * [`fn withPath(value)`](#fn-standardoptionswithpath) + * [`fn withUnit(value)`](#fn-standardoptionswithunit) + * [`obj color`](#obj-standardoptionscolor) + * [`fn withFixedColor(value)`](#fn-standardoptionscolorwithfixedcolor) + * [`fn withMode(value)`](#fn-standardoptionscolorwithmode) + * [`fn withSeriesBy(value)`](#fn-standardoptionscolorwithseriesby) + * [`obj thresholds`](#obj-standardoptionsthresholds) + * [`fn withMode(value)`](#fn-standardoptionsthresholdswithmode) + * [`fn withSteps(value)`](#fn-standardoptionsthresholdswithsteps) + * [`fn withStepsMixin(value)`](#fn-standardoptionsthresholdswithstepsmixin) + +## Fields + +### fn new + +```jsonnet +new(title) +``` + +PARAMETERS: + +* **title** (`string`) + +Creates a new dashboardList panel with a title. +### obj libraryPanel + + +#### fn libraryPanel.withName + +```jsonnet +libraryPanel.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn libraryPanel.withUid + +```jsonnet +libraryPanel.withUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj options + + +#### fn options.withFolderId + +```jsonnet +options.withFolderId(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +#### fn options.withIncludeVars + +```jsonnet +options.withIncludeVars(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +#### fn options.withKeepTime + +```jsonnet +options.withKeepTime(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +#### fn options.withMaxItems + +```jsonnet +options.withMaxItems(value=10) +``` + +PARAMETERS: + +* **value** (`integer`) + - default value: `10` + + +#### fn options.withQuery + +```jsonnet +options.withQuery(value="") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `""` + + +#### fn options.withShowHeadings + +```jsonnet +options.withShowHeadings(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +#### fn options.withShowRecentlyViewed + +```jsonnet +options.withShowRecentlyViewed(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +#### fn options.withShowSearch + +```jsonnet +options.withShowSearch(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +#### fn options.withShowStarred + +```jsonnet +options.withShowStarred(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +#### fn options.withTags + +```jsonnet +options.withTags(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn options.withTagsMixin + +```jsonnet +options.withTagsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### obj panelOptions + + +#### fn panelOptions.withDescription + +```jsonnet +panelOptions.withDescription(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Description. +#### fn panelOptions.withGridPos + +```jsonnet +panelOptions.withGridPos(h="null", w="null", x="null", y="null") +``` + +PARAMETERS: + +* **h** (`number`) + - default value: `"null"` +* **w** (`number`) + - default value: `"null"` +* **x** (`number`) + - default value: `"null"` +* **y** (`number`) + - default value: `"null"` + +`withGridPos` configures the height, width and xy coordinates of the panel. Also see `grafonnet.util.grid` for helper functions to calculate these fields. + +All arguments default to `null`, which means they will remain unchanged or unset. + +#### fn panelOptions.withLinks + +```jsonnet +panelOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withLinksMixin + +```jsonnet +panelOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withRepeat + +```jsonnet +panelOptions.withRepeat(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of template variable to repeat for. +#### fn panelOptions.withRepeatDirection + +```jsonnet +panelOptions.withRepeatDirection(value="h") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"h"` + - valid values: `"h"`, `"v"` + +Direction to repeat in if 'repeat' is set. +"h" for horizontal, "v" for vertical. +TODO this is probably optional +#### fn panelOptions.withTitle + +```jsonnet +panelOptions.withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Panel title. +#### fn panelOptions.withTransparent + +```jsonnet +panelOptions.withTransparent(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Whether to display the panel without a background. +### obj queryOptions + + +#### fn queryOptions.withDatasource + +```jsonnet +queryOptions.withDatasource(type, uid) +``` + +PARAMETERS: + +* **type** (`string`) +* **uid** (`string`) + +`withDatasource` sets the datasource for all queries in a panel. + +The default datasource for a panel is set to 'Mixed datasource' so panels can be datasource agnostic, which is a lot more interesting from a reusability standpoint. Note that this requires query targets to explicitly set datasource for the same reason. + +#### fn queryOptions.withDatasourceMixin + +```jsonnet +queryOptions.withDatasourceMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +The datasource used in all targets. +#### fn queryOptions.withInterval + +```jsonnet +queryOptions.withInterval(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withMaxDataPoints + +```jsonnet +queryOptions.withMaxDataPoints(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +#### fn queryOptions.withTargets + +```jsonnet +queryOptions.withTargets(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTargetsMixin + +```jsonnet +queryOptions.withTargetsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTimeFrom + +```jsonnet +queryOptions.withTimeFrom(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTimeShift + +```jsonnet +queryOptions.withTimeShift(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTransformations + +```jsonnet +queryOptions.withTransformations(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn queryOptions.withTransformationsMixin + +```jsonnet +queryOptions.withTransformationsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### obj standardOptions + + +#### fn standardOptions.withDecimals + +```jsonnet +standardOptions.withDecimals(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Significant digits (for display) +#### fn standardOptions.withDisplayName + +```jsonnet +standardOptions.withDisplayName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The display value for this field. This supports template variables blank is auto +#### fn standardOptions.withFilterable + +```jsonnet +standardOptions.withFilterable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +True if data source field supports ad-hoc filters +#### fn standardOptions.withLinks + +```jsonnet +standardOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withLinksMixin + +```jsonnet +standardOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withMappings + +```jsonnet +standardOptions.withMappings(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMappingsMixin + +```jsonnet +standardOptions.withMappingsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMax + +```jsonnet +standardOptions.withMax(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withMin + +```jsonnet +standardOptions.withMin(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withNoValue + +```jsonnet +standardOptions.withNoValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Alternative to empty string +#### fn standardOptions.withOverrides + +```jsonnet +standardOptions.withOverrides(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withOverridesMixin + +```jsonnet +standardOptions.withOverridesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withPath + +```jsonnet +standardOptions.withPath(value) +``` + +PARAMETERS: + +* **value** (`string`) + +An explicit path to the field in the datasource. When the frame meta includes a path, +This will default to `${frame.meta.path}/${field.name} + +When defined, this value can be used as an identifier within the datasource scope, and +may be used to update the results +#### fn standardOptions.withUnit + +```jsonnet +standardOptions.withUnit(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Numeric Options +#### obj standardOptions.color + + +##### fn standardOptions.color.withFixedColor + +```jsonnet +standardOptions.color.withFixedColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Stores the fixed color value if mode is fixed +##### fn standardOptions.color.withMode + +```jsonnet +standardOptions.color.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The main color scheme mode +##### fn standardOptions.color.withSeriesBy + +```jsonnet +standardOptions.color.withSeriesBy(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"min"`, `"max"`, `"last"` + +TODO docs +#### obj standardOptions.thresholds + + +##### fn standardOptions.thresholds.withMode + +```jsonnet +standardOptions.thresholds.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"absolute"`, `"percentage"` + + +##### fn standardOptions.thresholds.withSteps + +```jsonnet +standardOptions.thresholds.withSteps(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity +##### fn standardOptions.thresholds.withStepsMixin + +```jsonnet +standardOptions.thresholds.withStepsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/dashboardList/panelOptions/link.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/dashboardList/panelOptions/link.md new file mode 100644 index 0000000000..106f9d2edb --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/dashboardList/panelOptions/link.md @@ -0,0 +1,145 @@ +# link + + + +## Index + +* [`fn withAsDropdown(value=true)`](#fn-withasdropdown) +* [`fn withIcon(value)`](#fn-withicon) +* [`fn withIncludeVars(value=true)`](#fn-withincludevars) +* [`fn withKeepTime(value=true)`](#fn-withkeeptime) +* [`fn withTags(value)`](#fn-withtags) +* [`fn withTagsMixin(value)`](#fn-withtagsmixin) +* [`fn withTargetBlank(value=true)`](#fn-withtargetblank) +* [`fn withTitle(value)`](#fn-withtitle) +* [`fn withTooltip(value)`](#fn-withtooltip) +* [`fn withType(value)`](#fn-withtype) +* [`fn withUrl(value)`](#fn-withurl) + +## Fields + +### fn withAsDropdown + +```jsonnet +withAsDropdown(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withIcon + +```jsonnet +withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withIncludeVars + +```jsonnet +withIncludeVars(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withKeepTime + +```jsonnet +withKeepTime(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTags + +```jsonnet +withTags(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTagsMixin + +```jsonnet +withTagsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTargetBlank + +```jsonnet +withTargetBlank(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTitle + +```jsonnet +withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withTooltip + +```jsonnet +withTooltip(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withType + +```jsonnet +withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"link"`, `"dashboards"` + +TODO docs +### fn withUrl + +```jsonnet +withUrl(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/dashboardList/queryOptions/transformation.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/dashboardList/queryOptions/transformation.md new file mode 100644 index 0000000000..dc832f653d --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/dashboardList/queryOptions/transformation.md @@ -0,0 +1,99 @@ +# transformation + + + +## Index + +* [`fn withDisabled(value=true)`](#fn-withdisabled) +* [`fn withFilter(value)`](#fn-withfilter) +* [`fn withFilterMixin(value)`](#fn-withfiltermixin) +* [`fn withId(value)`](#fn-withid) +* [`fn withOptions(value)`](#fn-withoptions) +* [`obj filter`](#obj-filter) + * [`fn withId(value="")`](#fn-filterwithid) + * [`fn withOptions(value)`](#fn-filterwithoptions) + +## Fields + +### fn withDisabled + +```jsonnet +withDisabled(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Disabled transformations are skipped +### fn withFilter + +```jsonnet +withFilter(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withFilterMixin + +```jsonnet +withFilterMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withId + +```jsonnet +withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Unique identifier of transformer +### fn withOptions + +```jsonnet +withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Options to be passed to the transformer +Valid options depend on the transformer id +### obj filter + + +#### fn filter.withId + +```jsonnet +filter.withId(value="") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `""` + + +#### fn filter.withOptions + +```jsonnet +filter.withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/dashboardList/standardOptions/mapping.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/dashboardList/standardOptions/mapping.md new file mode 100644 index 0000000000..93296972e8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/dashboardList/standardOptions/mapping.md @@ -0,0 +1,469 @@ +# mapping + + + +## Index + +* [`obj RangeMap`](#obj-rangemap) + * [`fn withOptions(value)`](#fn-rangemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-rangemapwithoptionsmixin) + * [`fn withType(value)`](#fn-rangemapwithtype) + * [`obj options`](#obj-rangemapoptions) + * [`fn withFrom(value)`](#fn-rangemapoptionswithfrom) + * [`fn withResult(value)`](#fn-rangemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-rangemapoptionswithresultmixin) + * [`fn withTo(value)`](#fn-rangemapoptionswithto) + * [`obj result`](#obj-rangemapoptionsresult) + * [`fn withColor(value)`](#fn-rangemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-rangemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-rangemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-rangemapoptionsresultwithtext) +* [`obj RegexMap`](#obj-regexmap) + * [`fn withOptions(value)`](#fn-regexmapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-regexmapwithoptionsmixin) + * [`fn withType(value)`](#fn-regexmapwithtype) + * [`obj options`](#obj-regexmapoptions) + * [`fn withPattern(value)`](#fn-regexmapoptionswithpattern) + * [`fn withResult(value)`](#fn-regexmapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-regexmapoptionswithresultmixin) + * [`obj result`](#obj-regexmapoptionsresult) + * [`fn withColor(value)`](#fn-regexmapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-regexmapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-regexmapoptionsresultwithindex) + * [`fn withText(value)`](#fn-regexmapoptionsresultwithtext) +* [`obj SpecialValueMap`](#obj-specialvaluemap) + * [`fn withOptions(value)`](#fn-specialvaluemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-specialvaluemapwithoptionsmixin) + * [`fn withType(value)`](#fn-specialvaluemapwithtype) + * [`obj options`](#obj-specialvaluemapoptions) + * [`fn withMatch(value)`](#fn-specialvaluemapoptionswithmatch) + * [`fn withPattern(value)`](#fn-specialvaluemapoptionswithpattern) + * [`fn withResult(value)`](#fn-specialvaluemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-specialvaluemapoptionswithresultmixin) + * [`obj result`](#obj-specialvaluemapoptionsresult) + * [`fn withColor(value)`](#fn-specialvaluemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-specialvaluemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-specialvaluemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-specialvaluemapoptionsresultwithtext) +* [`obj ValueMap`](#obj-valuemap) + * [`fn withOptions(value)`](#fn-valuemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-valuemapwithoptionsmixin) + * [`fn withType(value)`](#fn-valuemapwithtype) + +## Fields + +### obj RangeMap + + +#### fn RangeMap.withOptions + +```jsonnet +RangeMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withOptionsMixin + +```jsonnet +RangeMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withType + +```jsonnet +RangeMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RangeMap.options + + +##### fn RangeMap.options.withFrom + +```jsonnet +RangeMap.options.withFrom(value) +``` + +PARAMETERS: + +* **value** (`number`) + +to and from are `number | null` in current ts, really not sure what to do +##### fn RangeMap.options.withResult + +```jsonnet +RangeMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withResultMixin + +```jsonnet +RangeMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withTo + +```jsonnet +RangeMap.options.withTo(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +##### obj RangeMap.options.result + + +###### fn RangeMap.options.result.withColor + +```jsonnet +RangeMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIcon + +```jsonnet +RangeMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIndex + +```jsonnet +RangeMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RangeMap.options.result.withText + +```jsonnet +RangeMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj RegexMap + + +#### fn RegexMap.withOptions + +```jsonnet +RegexMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withOptionsMixin + +```jsonnet +RegexMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withType + +```jsonnet +RegexMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RegexMap.options + + +##### fn RegexMap.options.withPattern + +```jsonnet +RegexMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn RegexMap.options.withResult + +```jsonnet +RegexMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RegexMap.options.withResultMixin + +```jsonnet +RegexMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj RegexMap.options.result + + +###### fn RegexMap.options.result.withColor + +```jsonnet +RegexMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIcon + +```jsonnet +RegexMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIndex + +```jsonnet +RegexMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RegexMap.options.result.withText + +```jsonnet +RegexMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj SpecialValueMap + + +#### fn SpecialValueMap.withOptions + +```jsonnet +SpecialValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withOptionsMixin + +```jsonnet +SpecialValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withType + +```jsonnet +SpecialValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj SpecialValueMap.options + + +##### fn SpecialValueMap.options.withMatch + +```jsonnet +SpecialValueMap.options.withMatch(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"true"`, `"false"` + + +##### fn SpecialValueMap.options.withPattern + +```jsonnet +SpecialValueMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn SpecialValueMap.options.withResult + +```jsonnet +SpecialValueMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn SpecialValueMap.options.withResultMixin + +```jsonnet +SpecialValueMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj SpecialValueMap.options.result + + +###### fn SpecialValueMap.options.result.withColor + +```jsonnet +SpecialValueMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIcon + +```jsonnet +SpecialValueMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIndex + +```jsonnet +SpecialValueMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn SpecialValueMap.options.result.withText + +```jsonnet +SpecialValueMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj ValueMap + + +#### fn ValueMap.withOptions + +```jsonnet +ValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withOptionsMixin + +```jsonnet +ValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withType + +```jsonnet +ValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/dashboardList/standardOptions/override.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/dashboardList/standardOptions/override.md new file mode 100644 index 0000000000..154f3dbdac --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/dashboardList/standardOptions/override.md @@ -0,0 +1,244 @@ +# override + +Overrides allow you to customize visualization settings for specific fields or +series. This is accomplished by adding an override rule that targets +a particular set of fields and that can each define multiple options. + +```jsonnet +override.byType.new('number') ++ override.byType.withPropertiesFromOptions( + panel.standardOptions.withDecimals(2) + + panel.standardOptions.withUnit('s') +) +``` + + +## Index + +* [`obj byName`](#obj-byname) + * [`fn new(value)`](#fn-bynamenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bynamewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bynamewithproperty) +* [`obj byQuery`](#obj-byquery) + * [`fn new(value)`](#fn-byquerynew) + * [`fn withPropertiesFromOptions(options)`](#fn-byquerywithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byquerywithproperty) +* [`obj byRegexp`](#obj-byregexp) + * [`fn new(value)`](#fn-byregexpnew) + * [`fn withPropertiesFromOptions(options)`](#fn-byregexpwithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byregexpwithproperty) +* [`obj byType`](#obj-bytype) + * [`fn new(value)`](#fn-bytypenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bytypewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bytypewithproperty) +* [`obj byValue`](#obj-byvalue) + * [`fn new(value)`](#fn-byvaluenew) + * [`fn withPropertiesFromOptions(options)`](#fn-byvaluewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byvaluewithproperty) + +## Fields + +### obj byName + + +#### fn byName.new + +```jsonnet +byName.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byName`. +#### fn byName.withPropertiesFromOptions + +```jsonnet +byName.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byName.withProperty + +```jsonnet +byName.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byQuery + + +#### fn byQuery.new + +```jsonnet +byQuery.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byQuery`. +#### fn byQuery.withPropertiesFromOptions + +```jsonnet +byQuery.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byQuery.withProperty + +```jsonnet +byQuery.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byRegexp + + +#### fn byRegexp.new + +```jsonnet +byRegexp.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byRegexp`. +#### fn byRegexp.withPropertiesFromOptions + +```jsonnet +byRegexp.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byRegexp.withProperty + +```jsonnet +byRegexp.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byType + + +#### fn byType.new + +```jsonnet +byType.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byType`. +#### fn byType.withPropertiesFromOptions + +```jsonnet +byType.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byType.withProperty + +```jsonnet +byType.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byValue + + +#### fn byValue.new + +```jsonnet +byValue.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byValue`. +#### fn byValue.withPropertiesFromOptions + +```jsonnet +byValue.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byValue.withProperty + +```jsonnet +byValue.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/dashboardList/standardOptions/threshold/step.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/dashboardList/standardOptions/threshold/step.md new file mode 100644 index 0000000000..dd2dd227ff --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/dashboardList/standardOptions/threshold/step.md @@ -0,0 +1,60 @@ +# threshold.step + + + +## Index + +* [`fn withColor(value)`](#fn-withcolor) +* [`fn withIndex(value)`](#fn-withindex) +* [`fn withState(value)`](#fn-withstate) +* [`fn withValue(value)`](#fn-withvalue) + +## Fields + +### fn withColor + +```jsonnet +withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +### fn withIndex + +```jsonnet +withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Threshold index, an old property that is not needed an should only appear in older dashboards +### fn withState + +```jsonnet +withState(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO are the values here enumerable into a disjunction? +Some seem to be listed in typescript comment +### fn withValue + +```jsonnet +withValue(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +FIXME the corresponding typescript field is required/non-optional, but nulls currently appear here when serializing -Infinity to JSON \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/datagrid/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/datagrid/index.md new file mode 100644 index 0000000000..27438c0a77 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/datagrid/index.md @@ -0,0 +1,581 @@ +# datagrid + +grafonnet.panel.datagrid + +## Subpackages + +* [panelOptions.link](panelOptions/link.md) +* [queryOptions.transformation](queryOptions/transformation.md) +* [standardOptions.mapping](standardOptions/mapping.md) +* [standardOptions.override](standardOptions/override.md) +* [standardOptions.threshold.step](standardOptions/threshold/step.md) + +## Index + +* [`fn new(title)`](#fn-new) +* [`obj libraryPanel`](#obj-librarypanel) + * [`fn withName(value)`](#fn-librarypanelwithname) + * [`fn withUid(value)`](#fn-librarypanelwithuid) +* [`obj options`](#obj-options) + * [`fn withSelectedSeries(value=0)`](#fn-optionswithselectedseries) +* [`obj panelOptions`](#obj-paneloptions) + * [`fn withDescription(value)`](#fn-paneloptionswithdescription) + * [`fn withGridPos(h="null", w="null", x="null", y="null")`](#fn-paneloptionswithgridpos) + * [`fn withLinks(value)`](#fn-paneloptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-paneloptionswithlinksmixin) + * [`fn withRepeat(value)`](#fn-paneloptionswithrepeat) + * [`fn withRepeatDirection(value="h")`](#fn-paneloptionswithrepeatdirection) + * [`fn withTitle(value)`](#fn-paneloptionswithtitle) + * [`fn withTransparent(value=true)`](#fn-paneloptionswithtransparent) +* [`obj queryOptions`](#obj-queryoptions) + * [`fn withDatasource(type, uid)`](#fn-queryoptionswithdatasource) + * [`fn withDatasourceMixin(value)`](#fn-queryoptionswithdatasourcemixin) + * [`fn withInterval(value)`](#fn-queryoptionswithinterval) + * [`fn withMaxDataPoints(value)`](#fn-queryoptionswithmaxdatapoints) + * [`fn withTargets(value)`](#fn-queryoptionswithtargets) + * [`fn withTargetsMixin(value)`](#fn-queryoptionswithtargetsmixin) + * [`fn withTimeFrom(value)`](#fn-queryoptionswithtimefrom) + * [`fn withTimeShift(value)`](#fn-queryoptionswithtimeshift) + * [`fn withTransformations(value)`](#fn-queryoptionswithtransformations) + * [`fn withTransformationsMixin(value)`](#fn-queryoptionswithtransformationsmixin) +* [`obj standardOptions`](#obj-standardoptions) + * [`fn withDecimals(value)`](#fn-standardoptionswithdecimals) + * [`fn withDisplayName(value)`](#fn-standardoptionswithdisplayname) + * [`fn withFilterable(value=true)`](#fn-standardoptionswithfilterable) + * [`fn withLinks(value)`](#fn-standardoptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-standardoptionswithlinksmixin) + * [`fn withMappings(value)`](#fn-standardoptionswithmappings) + * [`fn withMappingsMixin(value)`](#fn-standardoptionswithmappingsmixin) + * [`fn withMax(value)`](#fn-standardoptionswithmax) + * [`fn withMin(value)`](#fn-standardoptionswithmin) + * [`fn withNoValue(value)`](#fn-standardoptionswithnovalue) + * [`fn withOverrides(value)`](#fn-standardoptionswithoverrides) + * [`fn withOverridesMixin(value)`](#fn-standardoptionswithoverridesmixin) + * [`fn withPath(value)`](#fn-standardoptionswithpath) + * [`fn withUnit(value)`](#fn-standardoptionswithunit) + * [`obj color`](#obj-standardoptionscolor) + * [`fn withFixedColor(value)`](#fn-standardoptionscolorwithfixedcolor) + * [`fn withMode(value)`](#fn-standardoptionscolorwithmode) + * [`fn withSeriesBy(value)`](#fn-standardoptionscolorwithseriesby) + * [`obj thresholds`](#obj-standardoptionsthresholds) + * [`fn withMode(value)`](#fn-standardoptionsthresholdswithmode) + * [`fn withSteps(value)`](#fn-standardoptionsthresholdswithsteps) + * [`fn withStepsMixin(value)`](#fn-standardoptionsthresholdswithstepsmixin) + +## Fields + +### fn new + +```jsonnet +new(title) +``` + +PARAMETERS: + +* **title** (`string`) + +Creates a new datagrid panel with a title. +### obj libraryPanel + + +#### fn libraryPanel.withName + +```jsonnet +libraryPanel.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn libraryPanel.withUid + +```jsonnet +libraryPanel.withUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj options + + +#### fn options.withSelectedSeries + +```jsonnet +options.withSelectedSeries(value=0) +``` + +PARAMETERS: + +* **value** (`integer`) + - default value: `0` + + +### obj panelOptions + + +#### fn panelOptions.withDescription + +```jsonnet +panelOptions.withDescription(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Description. +#### fn panelOptions.withGridPos + +```jsonnet +panelOptions.withGridPos(h="null", w="null", x="null", y="null") +``` + +PARAMETERS: + +* **h** (`number`) + - default value: `"null"` +* **w** (`number`) + - default value: `"null"` +* **x** (`number`) + - default value: `"null"` +* **y** (`number`) + - default value: `"null"` + +`withGridPos` configures the height, width and xy coordinates of the panel. Also see `grafonnet.util.grid` for helper functions to calculate these fields. + +All arguments default to `null`, which means they will remain unchanged or unset. + +#### fn panelOptions.withLinks + +```jsonnet +panelOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withLinksMixin + +```jsonnet +panelOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withRepeat + +```jsonnet +panelOptions.withRepeat(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of template variable to repeat for. +#### fn panelOptions.withRepeatDirection + +```jsonnet +panelOptions.withRepeatDirection(value="h") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"h"` + - valid values: `"h"`, `"v"` + +Direction to repeat in if 'repeat' is set. +"h" for horizontal, "v" for vertical. +TODO this is probably optional +#### fn panelOptions.withTitle + +```jsonnet +panelOptions.withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Panel title. +#### fn panelOptions.withTransparent + +```jsonnet +panelOptions.withTransparent(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Whether to display the panel without a background. +### obj queryOptions + + +#### fn queryOptions.withDatasource + +```jsonnet +queryOptions.withDatasource(type, uid) +``` + +PARAMETERS: + +* **type** (`string`) +* **uid** (`string`) + +`withDatasource` sets the datasource for all queries in a panel. + +The default datasource for a panel is set to 'Mixed datasource' so panels can be datasource agnostic, which is a lot more interesting from a reusability standpoint. Note that this requires query targets to explicitly set datasource for the same reason. + +#### fn queryOptions.withDatasourceMixin + +```jsonnet +queryOptions.withDatasourceMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +The datasource used in all targets. +#### fn queryOptions.withInterval + +```jsonnet +queryOptions.withInterval(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withMaxDataPoints + +```jsonnet +queryOptions.withMaxDataPoints(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +#### fn queryOptions.withTargets + +```jsonnet +queryOptions.withTargets(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTargetsMixin + +```jsonnet +queryOptions.withTargetsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTimeFrom + +```jsonnet +queryOptions.withTimeFrom(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTimeShift + +```jsonnet +queryOptions.withTimeShift(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTransformations + +```jsonnet +queryOptions.withTransformations(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn queryOptions.withTransformationsMixin + +```jsonnet +queryOptions.withTransformationsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### obj standardOptions + + +#### fn standardOptions.withDecimals + +```jsonnet +standardOptions.withDecimals(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Significant digits (for display) +#### fn standardOptions.withDisplayName + +```jsonnet +standardOptions.withDisplayName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The display value for this field. This supports template variables blank is auto +#### fn standardOptions.withFilterable + +```jsonnet +standardOptions.withFilterable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +True if data source field supports ad-hoc filters +#### fn standardOptions.withLinks + +```jsonnet +standardOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withLinksMixin + +```jsonnet +standardOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withMappings + +```jsonnet +standardOptions.withMappings(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMappingsMixin + +```jsonnet +standardOptions.withMappingsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMax + +```jsonnet +standardOptions.withMax(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withMin + +```jsonnet +standardOptions.withMin(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withNoValue + +```jsonnet +standardOptions.withNoValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Alternative to empty string +#### fn standardOptions.withOverrides + +```jsonnet +standardOptions.withOverrides(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withOverridesMixin + +```jsonnet +standardOptions.withOverridesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withPath + +```jsonnet +standardOptions.withPath(value) +``` + +PARAMETERS: + +* **value** (`string`) + +An explicit path to the field in the datasource. When the frame meta includes a path, +This will default to `${frame.meta.path}/${field.name} + +When defined, this value can be used as an identifier within the datasource scope, and +may be used to update the results +#### fn standardOptions.withUnit + +```jsonnet +standardOptions.withUnit(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Numeric Options +#### obj standardOptions.color + + +##### fn standardOptions.color.withFixedColor + +```jsonnet +standardOptions.color.withFixedColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Stores the fixed color value if mode is fixed +##### fn standardOptions.color.withMode + +```jsonnet +standardOptions.color.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The main color scheme mode +##### fn standardOptions.color.withSeriesBy + +```jsonnet +standardOptions.color.withSeriesBy(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"min"`, `"max"`, `"last"` + +TODO docs +#### obj standardOptions.thresholds + + +##### fn standardOptions.thresholds.withMode + +```jsonnet +standardOptions.thresholds.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"absolute"`, `"percentage"` + + +##### fn standardOptions.thresholds.withSteps + +```jsonnet +standardOptions.thresholds.withSteps(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity +##### fn standardOptions.thresholds.withStepsMixin + +```jsonnet +standardOptions.thresholds.withStepsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/datagrid/panelOptions/link.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/datagrid/panelOptions/link.md new file mode 100644 index 0000000000..106f9d2edb --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/datagrid/panelOptions/link.md @@ -0,0 +1,145 @@ +# link + + + +## Index + +* [`fn withAsDropdown(value=true)`](#fn-withasdropdown) +* [`fn withIcon(value)`](#fn-withicon) +* [`fn withIncludeVars(value=true)`](#fn-withincludevars) +* [`fn withKeepTime(value=true)`](#fn-withkeeptime) +* [`fn withTags(value)`](#fn-withtags) +* [`fn withTagsMixin(value)`](#fn-withtagsmixin) +* [`fn withTargetBlank(value=true)`](#fn-withtargetblank) +* [`fn withTitle(value)`](#fn-withtitle) +* [`fn withTooltip(value)`](#fn-withtooltip) +* [`fn withType(value)`](#fn-withtype) +* [`fn withUrl(value)`](#fn-withurl) + +## Fields + +### fn withAsDropdown + +```jsonnet +withAsDropdown(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withIcon + +```jsonnet +withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withIncludeVars + +```jsonnet +withIncludeVars(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withKeepTime + +```jsonnet +withKeepTime(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTags + +```jsonnet +withTags(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTagsMixin + +```jsonnet +withTagsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTargetBlank + +```jsonnet +withTargetBlank(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTitle + +```jsonnet +withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withTooltip + +```jsonnet +withTooltip(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withType + +```jsonnet +withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"link"`, `"dashboards"` + +TODO docs +### fn withUrl + +```jsonnet +withUrl(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/datagrid/queryOptions/transformation.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/datagrid/queryOptions/transformation.md new file mode 100644 index 0000000000..dc832f653d --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/datagrid/queryOptions/transformation.md @@ -0,0 +1,99 @@ +# transformation + + + +## Index + +* [`fn withDisabled(value=true)`](#fn-withdisabled) +* [`fn withFilter(value)`](#fn-withfilter) +* [`fn withFilterMixin(value)`](#fn-withfiltermixin) +* [`fn withId(value)`](#fn-withid) +* [`fn withOptions(value)`](#fn-withoptions) +* [`obj filter`](#obj-filter) + * [`fn withId(value="")`](#fn-filterwithid) + * [`fn withOptions(value)`](#fn-filterwithoptions) + +## Fields + +### fn withDisabled + +```jsonnet +withDisabled(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Disabled transformations are skipped +### fn withFilter + +```jsonnet +withFilter(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withFilterMixin + +```jsonnet +withFilterMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withId + +```jsonnet +withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Unique identifier of transformer +### fn withOptions + +```jsonnet +withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Options to be passed to the transformer +Valid options depend on the transformer id +### obj filter + + +#### fn filter.withId + +```jsonnet +filter.withId(value="") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `""` + + +#### fn filter.withOptions + +```jsonnet +filter.withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/datagrid/standardOptions/mapping.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/datagrid/standardOptions/mapping.md new file mode 100644 index 0000000000..93296972e8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/datagrid/standardOptions/mapping.md @@ -0,0 +1,469 @@ +# mapping + + + +## Index + +* [`obj RangeMap`](#obj-rangemap) + * [`fn withOptions(value)`](#fn-rangemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-rangemapwithoptionsmixin) + * [`fn withType(value)`](#fn-rangemapwithtype) + * [`obj options`](#obj-rangemapoptions) + * [`fn withFrom(value)`](#fn-rangemapoptionswithfrom) + * [`fn withResult(value)`](#fn-rangemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-rangemapoptionswithresultmixin) + * [`fn withTo(value)`](#fn-rangemapoptionswithto) + * [`obj result`](#obj-rangemapoptionsresult) + * [`fn withColor(value)`](#fn-rangemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-rangemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-rangemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-rangemapoptionsresultwithtext) +* [`obj RegexMap`](#obj-regexmap) + * [`fn withOptions(value)`](#fn-regexmapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-regexmapwithoptionsmixin) + * [`fn withType(value)`](#fn-regexmapwithtype) + * [`obj options`](#obj-regexmapoptions) + * [`fn withPattern(value)`](#fn-regexmapoptionswithpattern) + * [`fn withResult(value)`](#fn-regexmapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-regexmapoptionswithresultmixin) + * [`obj result`](#obj-regexmapoptionsresult) + * [`fn withColor(value)`](#fn-regexmapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-regexmapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-regexmapoptionsresultwithindex) + * [`fn withText(value)`](#fn-regexmapoptionsresultwithtext) +* [`obj SpecialValueMap`](#obj-specialvaluemap) + * [`fn withOptions(value)`](#fn-specialvaluemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-specialvaluemapwithoptionsmixin) + * [`fn withType(value)`](#fn-specialvaluemapwithtype) + * [`obj options`](#obj-specialvaluemapoptions) + * [`fn withMatch(value)`](#fn-specialvaluemapoptionswithmatch) + * [`fn withPattern(value)`](#fn-specialvaluemapoptionswithpattern) + * [`fn withResult(value)`](#fn-specialvaluemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-specialvaluemapoptionswithresultmixin) + * [`obj result`](#obj-specialvaluemapoptionsresult) + * [`fn withColor(value)`](#fn-specialvaluemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-specialvaluemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-specialvaluemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-specialvaluemapoptionsresultwithtext) +* [`obj ValueMap`](#obj-valuemap) + * [`fn withOptions(value)`](#fn-valuemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-valuemapwithoptionsmixin) + * [`fn withType(value)`](#fn-valuemapwithtype) + +## Fields + +### obj RangeMap + + +#### fn RangeMap.withOptions + +```jsonnet +RangeMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withOptionsMixin + +```jsonnet +RangeMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withType + +```jsonnet +RangeMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RangeMap.options + + +##### fn RangeMap.options.withFrom + +```jsonnet +RangeMap.options.withFrom(value) +``` + +PARAMETERS: + +* **value** (`number`) + +to and from are `number | null` in current ts, really not sure what to do +##### fn RangeMap.options.withResult + +```jsonnet +RangeMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withResultMixin + +```jsonnet +RangeMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withTo + +```jsonnet +RangeMap.options.withTo(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +##### obj RangeMap.options.result + + +###### fn RangeMap.options.result.withColor + +```jsonnet +RangeMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIcon + +```jsonnet +RangeMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIndex + +```jsonnet +RangeMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RangeMap.options.result.withText + +```jsonnet +RangeMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj RegexMap + + +#### fn RegexMap.withOptions + +```jsonnet +RegexMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withOptionsMixin + +```jsonnet +RegexMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withType + +```jsonnet +RegexMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RegexMap.options + + +##### fn RegexMap.options.withPattern + +```jsonnet +RegexMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn RegexMap.options.withResult + +```jsonnet +RegexMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RegexMap.options.withResultMixin + +```jsonnet +RegexMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj RegexMap.options.result + + +###### fn RegexMap.options.result.withColor + +```jsonnet +RegexMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIcon + +```jsonnet +RegexMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIndex + +```jsonnet +RegexMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RegexMap.options.result.withText + +```jsonnet +RegexMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj SpecialValueMap + + +#### fn SpecialValueMap.withOptions + +```jsonnet +SpecialValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withOptionsMixin + +```jsonnet +SpecialValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withType + +```jsonnet +SpecialValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj SpecialValueMap.options + + +##### fn SpecialValueMap.options.withMatch + +```jsonnet +SpecialValueMap.options.withMatch(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"true"`, `"false"` + + +##### fn SpecialValueMap.options.withPattern + +```jsonnet +SpecialValueMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn SpecialValueMap.options.withResult + +```jsonnet +SpecialValueMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn SpecialValueMap.options.withResultMixin + +```jsonnet +SpecialValueMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj SpecialValueMap.options.result + + +###### fn SpecialValueMap.options.result.withColor + +```jsonnet +SpecialValueMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIcon + +```jsonnet +SpecialValueMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIndex + +```jsonnet +SpecialValueMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn SpecialValueMap.options.result.withText + +```jsonnet +SpecialValueMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj ValueMap + + +#### fn ValueMap.withOptions + +```jsonnet +ValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withOptionsMixin + +```jsonnet +ValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withType + +```jsonnet +ValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/datagrid/standardOptions/override.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/datagrid/standardOptions/override.md new file mode 100644 index 0000000000..154f3dbdac --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/datagrid/standardOptions/override.md @@ -0,0 +1,244 @@ +# override + +Overrides allow you to customize visualization settings for specific fields or +series. This is accomplished by adding an override rule that targets +a particular set of fields and that can each define multiple options. + +```jsonnet +override.byType.new('number') ++ override.byType.withPropertiesFromOptions( + panel.standardOptions.withDecimals(2) + + panel.standardOptions.withUnit('s') +) +``` + + +## Index + +* [`obj byName`](#obj-byname) + * [`fn new(value)`](#fn-bynamenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bynamewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bynamewithproperty) +* [`obj byQuery`](#obj-byquery) + * [`fn new(value)`](#fn-byquerynew) + * [`fn withPropertiesFromOptions(options)`](#fn-byquerywithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byquerywithproperty) +* [`obj byRegexp`](#obj-byregexp) + * [`fn new(value)`](#fn-byregexpnew) + * [`fn withPropertiesFromOptions(options)`](#fn-byregexpwithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byregexpwithproperty) +* [`obj byType`](#obj-bytype) + * [`fn new(value)`](#fn-bytypenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bytypewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bytypewithproperty) +* [`obj byValue`](#obj-byvalue) + * [`fn new(value)`](#fn-byvaluenew) + * [`fn withPropertiesFromOptions(options)`](#fn-byvaluewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byvaluewithproperty) + +## Fields + +### obj byName + + +#### fn byName.new + +```jsonnet +byName.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byName`. +#### fn byName.withPropertiesFromOptions + +```jsonnet +byName.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byName.withProperty + +```jsonnet +byName.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byQuery + + +#### fn byQuery.new + +```jsonnet +byQuery.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byQuery`. +#### fn byQuery.withPropertiesFromOptions + +```jsonnet +byQuery.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byQuery.withProperty + +```jsonnet +byQuery.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byRegexp + + +#### fn byRegexp.new + +```jsonnet +byRegexp.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byRegexp`. +#### fn byRegexp.withPropertiesFromOptions + +```jsonnet +byRegexp.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byRegexp.withProperty + +```jsonnet +byRegexp.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byType + + +#### fn byType.new + +```jsonnet +byType.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byType`. +#### fn byType.withPropertiesFromOptions + +```jsonnet +byType.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byType.withProperty + +```jsonnet +byType.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byValue + + +#### fn byValue.new + +```jsonnet +byValue.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byValue`. +#### fn byValue.withPropertiesFromOptions + +```jsonnet +byValue.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byValue.withProperty + +```jsonnet +byValue.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/datagrid/standardOptions/threshold/step.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/datagrid/standardOptions/threshold/step.md new file mode 100644 index 0000000000..dd2dd227ff --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/datagrid/standardOptions/threshold/step.md @@ -0,0 +1,60 @@ +# threshold.step + + + +## Index + +* [`fn withColor(value)`](#fn-withcolor) +* [`fn withIndex(value)`](#fn-withindex) +* [`fn withState(value)`](#fn-withstate) +* [`fn withValue(value)`](#fn-withvalue) + +## Fields + +### fn withColor + +```jsonnet +withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +### fn withIndex + +```jsonnet +withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Threshold index, an old property that is not needed an should only appear in older dashboards +### fn withState + +```jsonnet +withState(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO are the values here enumerable into a disjunction? +Some seem to be listed in typescript comment +### fn withValue + +```jsonnet +withValue(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +FIXME the corresponding typescript field is required/non-optional, but nulls currently appear here when serializing -Infinity to JSON \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/debug/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/debug/index.md new file mode 100644 index 0000000000..edf7a291e4 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/debug/index.md @@ -0,0 +1,648 @@ +# debug + +grafonnet.panel.debug + +## Subpackages + +* [panelOptions.link](panelOptions/link.md) +* [queryOptions.transformation](queryOptions/transformation.md) +* [standardOptions.mapping](standardOptions/mapping.md) +* [standardOptions.override](standardOptions/override.md) +* [standardOptions.threshold.step](standardOptions/threshold/step.md) + +## Index + +* [`fn new(title)`](#fn-new) +* [`obj libraryPanel`](#obj-librarypanel) + * [`fn withName(value)`](#fn-librarypanelwithname) + * [`fn withUid(value)`](#fn-librarypanelwithuid) +* [`obj options`](#obj-options) + * [`fn withCounters(value)`](#fn-optionswithcounters) + * [`fn withCountersMixin(value)`](#fn-optionswithcountersmixin) + * [`fn withMode(value)`](#fn-optionswithmode) + * [`obj counters`](#obj-optionscounters) + * [`fn withDataChanged(value=true)`](#fn-optionscounterswithdatachanged) + * [`fn withRender(value=true)`](#fn-optionscounterswithrender) + * [`fn withSchemaChanged(value=true)`](#fn-optionscounterswithschemachanged) +* [`obj panelOptions`](#obj-paneloptions) + * [`fn withDescription(value)`](#fn-paneloptionswithdescription) + * [`fn withGridPos(h="null", w="null", x="null", y="null")`](#fn-paneloptionswithgridpos) + * [`fn withLinks(value)`](#fn-paneloptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-paneloptionswithlinksmixin) + * [`fn withRepeat(value)`](#fn-paneloptionswithrepeat) + * [`fn withRepeatDirection(value="h")`](#fn-paneloptionswithrepeatdirection) + * [`fn withTitle(value)`](#fn-paneloptionswithtitle) + * [`fn withTransparent(value=true)`](#fn-paneloptionswithtransparent) +* [`obj queryOptions`](#obj-queryoptions) + * [`fn withDatasource(type, uid)`](#fn-queryoptionswithdatasource) + * [`fn withDatasourceMixin(value)`](#fn-queryoptionswithdatasourcemixin) + * [`fn withInterval(value)`](#fn-queryoptionswithinterval) + * [`fn withMaxDataPoints(value)`](#fn-queryoptionswithmaxdatapoints) + * [`fn withTargets(value)`](#fn-queryoptionswithtargets) + * [`fn withTargetsMixin(value)`](#fn-queryoptionswithtargetsmixin) + * [`fn withTimeFrom(value)`](#fn-queryoptionswithtimefrom) + * [`fn withTimeShift(value)`](#fn-queryoptionswithtimeshift) + * [`fn withTransformations(value)`](#fn-queryoptionswithtransformations) + * [`fn withTransformationsMixin(value)`](#fn-queryoptionswithtransformationsmixin) +* [`obj standardOptions`](#obj-standardoptions) + * [`fn withDecimals(value)`](#fn-standardoptionswithdecimals) + * [`fn withDisplayName(value)`](#fn-standardoptionswithdisplayname) + * [`fn withFilterable(value=true)`](#fn-standardoptionswithfilterable) + * [`fn withLinks(value)`](#fn-standardoptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-standardoptionswithlinksmixin) + * [`fn withMappings(value)`](#fn-standardoptionswithmappings) + * [`fn withMappingsMixin(value)`](#fn-standardoptionswithmappingsmixin) + * [`fn withMax(value)`](#fn-standardoptionswithmax) + * [`fn withMin(value)`](#fn-standardoptionswithmin) + * [`fn withNoValue(value)`](#fn-standardoptionswithnovalue) + * [`fn withOverrides(value)`](#fn-standardoptionswithoverrides) + * [`fn withOverridesMixin(value)`](#fn-standardoptionswithoverridesmixin) + * [`fn withPath(value)`](#fn-standardoptionswithpath) + * [`fn withUnit(value)`](#fn-standardoptionswithunit) + * [`obj color`](#obj-standardoptionscolor) + * [`fn withFixedColor(value)`](#fn-standardoptionscolorwithfixedcolor) + * [`fn withMode(value)`](#fn-standardoptionscolorwithmode) + * [`fn withSeriesBy(value)`](#fn-standardoptionscolorwithseriesby) + * [`obj thresholds`](#obj-standardoptionsthresholds) + * [`fn withMode(value)`](#fn-standardoptionsthresholdswithmode) + * [`fn withSteps(value)`](#fn-standardoptionsthresholdswithsteps) + * [`fn withStepsMixin(value)`](#fn-standardoptionsthresholdswithstepsmixin) + +## Fields + +### fn new + +```jsonnet +new(title) +``` + +PARAMETERS: + +* **title** (`string`) + +Creates a new debug panel with a title. +### obj libraryPanel + + +#### fn libraryPanel.withName + +```jsonnet +libraryPanel.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn libraryPanel.withUid + +```jsonnet +libraryPanel.withUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj options + + +#### fn options.withCounters + +```jsonnet +options.withCounters(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn options.withCountersMixin + +```jsonnet +options.withCountersMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn options.withMode + +```jsonnet +options.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"render"`, `"events"`, `"cursor"`, `"State"`, `"ThrowError"` + + +#### obj options.counters + + +##### fn options.counters.withDataChanged + +```jsonnet +options.counters.withDataChanged(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.counters.withRender + +```jsonnet +options.counters.withRender(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.counters.withSchemaChanged + +```jsonnet +options.counters.withSchemaChanged(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### obj panelOptions + + +#### fn panelOptions.withDescription + +```jsonnet +panelOptions.withDescription(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Description. +#### fn panelOptions.withGridPos + +```jsonnet +panelOptions.withGridPos(h="null", w="null", x="null", y="null") +``` + +PARAMETERS: + +* **h** (`number`) + - default value: `"null"` +* **w** (`number`) + - default value: `"null"` +* **x** (`number`) + - default value: `"null"` +* **y** (`number`) + - default value: `"null"` + +`withGridPos` configures the height, width and xy coordinates of the panel. Also see `grafonnet.util.grid` for helper functions to calculate these fields. + +All arguments default to `null`, which means they will remain unchanged or unset. + +#### fn panelOptions.withLinks + +```jsonnet +panelOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withLinksMixin + +```jsonnet +panelOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withRepeat + +```jsonnet +panelOptions.withRepeat(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of template variable to repeat for. +#### fn panelOptions.withRepeatDirection + +```jsonnet +panelOptions.withRepeatDirection(value="h") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"h"` + - valid values: `"h"`, `"v"` + +Direction to repeat in if 'repeat' is set. +"h" for horizontal, "v" for vertical. +TODO this is probably optional +#### fn panelOptions.withTitle + +```jsonnet +panelOptions.withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Panel title. +#### fn panelOptions.withTransparent + +```jsonnet +panelOptions.withTransparent(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Whether to display the panel without a background. +### obj queryOptions + + +#### fn queryOptions.withDatasource + +```jsonnet +queryOptions.withDatasource(type, uid) +``` + +PARAMETERS: + +* **type** (`string`) +* **uid** (`string`) + +`withDatasource` sets the datasource for all queries in a panel. + +The default datasource for a panel is set to 'Mixed datasource' so panels can be datasource agnostic, which is a lot more interesting from a reusability standpoint. Note that this requires query targets to explicitly set datasource for the same reason. + +#### fn queryOptions.withDatasourceMixin + +```jsonnet +queryOptions.withDatasourceMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +The datasource used in all targets. +#### fn queryOptions.withInterval + +```jsonnet +queryOptions.withInterval(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withMaxDataPoints + +```jsonnet +queryOptions.withMaxDataPoints(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +#### fn queryOptions.withTargets + +```jsonnet +queryOptions.withTargets(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTargetsMixin + +```jsonnet +queryOptions.withTargetsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTimeFrom + +```jsonnet +queryOptions.withTimeFrom(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTimeShift + +```jsonnet +queryOptions.withTimeShift(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTransformations + +```jsonnet +queryOptions.withTransformations(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn queryOptions.withTransformationsMixin + +```jsonnet +queryOptions.withTransformationsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### obj standardOptions + + +#### fn standardOptions.withDecimals + +```jsonnet +standardOptions.withDecimals(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Significant digits (for display) +#### fn standardOptions.withDisplayName + +```jsonnet +standardOptions.withDisplayName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The display value for this field. This supports template variables blank is auto +#### fn standardOptions.withFilterable + +```jsonnet +standardOptions.withFilterable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +True if data source field supports ad-hoc filters +#### fn standardOptions.withLinks + +```jsonnet +standardOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withLinksMixin + +```jsonnet +standardOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withMappings + +```jsonnet +standardOptions.withMappings(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMappingsMixin + +```jsonnet +standardOptions.withMappingsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMax + +```jsonnet +standardOptions.withMax(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withMin + +```jsonnet +standardOptions.withMin(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withNoValue + +```jsonnet +standardOptions.withNoValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Alternative to empty string +#### fn standardOptions.withOverrides + +```jsonnet +standardOptions.withOverrides(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withOverridesMixin + +```jsonnet +standardOptions.withOverridesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withPath + +```jsonnet +standardOptions.withPath(value) +``` + +PARAMETERS: + +* **value** (`string`) + +An explicit path to the field in the datasource. When the frame meta includes a path, +This will default to `${frame.meta.path}/${field.name} + +When defined, this value can be used as an identifier within the datasource scope, and +may be used to update the results +#### fn standardOptions.withUnit + +```jsonnet +standardOptions.withUnit(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Numeric Options +#### obj standardOptions.color + + +##### fn standardOptions.color.withFixedColor + +```jsonnet +standardOptions.color.withFixedColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Stores the fixed color value if mode is fixed +##### fn standardOptions.color.withMode + +```jsonnet +standardOptions.color.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The main color scheme mode +##### fn standardOptions.color.withSeriesBy + +```jsonnet +standardOptions.color.withSeriesBy(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"min"`, `"max"`, `"last"` + +TODO docs +#### obj standardOptions.thresholds + + +##### fn standardOptions.thresholds.withMode + +```jsonnet +standardOptions.thresholds.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"absolute"`, `"percentage"` + + +##### fn standardOptions.thresholds.withSteps + +```jsonnet +standardOptions.thresholds.withSteps(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity +##### fn standardOptions.thresholds.withStepsMixin + +```jsonnet +standardOptions.thresholds.withStepsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/debug/panelOptions/link.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/debug/panelOptions/link.md new file mode 100644 index 0000000000..106f9d2edb --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/debug/panelOptions/link.md @@ -0,0 +1,145 @@ +# link + + + +## Index + +* [`fn withAsDropdown(value=true)`](#fn-withasdropdown) +* [`fn withIcon(value)`](#fn-withicon) +* [`fn withIncludeVars(value=true)`](#fn-withincludevars) +* [`fn withKeepTime(value=true)`](#fn-withkeeptime) +* [`fn withTags(value)`](#fn-withtags) +* [`fn withTagsMixin(value)`](#fn-withtagsmixin) +* [`fn withTargetBlank(value=true)`](#fn-withtargetblank) +* [`fn withTitle(value)`](#fn-withtitle) +* [`fn withTooltip(value)`](#fn-withtooltip) +* [`fn withType(value)`](#fn-withtype) +* [`fn withUrl(value)`](#fn-withurl) + +## Fields + +### fn withAsDropdown + +```jsonnet +withAsDropdown(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withIcon + +```jsonnet +withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withIncludeVars + +```jsonnet +withIncludeVars(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withKeepTime + +```jsonnet +withKeepTime(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTags + +```jsonnet +withTags(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTagsMixin + +```jsonnet +withTagsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTargetBlank + +```jsonnet +withTargetBlank(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTitle + +```jsonnet +withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withTooltip + +```jsonnet +withTooltip(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withType + +```jsonnet +withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"link"`, `"dashboards"` + +TODO docs +### fn withUrl + +```jsonnet +withUrl(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/debug/queryOptions/transformation.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/debug/queryOptions/transformation.md new file mode 100644 index 0000000000..dc832f653d --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/debug/queryOptions/transformation.md @@ -0,0 +1,99 @@ +# transformation + + + +## Index + +* [`fn withDisabled(value=true)`](#fn-withdisabled) +* [`fn withFilter(value)`](#fn-withfilter) +* [`fn withFilterMixin(value)`](#fn-withfiltermixin) +* [`fn withId(value)`](#fn-withid) +* [`fn withOptions(value)`](#fn-withoptions) +* [`obj filter`](#obj-filter) + * [`fn withId(value="")`](#fn-filterwithid) + * [`fn withOptions(value)`](#fn-filterwithoptions) + +## Fields + +### fn withDisabled + +```jsonnet +withDisabled(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Disabled transformations are skipped +### fn withFilter + +```jsonnet +withFilter(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withFilterMixin + +```jsonnet +withFilterMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withId + +```jsonnet +withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Unique identifier of transformer +### fn withOptions + +```jsonnet +withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Options to be passed to the transformer +Valid options depend on the transformer id +### obj filter + + +#### fn filter.withId + +```jsonnet +filter.withId(value="") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `""` + + +#### fn filter.withOptions + +```jsonnet +filter.withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/debug/standardOptions/mapping.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/debug/standardOptions/mapping.md new file mode 100644 index 0000000000..93296972e8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/debug/standardOptions/mapping.md @@ -0,0 +1,469 @@ +# mapping + + + +## Index + +* [`obj RangeMap`](#obj-rangemap) + * [`fn withOptions(value)`](#fn-rangemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-rangemapwithoptionsmixin) + * [`fn withType(value)`](#fn-rangemapwithtype) + * [`obj options`](#obj-rangemapoptions) + * [`fn withFrom(value)`](#fn-rangemapoptionswithfrom) + * [`fn withResult(value)`](#fn-rangemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-rangemapoptionswithresultmixin) + * [`fn withTo(value)`](#fn-rangemapoptionswithto) + * [`obj result`](#obj-rangemapoptionsresult) + * [`fn withColor(value)`](#fn-rangemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-rangemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-rangemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-rangemapoptionsresultwithtext) +* [`obj RegexMap`](#obj-regexmap) + * [`fn withOptions(value)`](#fn-regexmapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-regexmapwithoptionsmixin) + * [`fn withType(value)`](#fn-regexmapwithtype) + * [`obj options`](#obj-regexmapoptions) + * [`fn withPattern(value)`](#fn-regexmapoptionswithpattern) + * [`fn withResult(value)`](#fn-regexmapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-regexmapoptionswithresultmixin) + * [`obj result`](#obj-regexmapoptionsresult) + * [`fn withColor(value)`](#fn-regexmapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-regexmapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-regexmapoptionsresultwithindex) + * [`fn withText(value)`](#fn-regexmapoptionsresultwithtext) +* [`obj SpecialValueMap`](#obj-specialvaluemap) + * [`fn withOptions(value)`](#fn-specialvaluemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-specialvaluemapwithoptionsmixin) + * [`fn withType(value)`](#fn-specialvaluemapwithtype) + * [`obj options`](#obj-specialvaluemapoptions) + * [`fn withMatch(value)`](#fn-specialvaluemapoptionswithmatch) + * [`fn withPattern(value)`](#fn-specialvaluemapoptionswithpattern) + * [`fn withResult(value)`](#fn-specialvaluemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-specialvaluemapoptionswithresultmixin) + * [`obj result`](#obj-specialvaluemapoptionsresult) + * [`fn withColor(value)`](#fn-specialvaluemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-specialvaluemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-specialvaluemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-specialvaluemapoptionsresultwithtext) +* [`obj ValueMap`](#obj-valuemap) + * [`fn withOptions(value)`](#fn-valuemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-valuemapwithoptionsmixin) + * [`fn withType(value)`](#fn-valuemapwithtype) + +## Fields + +### obj RangeMap + + +#### fn RangeMap.withOptions + +```jsonnet +RangeMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withOptionsMixin + +```jsonnet +RangeMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withType + +```jsonnet +RangeMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RangeMap.options + + +##### fn RangeMap.options.withFrom + +```jsonnet +RangeMap.options.withFrom(value) +``` + +PARAMETERS: + +* **value** (`number`) + +to and from are `number | null` in current ts, really not sure what to do +##### fn RangeMap.options.withResult + +```jsonnet +RangeMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withResultMixin + +```jsonnet +RangeMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withTo + +```jsonnet +RangeMap.options.withTo(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +##### obj RangeMap.options.result + + +###### fn RangeMap.options.result.withColor + +```jsonnet +RangeMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIcon + +```jsonnet +RangeMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIndex + +```jsonnet +RangeMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RangeMap.options.result.withText + +```jsonnet +RangeMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj RegexMap + + +#### fn RegexMap.withOptions + +```jsonnet +RegexMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withOptionsMixin + +```jsonnet +RegexMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withType + +```jsonnet +RegexMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RegexMap.options + + +##### fn RegexMap.options.withPattern + +```jsonnet +RegexMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn RegexMap.options.withResult + +```jsonnet +RegexMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RegexMap.options.withResultMixin + +```jsonnet +RegexMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj RegexMap.options.result + + +###### fn RegexMap.options.result.withColor + +```jsonnet +RegexMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIcon + +```jsonnet +RegexMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIndex + +```jsonnet +RegexMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RegexMap.options.result.withText + +```jsonnet +RegexMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj SpecialValueMap + + +#### fn SpecialValueMap.withOptions + +```jsonnet +SpecialValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withOptionsMixin + +```jsonnet +SpecialValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withType + +```jsonnet +SpecialValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj SpecialValueMap.options + + +##### fn SpecialValueMap.options.withMatch + +```jsonnet +SpecialValueMap.options.withMatch(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"true"`, `"false"` + + +##### fn SpecialValueMap.options.withPattern + +```jsonnet +SpecialValueMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn SpecialValueMap.options.withResult + +```jsonnet +SpecialValueMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn SpecialValueMap.options.withResultMixin + +```jsonnet +SpecialValueMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj SpecialValueMap.options.result + + +###### fn SpecialValueMap.options.result.withColor + +```jsonnet +SpecialValueMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIcon + +```jsonnet +SpecialValueMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIndex + +```jsonnet +SpecialValueMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn SpecialValueMap.options.result.withText + +```jsonnet +SpecialValueMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj ValueMap + + +#### fn ValueMap.withOptions + +```jsonnet +ValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withOptionsMixin + +```jsonnet +ValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withType + +```jsonnet +ValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/debug/standardOptions/override.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/debug/standardOptions/override.md new file mode 100644 index 0000000000..154f3dbdac --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/debug/standardOptions/override.md @@ -0,0 +1,244 @@ +# override + +Overrides allow you to customize visualization settings for specific fields or +series. This is accomplished by adding an override rule that targets +a particular set of fields and that can each define multiple options. + +```jsonnet +override.byType.new('number') ++ override.byType.withPropertiesFromOptions( + panel.standardOptions.withDecimals(2) + + panel.standardOptions.withUnit('s') +) +``` + + +## Index + +* [`obj byName`](#obj-byname) + * [`fn new(value)`](#fn-bynamenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bynamewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bynamewithproperty) +* [`obj byQuery`](#obj-byquery) + * [`fn new(value)`](#fn-byquerynew) + * [`fn withPropertiesFromOptions(options)`](#fn-byquerywithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byquerywithproperty) +* [`obj byRegexp`](#obj-byregexp) + * [`fn new(value)`](#fn-byregexpnew) + * [`fn withPropertiesFromOptions(options)`](#fn-byregexpwithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byregexpwithproperty) +* [`obj byType`](#obj-bytype) + * [`fn new(value)`](#fn-bytypenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bytypewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bytypewithproperty) +* [`obj byValue`](#obj-byvalue) + * [`fn new(value)`](#fn-byvaluenew) + * [`fn withPropertiesFromOptions(options)`](#fn-byvaluewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byvaluewithproperty) + +## Fields + +### obj byName + + +#### fn byName.new + +```jsonnet +byName.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byName`. +#### fn byName.withPropertiesFromOptions + +```jsonnet +byName.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byName.withProperty + +```jsonnet +byName.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byQuery + + +#### fn byQuery.new + +```jsonnet +byQuery.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byQuery`. +#### fn byQuery.withPropertiesFromOptions + +```jsonnet +byQuery.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byQuery.withProperty + +```jsonnet +byQuery.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byRegexp + + +#### fn byRegexp.new + +```jsonnet +byRegexp.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byRegexp`. +#### fn byRegexp.withPropertiesFromOptions + +```jsonnet +byRegexp.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byRegexp.withProperty + +```jsonnet +byRegexp.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byType + + +#### fn byType.new + +```jsonnet +byType.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byType`. +#### fn byType.withPropertiesFromOptions + +```jsonnet +byType.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byType.withProperty + +```jsonnet +byType.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byValue + + +#### fn byValue.new + +```jsonnet +byValue.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byValue`. +#### fn byValue.withPropertiesFromOptions + +```jsonnet +byValue.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byValue.withProperty + +```jsonnet +byValue.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/debug/standardOptions/threshold/step.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/debug/standardOptions/threshold/step.md new file mode 100644 index 0000000000..dd2dd227ff --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/debug/standardOptions/threshold/step.md @@ -0,0 +1,60 @@ +# threshold.step + + + +## Index + +* [`fn withColor(value)`](#fn-withcolor) +* [`fn withIndex(value)`](#fn-withindex) +* [`fn withState(value)`](#fn-withstate) +* [`fn withValue(value)`](#fn-withvalue) + +## Fields + +### fn withColor + +```jsonnet +withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +### fn withIndex + +```jsonnet +withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Threshold index, an old property that is not needed an should only appear in older dashboards +### fn withState + +```jsonnet +withState(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO are the values here enumerable into a disjunction? +Some seem to be listed in typescript comment +### fn withValue + +```jsonnet +withValue(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +FIXME the corresponding typescript field is required/non-optional, but nulls currently appear here when serializing -Infinity to JSON \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/gauge/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/gauge/index.md new file mode 100644 index 0000000000..b766519f7a --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/gauge/index.md @@ -0,0 +1,748 @@ +# gauge + +grafonnet.panel.gauge + +## Subpackages + +* [panelOptions.link](panelOptions/link.md) +* [queryOptions.transformation](queryOptions/transformation.md) +* [standardOptions.mapping](standardOptions/mapping.md) +* [standardOptions.override](standardOptions/override.md) +* [standardOptions.threshold.step](standardOptions/threshold/step.md) + +## Index + +* [`fn new(title)`](#fn-new) +* [`obj libraryPanel`](#obj-librarypanel) + * [`fn withName(value)`](#fn-librarypanelwithname) + * [`fn withUid(value)`](#fn-librarypanelwithuid) +* [`obj options`](#obj-options) + * [`fn withOrientation(value)`](#fn-optionswithorientation) + * [`fn withReduceOptions(value)`](#fn-optionswithreduceoptions) + * [`fn withReduceOptionsMixin(value)`](#fn-optionswithreduceoptionsmixin) + * [`fn withShowThresholdLabels(value=true)`](#fn-optionswithshowthresholdlabels) + * [`fn withShowThresholdMarkers(value=true)`](#fn-optionswithshowthresholdmarkers) + * [`fn withText(value)`](#fn-optionswithtext) + * [`fn withTextMixin(value)`](#fn-optionswithtextmixin) + * [`obj reduceOptions`](#obj-optionsreduceoptions) + * [`fn withCalcs(value)`](#fn-optionsreduceoptionswithcalcs) + * [`fn withCalcsMixin(value)`](#fn-optionsreduceoptionswithcalcsmixin) + * [`fn withFields(value)`](#fn-optionsreduceoptionswithfields) + * [`fn withLimit(value)`](#fn-optionsreduceoptionswithlimit) + * [`fn withValues(value=true)`](#fn-optionsreduceoptionswithvalues) + * [`obj text`](#obj-optionstext) + * [`fn withTitleSize(value)`](#fn-optionstextwithtitlesize) + * [`fn withValueSize(value)`](#fn-optionstextwithvaluesize) +* [`obj panelOptions`](#obj-paneloptions) + * [`fn withDescription(value)`](#fn-paneloptionswithdescription) + * [`fn withGridPos(h="null", w="null", x="null", y="null")`](#fn-paneloptionswithgridpos) + * [`fn withLinks(value)`](#fn-paneloptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-paneloptionswithlinksmixin) + * [`fn withRepeat(value)`](#fn-paneloptionswithrepeat) + * [`fn withRepeatDirection(value="h")`](#fn-paneloptionswithrepeatdirection) + * [`fn withTitle(value)`](#fn-paneloptionswithtitle) + * [`fn withTransparent(value=true)`](#fn-paneloptionswithtransparent) +* [`obj queryOptions`](#obj-queryoptions) + * [`fn withDatasource(type, uid)`](#fn-queryoptionswithdatasource) + * [`fn withDatasourceMixin(value)`](#fn-queryoptionswithdatasourcemixin) + * [`fn withInterval(value)`](#fn-queryoptionswithinterval) + * [`fn withMaxDataPoints(value)`](#fn-queryoptionswithmaxdatapoints) + * [`fn withTargets(value)`](#fn-queryoptionswithtargets) + * [`fn withTargetsMixin(value)`](#fn-queryoptionswithtargetsmixin) + * [`fn withTimeFrom(value)`](#fn-queryoptionswithtimefrom) + * [`fn withTimeShift(value)`](#fn-queryoptionswithtimeshift) + * [`fn withTransformations(value)`](#fn-queryoptionswithtransformations) + * [`fn withTransformationsMixin(value)`](#fn-queryoptionswithtransformationsmixin) +* [`obj standardOptions`](#obj-standardoptions) + * [`fn withDecimals(value)`](#fn-standardoptionswithdecimals) + * [`fn withDisplayName(value)`](#fn-standardoptionswithdisplayname) + * [`fn withFilterable(value=true)`](#fn-standardoptionswithfilterable) + * [`fn withLinks(value)`](#fn-standardoptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-standardoptionswithlinksmixin) + * [`fn withMappings(value)`](#fn-standardoptionswithmappings) + * [`fn withMappingsMixin(value)`](#fn-standardoptionswithmappingsmixin) + * [`fn withMax(value)`](#fn-standardoptionswithmax) + * [`fn withMin(value)`](#fn-standardoptionswithmin) + * [`fn withNoValue(value)`](#fn-standardoptionswithnovalue) + * [`fn withOverrides(value)`](#fn-standardoptionswithoverrides) + * [`fn withOverridesMixin(value)`](#fn-standardoptionswithoverridesmixin) + * [`fn withPath(value)`](#fn-standardoptionswithpath) + * [`fn withUnit(value)`](#fn-standardoptionswithunit) + * [`obj color`](#obj-standardoptionscolor) + * [`fn withFixedColor(value)`](#fn-standardoptionscolorwithfixedcolor) + * [`fn withMode(value)`](#fn-standardoptionscolorwithmode) + * [`fn withSeriesBy(value)`](#fn-standardoptionscolorwithseriesby) + * [`obj thresholds`](#obj-standardoptionsthresholds) + * [`fn withMode(value)`](#fn-standardoptionsthresholdswithmode) + * [`fn withSteps(value)`](#fn-standardoptionsthresholdswithsteps) + * [`fn withStepsMixin(value)`](#fn-standardoptionsthresholdswithstepsmixin) + +## Fields + +### fn new + +```jsonnet +new(title) +``` + +PARAMETERS: + +* **title** (`string`) + +Creates a new gauge panel with a title. +### obj libraryPanel + + +#### fn libraryPanel.withName + +```jsonnet +libraryPanel.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn libraryPanel.withUid + +```jsonnet +libraryPanel.withUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj options + + +#### fn options.withOrientation + +```jsonnet +options.withOrientation(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"auto"`, `"vertical"`, `"horizontal"` + +TODO docs +#### fn options.withReduceOptions + +```jsonnet +options.withReduceOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withReduceOptionsMixin + +```jsonnet +options.withReduceOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withShowThresholdLabels + +```jsonnet +options.withShowThresholdLabels(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +#### fn options.withShowThresholdMarkers + +```jsonnet +options.withShowThresholdMarkers(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +#### fn options.withText + +```jsonnet +options.withText(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withTextMixin + +```jsonnet +options.withTextMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### obj options.reduceOptions + + +##### fn options.reduceOptions.withCalcs + +```jsonnet +options.reduceOptions.withCalcs(value) +``` + +PARAMETERS: + +* **value** (`array`) + +When !values, pick one value for the whole field +##### fn options.reduceOptions.withCalcsMixin + +```jsonnet +options.reduceOptions.withCalcsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +When !values, pick one value for the whole field +##### fn options.reduceOptions.withFields + +```jsonnet +options.reduceOptions.withFields(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Which fields to show. By default this is only numeric fields +##### fn options.reduceOptions.withLimit + +```jsonnet +options.reduceOptions.withLimit(value) +``` + +PARAMETERS: + +* **value** (`number`) + +if showing all values limit +##### fn options.reduceOptions.withValues + +```jsonnet +options.reduceOptions.withValues(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +If true show each row value +#### obj options.text + + +##### fn options.text.withTitleSize + +```jsonnet +options.text.withTitleSize(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Explicit title text size +##### fn options.text.withValueSize + +```jsonnet +options.text.withValueSize(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Explicit value text size +### obj panelOptions + + +#### fn panelOptions.withDescription + +```jsonnet +panelOptions.withDescription(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Description. +#### fn panelOptions.withGridPos + +```jsonnet +panelOptions.withGridPos(h="null", w="null", x="null", y="null") +``` + +PARAMETERS: + +* **h** (`number`) + - default value: `"null"` +* **w** (`number`) + - default value: `"null"` +* **x** (`number`) + - default value: `"null"` +* **y** (`number`) + - default value: `"null"` + +`withGridPos` configures the height, width and xy coordinates of the panel. Also see `grafonnet.util.grid` for helper functions to calculate these fields. + +All arguments default to `null`, which means they will remain unchanged or unset. + +#### fn panelOptions.withLinks + +```jsonnet +panelOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withLinksMixin + +```jsonnet +panelOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withRepeat + +```jsonnet +panelOptions.withRepeat(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of template variable to repeat for. +#### fn panelOptions.withRepeatDirection + +```jsonnet +panelOptions.withRepeatDirection(value="h") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"h"` + - valid values: `"h"`, `"v"` + +Direction to repeat in if 'repeat' is set. +"h" for horizontal, "v" for vertical. +TODO this is probably optional +#### fn panelOptions.withTitle + +```jsonnet +panelOptions.withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Panel title. +#### fn panelOptions.withTransparent + +```jsonnet +panelOptions.withTransparent(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Whether to display the panel without a background. +### obj queryOptions + + +#### fn queryOptions.withDatasource + +```jsonnet +queryOptions.withDatasource(type, uid) +``` + +PARAMETERS: + +* **type** (`string`) +* **uid** (`string`) + +`withDatasource` sets the datasource for all queries in a panel. + +The default datasource for a panel is set to 'Mixed datasource' so panels can be datasource agnostic, which is a lot more interesting from a reusability standpoint. Note that this requires query targets to explicitly set datasource for the same reason. + +#### fn queryOptions.withDatasourceMixin + +```jsonnet +queryOptions.withDatasourceMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +The datasource used in all targets. +#### fn queryOptions.withInterval + +```jsonnet +queryOptions.withInterval(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withMaxDataPoints + +```jsonnet +queryOptions.withMaxDataPoints(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +#### fn queryOptions.withTargets + +```jsonnet +queryOptions.withTargets(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTargetsMixin + +```jsonnet +queryOptions.withTargetsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTimeFrom + +```jsonnet +queryOptions.withTimeFrom(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTimeShift + +```jsonnet +queryOptions.withTimeShift(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTransformations + +```jsonnet +queryOptions.withTransformations(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn queryOptions.withTransformationsMixin + +```jsonnet +queryOptions.withTransformationsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### obj standardOptions + + +#### fn standardOptions.withDecimals + +```jsonnet +standardOptions.withDecimals(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Significant digits (for display) +#### fn standardOptions.withDisplayName + +```jsonnet +standardOptions.withDisplayName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The display value for this field. This supports template variables blank is auto +#### fn standardOptions.withFilterable + +```jsonnet +standardOptions.withFilterable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +True if data source field supports ad-hoc filters +#### fn standardOptions.withLinks + +```jsonnet +standardOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withLinksMixin + +```jsonnet +standardOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withMappings + +```jsonnet +standardOptions.withMappings(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMappingsMixin + +```jsonnet +standardOptions.withMappingsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMax + +```jsonnet +standardOptions.withMax(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withMin + +```jsonnet +standardOptions.withMin(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withNoValue + +```jsonnet +standardOptions.withNoValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Alternative to empty string +#### fn standardOptions.withOverrides + +```jsonnet +standardOptions.withOverrides(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withOverridesMixin + +```jsonnet +standardOptions.withOverridesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withPath + +```jsonnet +standardOptions.withPath(value) +``` + +PARAMETERS: + +* **value** (`string`) + +An explicit path to the field in the datasource. When the frame meta includes a path, +This will default to `${frame.meta.path}/${field.name} + +When defined, this value can be used as an identifier within the datasource scope, and +may be used to update the results +#### fn standardOptions.withUnit + +```jsonnet +standardOptions.withUnit(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Numeric Options +#### obj standardOptions.color + + +##### fn standardOptions.color.withFixedColor + +```jsonnet +standardOptions.color.withFixedColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Stores the fixed color value if mode is fixed +##### fn standardOptions.color.withMode + +```jsonnet +standardOptions.color.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The main color scheme mode +##### fn standardOptions.color.withSeriesBy + +```jsonnet +standardOptions.color.withSeriesBy(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"min"`, `"max"`, `"last"` + +TODO docs +#### obj standardOptions.thresholds + + +##### fn standardOptions.thresholds.withMode + +```jsonnet +standardOptions.thresholds.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"absolute"`, `"percentage"` + + +##### fn standardOptions.thresholds.withSteps + +```jsonnet +standardOptions.thresholds.withSteps(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity +##### fn standardOptions.thresholds.withStepsMixin + +```jsonnet +standardOptions.thresholds.withStepsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/gauge/panelOptions/link.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/gauge/panelOptions/link.md new file mode 100644 index 0000000000..106f9d2edb --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/gauge/panelOptions/link.md @@ -0,0 +1,145 @@ +# link + + + +## Index + +* [`fn withAsDropdown(value=true)`](#fn-withasdropdown) +* [`fn withIcon(value)`](#fn-withicon) +* [`fn withIncludeVars(value=true)`](#fn-withincludevars) +* [`fn withKeepTime(value=true)`](#fn-withkeeptime) +* [`fn withTags(value)`](#fn-withtags) +* [`fn withTagsMixin(value)`](#fn-withtagsmixin) +* [`fn withTargetBlank(value=true)`](#fn-withtargetblank) +* [`fn withTitle(value)`](#fn-withtitle) +* [`fn withTooltip(value)`](#fn-withtooltip) +* [`fn withType(value)`](#fn-withtype) +* [`fn withUrl(value)`](#fn-withurl) + +## Fields + +### fn withAsDropdown + +```jsonnet +withAsDropdown(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withIcon + +```jsonnet +withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withIncludeVars + +```jsonnet +withIncludeVars(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withKeepTime + +```jsonnet +withKeepTime(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTags + +```jsonnet +withTags(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTagsMixin + +```jsonnet +withTagsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTargetBlank + +```jsonnet +withTargetBlank(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTitle + +```jsonnet +withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withTooltip + +```jsonnet +withTooltip(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withType + +```jsonnet +withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"link"`, `"dashboards"` + +TODO docs +### fn withUrl + +```jsonnet +withUrl(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/gauge/queryOptions/transformation.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/gauge/queryOptions/transformation.md new file mode 100644 index 0000000000..dc832f653d --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/gauge/queryOptions/transformation.md @@ -0,0 +1,99 @@ +# transformation + + + +## Index + +* [`fn withDisabled(value=true)`](#fn-withdisabled) +* [`fn withFilter(value)`](#fn-withfilter) +* [`fn withFilterMixin(value)`](#fn-withfiltermixin) +* [`fn withId(value)`](#fn-withid) +* [`fn withOptions(value)`](#fn-withoptions) +* [`obj filter`](#obj-filter) + * [`fn withId(value="")`](#fn-filterwithid) + * [`fn withOptions(value)`](#fn-filterwithoptions) + +## Fields + +### fn withDisabled + +```jsonnet +withDisabled(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Disabled transformations are skipped +### fn withFilter + +```jsonnet +withFilter(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withFilterMixin + +```jsonnet +withFilterMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withId + +```jsonnet +withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Unique identifier of transformer +### fn withOptions + +```jsonnet +withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Options to be passed to the transformer +Valid options depend on the transformer id +### obj filter + + +#### fn filter.withId + +```jsonnet +filter.withId(value="") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `""` + + +#### fn filter.withOptions + +```jsonnet +filter.withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/gauge/standardOptions/mapping.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/gauge/standardOptions/mapping.md new file mode 100644 index 0000000000..93296972e8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/gauge/standardOptions/mapping.md @@ -0,0 +1,469 @@ +# mapping + + + +## Index + +* [`obj RangeMap`](#obj-rangemap) + * [`fn withOptions(value)`](#fn-rangemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-rangemapwithoptionsmixin) + * [`fn withType(value)`](#fn-rangemapwithtype) + * [`obj options`](#obj-rangemapoptions) + * [`fn withFrom(value)`](#fn-rangemapoptionswithfrom) + * [`fn withResult(value)`](#fn-rangemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-rangemapoptionswithresultmixin) + * [`fn withTo(value)`](#fn-rangemapoptionswithto) + * [`obj result`](#obj-rangemapoptionsresult) + * [`fn withColor(value)`](#fn-rangemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-rangemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-rangemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-rangemapoptionsresultwithtext) +* [`obj RegexMap`](#obj-regexmap) + * [`fn withOptions(value)`](#fn-regexmapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-regexmapwithoptionsmixin) + * [`fn withType(value)`](#fn-regexmapwithtype) + * [`obj options`](#obj-regexmapoptions) + * [`fn withPattern(value)`](#fn-regexmapoptionswithpattern) + * [`fn withResult(value)`](#fn-regexmapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-regexmapoptionswithresultmixin) + * [`obj result`](#obj-regexmapoptionsresult) + * [`fn withColor(value)`](#fn-regexmapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-regexmapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-regexmapoptionsresultwithindex) + * [`fn withText(value)`](#fn-regexmapoptionsresultwithtext) +* [`obj SpecialValueMap`](#obj-specialvaluemap) + * [`fn withOptions(value)`](#fn-specialvaluemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-specialvaluemapwithoptionsmixin) + * [`fn withType(value)`](#fn-specialvaluemapwithtype) + * [`obj options`](#obj-specialvaluemapoptions) + * [`fn withMatch(value)`](#fn-specialvaluemapoptionswithmatch) + * [`fn withPattern(value)`](#fn-specialvaluemapoptionswithpattern) + * [`fn withResult(value)`](#fn-specialvaluemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-specialvaluemapoptionswithresultmixin) + * [`obj result`](#obj-specialvaluemapoptionsresult) + * [`fn withColor(value)`](#fn-specialvaluemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-specialvaluemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-specialvaluemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-specialvaluemapoptionsresultwithtext) +* [`obj ValueMap`](#obj-valuemap) + * [`fn withOptions(value)`](#fn-valuemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-valuemapwithoptionsmixin) + * [`fn withType(value)`](#fn-valuemapwithtype) + +## Fields + +### obj RangeMap + + +#### fn RangeMap.withOptions + +```jsonnet +RangeMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withOptionsMixin + +```jsonnet +RangeMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withType + +```jsonnet +RangeMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RangeMap.options + + +##### fn RangeMap.options.withFrom + +```jsonnet +RangeMap.options.withFrom(value) +``` + +PARAMETERS: + +* **value** (`number`) + +to and from are `number | null` in current ts, really not sure what to do +##### fn RangeMap.options.withResult + +```jsonnet +RangeMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withResultMixin + +```jsonnet +RangeMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withTo + +```jsonnet +RangeMap.options.withTo(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +##### obj RangeMap.options.result + + +###### fn RangeMap.options.result.withColor + +```jsonnet +RangeMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIcon + +```jsonnet +RangeMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIndex + +```jsonnet +RangeMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RangeMap.options.result.withText + +```jsonnet +RangeMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj RegexMap + + +#### fn RegexMap.withOptions + +```jsonnet +RegexMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withOptionsMixin + +```jsonnet +RegexMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withType + +```jsonnet +RegexMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RegexMap.options + + +##### fn RegexMap.options.withPattern + +```jsonnet +RegexMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn RegexMap.options.withResult + +```jsonnet +RegexMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RegexMap.options.withResultMixin + +```jsonnet +RegexMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj RegexMap.options.result + + +###### fn RegexMap.options.result.withColor + +```jsonnet +RegexMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIcon + +```jsonnet +RegexMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIndex + +```jsonnet +RegexMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RegexMap.options.result.withText + +```jsonnet +RegexMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj SpecialValueMap + + +#### fn SpecialValueMap.withOptions + +```jsonnet +SpecialValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withOptionsMixin + +```jsonnet +SpecialValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withType + +```jsonnet +SpecialValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj SpecialValueMap.options + + +##### fn SpecialValueMap.options.withMatch + +```jsonnet +SpecialValueMap.options.withMatch(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"true"`, `"false"` + + +##### fn SpecialValueMap.options.withPattern + +```jsonnet +SpecialValueMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn SpecialValueMap.options.withResult + +```jsonnet +SpecialValueMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn SpecialValueMap.options.withResultMixin + +```jsonnet +SpecialValueMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj SpecialValueMap.options.result + + +###### fn SpecialValueMap.options.result.withColor + +```jsonnet +SpecialValueMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIcon + +```jsonnet +SpecialValueMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIndex + +```jsonnet +SpecialValueMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn SpecialValueMap.options.result.withText + +```jsonnet +SpecialValueMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj ValueMap + + +#### fn ValueMap.withOptions + +```jsonnet +ValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withOptionsMixin + +```jsonnet +ValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withType + +```jsonnet +ValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/gauge/standardOptions/override.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/gauge/standardOptions/override.md new file mode 100644 index 0000000000..154f3dbdac --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/gauge/standardOptions/override.md @@ -0,0 +1,244 @@ +# override + +Overrides allow you to customize visualization settings for specific fields or +series. This is accomplished by adding an override rule that targets +a particular set of fields and that can each define multiple options. + +```jsonnet +override.byType.new('number') ++ override.byType.withPropertiesFromOptions( + panel.standardOptions.withDecimals(2) + + panel.standardOptions.withUnit('s') +) +``` + + +## Index + +* [`obj byName`](#obj-byname) + * [`fn new(value)`](#fn-bynamenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bynamewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bynamewithproperty) +* [`obj byQuery`](#obj-byquery) + * [`fn new(value)`](#fn-byquerynew) + * [`fn withPropertiesFromOptions(options)`](#fn-byquerywithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byquerywithproperty) +* [`obj byRegexp`](#obj-byregexp) + * [`fn new(value)`](#fn-byregexpnew) + * [`fn withPropertiesFromOptions(options)`](#fn-byregexpwithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byregexpwithproperty) +* [`obj byType`](#obj-bytype) + * [`fn new(value)`](#fn-bytypenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bytypewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bytypewithproperty) +* [`obj byValue`](#obj-byvalue) + * [`fn new(value)`](#fn-byvaluenew) + * [`fn withPropertiesFromOptions(options)`](#fn-byvaluewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byvaluewithproperty) + +## Fields + +### obj byName + + +#### fn byName.new + +```jsonnet +byName.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byName`. +#### fn byName.withPropertiesFromOptions + +```jsonnet +byName.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byName.withProperty + +```jsonnet +byName.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byQuery + + +#### fn byQuery.new + +```jsonnet +byQuery.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byQuery`. +#### fn byQuery.withPropertiesFromOptions + +```jsonnet +byQuery.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byQuery.withProperty + +```jsonnet +byQuery.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byRegexp + + +#### fn byRegexp.new + +```jsonnet +byRegexp.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byRegexp`. +#### fn byRegexp.withPropertiesFromOptions + +```jsonnet +byRegexp.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byRegexp.withProperty + +```jsonnet +byRegexp.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byType + + +#### fn byType.new + +```jsonnet +byType.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byType`. +#### fn byType.withPropertiesFromOptions + +```jsonnet +byType.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byType.withProperty + +```jsonnet +byType.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byValue + + +#### fn byValue.new + +```jsonnet +byValue.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byValue`. +#### fn byValue.withPropertiesFromOptions + +```jsonnet +byValue.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byValue.withProperty + +```jsonnet +byValue.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/gauge/standardOptions/threshold/step.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/gauge/standardOptions/threshold/step.md new file mode 100644 index 0000000000..dd2dd227ff --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/gauge/standardOptions/threshold/step.md @@ -0,0 +1,60 @@ +# threshold.step + + + +## Index + +* [`fn withColor(value)`](#fn-withcolor) +* [`fn withIndex(value)`](#fn-withindex) +* [`fn withState(value)`](#fn-withstate) +* [`fn withValue(value)`](#fn-withvalue) + +## Fields + +### fn withColor + +```jsonnet +withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +### fn withIndex + +```jsonnet +withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Threshold index, an old property that is not needed an should only appear in older dashboards +### fn withState + +```jsonnet +withState(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO are the values here enumerable into a disjunction? +Some seem to be listed in typescript comment +### fn withValue + +```jsonnet +withValue(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +FIXME the corresponding typescript field is required/non-optional, but nulls currently appear here when serializing -Infinity to JSON \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/geomap/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/geomap/index.md new file mode 100644 index 0000000000..39c74bd8f8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/geomap/index.md @@ -0,0 +1,1123 @@ +# geomap + +grafonnet.panel.geomap + +## Subpackages + +* [options.layers](options/layers.md) +* [panelOptions.link](panelOptions/link.md) +* [queryOptions.transformation](queryOptions/transformation.md) +* [standardOptions.mapping](standardOptions/mapping.md) +* [standardOptions.override](standardOptions/override.md) +* [standardOptions.threshold.step](standardOptions/threshold/step.md) + +## Index + +* [`fn new(title)`](#fn-new) +* [`obj libraryPanel`](#obj-librarypanel) + * [`fn withName(value)`](#fn-librarypanelwithname) + * [`fn withUid(value)`](#fn-librarypanelwithuid) +* [`obj options`](#obj-options) + * [`fn withBasemap(value)`](#fn-optionswithbasemap) + * [`fn withBasemapMixin(value)`](#fn-optionswithbasemapmixin) + * [`fn withControls(value)`](#fn-optionswithcontrols) + * [`fn withControlsMixin(value)`](#fn-optionswithcontrolsmixin) + * [`fn withLayers(value)`](#fn-optionswithlayers) + * [`fn withLayersMixin(value)`](#fn-optionswithlayersmixin) + * [`fn withTooltip(value)`](#fn-optionswithtooltip) + * [`fn withTooltipMixin(value)`](#fn-optionswithtooltipmixin) + * [`fn withView(value)`](#fn-optionswithview) + * [`fn withViewMixin(value)`](#fn-optionswithviewmixin) + * [`obj basemap`](#obj-optionsbasemap) + * [`fn withConfig(value)`](#fn-optionsbasemapwithconfig) + * [`fn withFilterData(value)`](#fn-optionsbasemapwithfilterdata) + * [`fn withLocation(value)`](#fn-optionsbasemapwithlocation) + * [`fn withLocationMixin(value)`](#fn-optionsbasemapwithlocationmixin) + * [`fn withName(value)`](#fn-optionsbasemapwithname) + * [`fn withOpacity(value)`](#fn-optionsbasemapwithopacity) + * [`fn withTooltip(value=true)`](#fn-optionsbasemapwithtooltip) + * [`fn withType(value)`](#fn-optionsbasemapwithtype) + * [`obj location`](#obj-optionsbasemaplocation) + * [`fn withGazetteer(value)`](#fn-optionsbasemaplocationwithgazetteer) + * [`fn withGeohash(value)`](#fn-optionsbasemaplocationwithgeohash) + * [`fn withLatitude(value)`](#fn-optionsbasemaplocationwithlatitude) + * [`fn withLongitude(value)`](#fn-optionsbasemaplocationwithlongitude) + * [`fn withLookup(value)`](#fn-optionsbasemaplocationwithlookup) + * [`fn withMode(value)`](#fn-optionsbasemaplocationwithmode) + * [`fn withWkt(value)`](#fn-optionsbasemaplocationwithwkt) + * [`obj controls`](#obj-optionscontrols) + * [`fn withMouseWheelZoom(value=true)`](#fn-optionscontrolswithmousewheelzoom) + * [`fn withShowAttribution(value=true)`](#fn-optionscontrolswithshowattribution) + * [`fn withShowDebug(value=true)`](#fn-optionscontrolswithshowdebug) + * [`fn withShowMeasure(value=true)`](#fn-optionscontrolswithshowmeasure) + * [`fn withShowScale(value=true)`](#fn-optionscontrolswithshowscale) + * [`fn withShowZoom(value=true)`](#fn-optionscontrolswithshowzoom) + * [`obj tooltip`](#obj-optionstooltip) + * [`fn withMode(value)`](#fn-optionstooltipwithmode) + * [`obj view`](#obj-optionsview) + * [`fn withAllLayers(value=true)`](#fn-optionsviewwithalllayers) + * [`fn withId(value="zero")`](#fn-optionsviewwithid) + * [`fn withLastOnly(value=true)`](#fn-optionsviewwithlastonly) + * [`fn withLat(value=0)`](#fn-optionsviewwithlat) + * [`fn withLayer(value)`](#fn-optionsviewwithlayer) + * [`fn withLon(value=0)`](#fn-optionsviewwithlon) + * [`fn withMaxZoom(value)`](#fn-optionsviewwithmaxzoom) + * [`fn withMinZoom(value)`](#fn-optionsviewwithminzoom) + * [`fn withPadding(value)`](#fn-optionsviewwithpadding) + * [`fn withShared(value=true)`](#fn-optionsviewwithshared) + * [`fn withZoom(value=1)`](#fn-optionsviewwithzoom) +* [`obj panelOptions`](#obj-paneloptions) + * [`fn withDescription(value)`](#fn-paneloptionswithdescription) + * [`fn withGridPos(h="null", w="null", x="null", y="null")`](#fn-paneloptionswithgridpos) + * [`fn withLinks(value)`](#fn-paneloptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-paneloptionswithlinksmixin) + * [`fn withRepeat(value)`](#fn-paneloptionswithrepeat) + * [`fn withRepeatDirection(value="h")`](#fn-paneloptionswithrepeatdirection) + * [`fn withTitle(value)`](#fn-paneloptionswithtitle) + * [`fn withTransparent(value=true)`](#fn-paneloptionswithtransparent) +* [`obj queryOptions`](#obj-queryoptions) + * [`fn withDatasource(type, uid)`](#fn-queryoptionswithdatasource) + * [`fn withDatasourceMixin(value)`](#fn-queryoptionswithdatasourcemixin) + * [`fn withInterval(value)`](#fn-queryoptionswithinterval) + * [`fn withMaxDataPoints(value)`](#fn-queryoptionswithmaxdatapoints) + * [`fn withTargets(value)`](#fn-queryoptionswithtargets) + * [`fn withTargetsMixin(value)`](#fn-queryoptionswithtargetsmixin) + * [`fn withTimeFrom(value)`](#fn-queryoptionswithtimefrom) + * [`fn withTimeShift(value)`](#fn-queryoptionswithtimeshift) + * [`fn withTransformations(value)`](#fn-queryoptionswithtransformations) + * [`fn withTransformationsMixin(value)`](#fn-queryoptionswithtransformationsmixin) +* [`obj standardOptions`](#obj-standardoptions) + * [`fn withDecimals(value)`](#fn-standardoptionswithdecimals) + * [`fn withDisplayName(value)`](#fn-standardoptionswithdisplayname) + * [`fn withFilterable(value=true)`](#fn-standardoptionswithfilterable) + * [`fn withLinks(value)`](#fn-standardoptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-standardoptionswithlinksmixin) + * [`fn withMappings(value)`](#fn-standardoptionswithmappings) + * [`fn withMappingsMixin(value)`](#fn-standardoptionswithmappingsmixin) + * [`fn withMax(value)`](#fn-standardoptionswithmax) + * [`fn withMin(value)`](#fn-standardoptionswithmin) + * [`fn withNoValue(value)`](#fn-standardoptionswithnovalue) + * [`fn withOverrides(value)`](#fn-standardoptionswithoverrides) + * [`fn withOverridesMixin(value)`](#fn-standardoptionswithoverridesmixin) + * [`fn withPath(value)`](#fn-standardoptionswithpath) + * [`fn withUnit(value)`](#fn-standardoptionswithunit) + * [`obj color`](#obj-standardoptionscolor) + * [`fn withFixedColor(value)`](#fn-standardoptionscolorwithfixedcolor) + * [`fn withMode(value)`](#fn-standardoptionscolorwithmode) + * [`fn withSeriesBy(value)`](#fn-standardoptionscolorwithseriesby) + * [`obj thresholds`](#obj-standardoptionsthresholds) + * [`fn withMode(value)`](#fn-standardoptionsthresholdswithmode) + * [`fn withSteps(value)`](#fn-standardoptionsthresholdswithsteps) + * [`fn withStepsMixin(value)`](#fn-standardoptionsthresholdswithstepsmixin) + +## Fields + +### fn new + +```jsonnet +new(title) +``` + +PARAMETERS: + +* **title** (`string`) + +Creates a new geomap panel with a title. +### obj libraryPanel + + +#### fn libraryPanel.withName + +```jsonnet +libraryPanel.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn libraryPanel.withUid + +```jsonnet +libraryPanel.withUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj options + + +#### fn options.withBasemap + +```jsonnet +options.withBasemap(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn options.withBasemapMixin + +```jsonnet +options.withBasemapMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn options.withControls + +```jsonnet +options.withControls(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn options.withControlsMixin + +```jsonnet +options.withControlsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn options.withLayers + +```jsonnet +options.withLayers(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn options.withLayersMixin + +```jsonnet +options.withLayersMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn options.withTooltip + +```jsonnet +options.withTooltip(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn options.withTooltipMixin + +```jsonnet +options.withTooltipMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn options.withView + +```jsonnet +options.withView(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn options.withViewMixin + +```jsonnet +options.withViewMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### obj options.basemap + + +##### fn options.basemap.withConfig + +```jsonnet +options.basemap.withConfig(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Custom options depending on the type +##### fn options.basemap.withFilterData + +```jsonnet +options.basemap.withFilterData(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Defines a frame MatcherConfig that may filter data for the given layer +##### fn options.basemap.withLocation + +```jsonnet +options.basemap.withLocation(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn options.basemap.withLocationMixin + +```jsonnet +options.basemap.withLocationMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn options.basemap.withName + +```jsonnet +options.basemap.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +configured unique display name +##### fn options.basemap.withOpacity + +```jsonnet +options.basemap.withOpacity(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Common properties: +https://openlayers.org/en/latest/apidoc/module-ol_layer_Base-BaseLayer.html +Layer opacity (0-1) +##### fn options.basemap.withTooltip + +```jsonnet +options.basemap.withTooltip(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Check tooltip (defaults to true) +##### fn options.basemap.withType + +```jsonnet +options.basemap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### obj options.basemap.location + + +###### fn options.basemap.location.withGazetteer + +```jsonnet +options.basemap.location.withGazetteer(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Path to Gazetteer +###### fn options.basemap.location.withGeohash + +```jsonnet +options.basemap.location.withGeohash(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Field mappings +###### fn options.basemap.location.withLatitude + +```jsonnet +options.basemap.location.withLatitude(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn options.basemap.location.withLongitude + +```jsonnet +options.basemap.location.withLongitude(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn options.basemap.location.withLookup + +```jsonnet +options.basemap.location.withLookup(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn options.basemap.location.withMode + +```jsonnet +options.basemap.location.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"auto"`, `"geohash"`, `"coords"`, `"lookup"` + + +###### fn options.basemap.location.withWkt + +```jsonnet +options.basemap.location.withWkt(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj options.controls + + +##### fn options.controls.withMouseWheelZoom + +```jsonnet +options.controls.withMouseWheelZoom(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +let the mouse wheel zoom +##### fn options.controls.withShowAttribution + +```jsonnet +options.controls.withShowAttribution(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Lower right +##### fn options.controls.withShowDebug + +```jsonnet +options.controls.withShowDebug(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Show debug +##### fn options.controls.withShowMeasure + +```jsonnet +options.controls.withShowMeasure(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Show measure +##### fn options.controls.withShowScale + +```jsonnet +options.controls.withShowScale(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Scale options +##### fn options.controls.withShowZoom + +```jsonnet +options.controls.withShowZoom(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Zoom (upper left) +#### obj options.tooltip + + +##### fn options.tooltip.withMode + +```jsonnet +options.tooltip.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"none"`, `"details"` + + +#### obj options.view + + +##### fn options.view.withAllLayers + +```jsonnet +options.view.withAllLayers(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.view.withId + +```jsonnet +options.view.withId(value="zero") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"zero"` + + +##### fn options.view.withLastOnly + +```jsonnet +options.view.withLastOnly(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.view.withLat + +```jsonnet +options.view.withLat(value=0) +``` + +PARAMETERS: + +* **value** (`integer`) + - default value: `0` + + +##### fn options.view.withLayer + +```jsonnet +options.view.withLayer(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn options.view.withLon + +```jsonnet +options.view.withLon(value=0) +``` + +PARAMETERS: + +* **value** (`integer`) + - default value: `0` + + +##### fn options.view.withMaxZoom + +```jsonnet +options.view.withMaxZoom(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +##### fn options.view.withMinZoom + +```jsonnet +options.view.withMinZoom(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +##### fn options.view.withPadding + +```jsonnet +options.view.withPadding(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +##### fn options.view.withShared + +```jsonnet +options.view.withShared(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.view.withZoom + +```jsonnet +options.view.withZoom(value=1) +``` + +PARAMETERS: + +* **value** (`integer`) + - default value: `1` + + +### obj panelOptions + + +#### fn panelOptions.withDescription + +```jsonnet +panelOptions.withDescription(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Description. +#### fn panelOptions.withGridPos + +```jsonnet +panelOptions.withGridPos(h="null", w="null", x="null", y="null") +``` + +PARAMETERS: + +* **h** (`number`) + - default value: `"null"` +* **w** (`number`) + - default value: `"null"` +* **x** (`number`) + - default value: `"null"` +* **y** (`number`) + - default value: `"null"` + +`withGridPos` configures the height, width and xy coordinates of the panel. Also see `grafonnet.util.grid` for helper functions to calculate these fields. + +All arguments default to `null`, which means they will remain unchanged or unset. + +#### fn panelOptions.withLinks + +```jsonnet +panelOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withLinksMixin + +```jsonnet +panelOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withRepeat + +```jsonnet +panelOptions.withRepeat(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of template variable to repeat for. +#### fn panelOptions.withRepeatDirection + +```jsonnet +panelOptions.withRepeatDirection(value="h") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"h"` + - valid values: `"h"`, `"v"` + +Direction to repeat in if 'repeat' is set. +"h" for horizontal, "v" for vertical. +TODO this is probably optional +#### fn panelOptions.withTitle + +```jsonnet +panelOptions.withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Panel title. +#### fn panelOptions.withTransparent + +```jsonnet +panelOptions.withTransparent(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Whether to display the panel without a background. +### obj queryOptions + + +#### fn queryOptions.withDatasource + +```jsonnet +queryOptions.withDatasource(type, uid) +``` + +PARAMETERS: + +* **type** (`string`) +* **uid** (`string`) + +`withDatasource` sets the datasource for all queries in a panel. + +The default datasource for a panel is set to 'Mixed datasource' so panels can be datasource agnostic, which is a lot more interesting from a reusability standpoint. Note that this requires query targets to explicitly set datasource for the same reason. + +#### fn queryOptions.withDatasourceMixin + +```jsonnet +queryOptions.withDatasourceMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +The datasource used in all targets. +#### fn queryOptions.withInterval + +```jsonnet +queryOptions.withInterval(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withMaxDataPoints + +```jsonnet +queryOptions.withMaxDataPoints(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +#### fn queryOptions.withTargets + +```jsonnet +queryOptions.withTargets(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTargetsMixin + +```jsonnet +queryOptions.withTargetsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTimeFrom + +```jsonnet +queryOptions.withTimeFrom(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTimeShift + +```jsonnet +queryOptions.withTimeShift(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTransformations + +```jsonnet +queryOptions.withTransformations(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn queryOptions.withTransformationsMixin + +```jsonnet +queryOptions.withTransformationsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### obj standardOptions + + +#### fn standardOptions.withDecimals + +```jsonnet +standardOptions.withDecimals(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Significant digits (for display) +#### fn standardOptions.withDisplayName + +```jsonnet +standardOptions.withDisplayName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The display value for this field. This supports template variables blank is auto +#### fn standardOptions.withFilterable + +```jsonnet +standardOptions.withFilterable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +True if data source field supports ad-hoc filters +#### fn standardOptions.withLinks + +```jsonnet +standardOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withLinksMixin + +```jsonnet +standardOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withMappings + +```jsonnet +standardOptions.withMappings(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMappingsMixin + +```jsonnet +standardOptions.withMappingsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMax + +```jsonnet +standardOptions.withMax(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withMin + +```jsonnet +standardOptions.withMin(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withNoValue + +```jsonnet +standardOptions.withNoValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Alternative to empty string +#### fn standardOptions.withOverrides + +```jsonnet +standardOptions.withOverrides(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withOverridesMixin + +```jsonnet +standardOptions.withOverridesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withPath + +```jsonnet +standardOptions.withPath(value) +``` + +PARAMETERS: + +* **value** (`string`) + +An explicit path to the field in the datasource. When the frame meta includes a path, +This will default to `${frame.meta.path}/${field.name} + +When defined, this value can be used as an identifier within the datasource scope, and +may be used to update the results +#### fn standardOptions.withUnit + +```jsonnet +standardOptions.withUnit(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Numeric Options +#### obj standardOptions.color + + +##### fn standardOptions.color.withFixedColor + +```jsonnet +standardOptions.color.withFixedColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Stores the fixed color value if mode is fixed +##### fn standardOptions.color.withMode + +```jsonnet +standardOptions.color.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The main color scheme mode +##### fn standardOptions.color.withSeriesBy + +```jsonnet +standardOptions.color.withSeriesBy(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"min"`, `"max"`, `"last"` + +TODO docs +#### obj standardOptions.thresholds + + +##### fn standardOptions.thresholds.withMode + +```jsonnet +standardOptions.thresholds.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"absolute"`, `"percentage"` + + +##### fn standardOptions.thresholds.withSteps + +```jsonnet +standardOptions.thresholds.withSteps(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity +##### fn standardOptions.thresholds.withStepsMixin + +```jsonnet +standardOptions.thresholds.withStepsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/geomap/options/layers.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/geomap/options/layers.md new file mode 100644 index 0000000000..d65f7c6054 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/geomap/options/layers.md @@ -0,0 +1,196 @@ +# layers + + + +## Index + +* [`fn withConfig(value)`](#fn-withconfig) +* [`fn withFilterData(value)`](#fn-withfilterdata) +* [`fn withLocation(value)`](#fn-withlocation) +* [`fn withLocationMixin(value)`](#fn-withlocationmixin) +* [`fn withName(value)`](#fn-withname) +* [`fn withOpacity(value)`](#fn-withopacity) +* [`fn withTooltip(value=true)`](#fn-withtooltip) +* [`fn withType(value)`](#fn-withtype) +* [`obj location`](#obj-location) + * [`fn withGazetteer(value)`](#fn-locationwithgazetteer) + * [`fn withGeohash(value)`](#fn-locationwithgeohash) + * [`fn withLatitude(value)`](#fn-locationwithlatitude) + * [`fn withLongitude(value)`](#fn-locationwithlongitude) + * [`fn withLookup(value)`](#fn-locationwithlookup) + * [`fn withMode(value)`](#fn-locationwithmode) + * [`fn withWkt(value)`](#fn-locationwithwkt) + +## Fields + +### fn withConfig + +```jsonnet +withConfig(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Custom options depending on the type +### fn withFilterData + +```jsonnet +withFilterData(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Defines a frame MatcherConfig that may filter data for the given layer +### fn withLocation + +```jsonnet +withLocation(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withLocationMixin + +```jsonnet +withLocationMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withName + +```jsonnet +withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +configured unique display name +### fn withOpacity + +```jsonnet +withOpacity(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Common properties: +https://openlayers.org/en/latest/apidoc/module-ol_layer_Base-BaseLayer.html +Layer opacity (0-1) +### fn withTooltip + +```jsonnet +withTooltip(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Check tooltip (defaults to true) +### fn withType + +```jsonnet +withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj location + + +#### fn location.withGazetteer + +```jsonnet +location.withGazetteer(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Path to Gazetteer +#### fn location.withGeohash + +```jsonnet +location.withGeohash(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Field mappings +#### fn location.withLatitude + +```jsonnet +location.withLatitude(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn location.withLongitude + +```jsonnet +location.withLongitude(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn location.withLookup + +```jsonnet +location.withLookup(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn location.withMode + +```jsonnet +location.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"auto"`, `"geohash"`, `"coords"`, `"lookup"` + + +#### fn location.withWkt + +```jsonnet +location.withWkt(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/geomap/panelOptions/link.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/geomap/panelOptions/link.md new file mode 100644 index 0000000000..106f9d2edb --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/geomap/panelOptions/link.md @@ -0,0 +1,145 @@ +# link + + + +## Index + +* [`fn withAsDropdown(value=true)`](#fn-withasdropdown) +* [`fn withIcon(value)`](#fn-withicon) +* [`fn withIncludeVars(value=true)`](#fn-withincludevars) +* [`fn withKeepTime(value=true)`](#fn-withkeeptime) +* [`fn withTags(value)`](#fn-withtags) +* [`fn withTagsMixin(value)`](#fn-withtagsmixin) +* [`fn withTargetBlank(value=true)`](#fn-withtargetblank) +* [`fn withTitle(value)`](#fn-withtitle) +* [`fn withTooltip(value)`](#fn-withtooltip) +* [`fn withType(value)`](#fn-withtype) +* [`fn withUrl(value)`](#fn-withurl) + +## Fields + +### fn withAsDropdown + +```jsonnet +withAsDropdown(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withIcon + +```jsonnet +withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withIncludeVars + +```jsonnet +withIncludeVars(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withKeepTime + +```jsonnet +withKeepTime(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTags + +```jsonnet +withTags(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTagsMixin + +```jsonnet +withTagsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTargetBlank + +```jsonnet +withTargetBlank(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTitle + +```jsonnet +withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withTooltip + +```jsonnet +withTooltip(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withType + +```jsonnet +withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"link"`, `"dashboards"` + +TODO docs +### fn withUrl + +```jsonnet +withUrl(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/geomap/queryOptions/transformation.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/geomap/queryOptions/transformation.md new file mode 100644 index 0000000000..dc832f653d --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/geomap/queryOptions/transformation.md @@ -0,0 +1,99 @@ +# transformation + + + +## Index + +* [`fn withDisabled(value=true)`](#fn-withdisabled) +* [`fn withFilter(value)`](#fn-withfilter) +* [`fn withFilterMixin(value)`](#fn-withfiltermixin) +* [`fn withId(value)`](#fn-withid) +* [`fn withOptions(value)`](#fn-withoptions) +* [`obj filter`](#obj-filter) + * [`fn withId(value="")`](#fn-filterwithid) + * [`fn withOptions(value)`](#fn-filterwithoptions) + +## Fields + +### fn withDisabled + +```jsonnet +withDisabled(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Disabled transformations are skipped +### fn withFilter + +```jsonnet +withFilter(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withFilterMixin + +```jsonnet +withFilterMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withId + +```jsonnet +withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Unique identifier of transformer +### fn withOptions + +```jsonnet +withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Options to be passed to the transformer +Valid options depend on the transformer id +### obj filter + + +#### fn filter.withId + +```jsonnet +filter.withId(value="") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `""` + + +#### fn filter.withOptions + +```jsonnet +filter.withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/geomap/standardOptions/mapping.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/geomap/standardOptions/mapping.md new file mode 100644 index 0000000000..93296972e8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/geomap/standardOptions/mapping.md @@ -0,0 +1,469 @@ +# mapping + + + +## Index + +* [`obj RangeMap`](#obj-rangemap) + * [`fn withOptions(value)`](#fn-rangemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-rangemapwithoptionsmixin) + * [`fn withType(value)`](#fn-rangemapwithtype) + * [`obj options`](#obj-rangemapoptions) + * [`fn withFrom(value)`](#fn-rangemapoptionswithfrom) + * [`fn withResult(value)`](#fn-rangemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-rangemapoptionswithresultmixin) + * [`fn withTo(value)`](#fn-rangemapoptionswithto) + * [`obj result`](#obj-rangemapoptionsresult) + * [`fn withColor(value)`](#fn-rangemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-rangemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-rangemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-rangemapoptionsresultwithtext) +* [`obj RegexMap`](#obj-regexmap) + * [`fn withOptions(value)`](#fn-regexmapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-regexmapwithoptionsmixin) + * [`fn withType(value)`](#fn-regexmapwithtype) + * [`obj options`](#obj-regexmapoptions) + * [`fn withPattern(value)`](#fn-regexmapoptionswithpattern) + * [`fn withResult(value)`](#fn-regexmapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-regexmapoptionswithresultmixin) + * [`obj result`](#obj-regexmapoptionsresult) + * [`fn withColor(value)`](#fn-regexmapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-regexmapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-regexmapoptionsresultwithindex) + * [`fn withText(value)`](#fn-regexmapoptionsresultwithtext) +* [`obj SpecialValueMap`](#obj-specialvaluemap) + * [`fn withOptions(value)`](#fn-specialvaluemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-specialvaluemapwithoptionsmixin) + * [`fn withType(value)`](#fn-specialvaluemapwithtype) + * [`obj options`](#obj-specialvaluemapoptions) + * [`fn withMatch(value)`](#fn-specialvaluemapoptionswithmatch) + * [`fn withPattern(value)`](#fn-specialvaluemapoptionswithpattern) + * [`fn withResult(value)`](#fn-specialvaluemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-specialvaluemapoptionswithresultmixin) + * [`obj result`](#obj-specialvaluemapoptionsresult) + * [`fn withColor(value)`](#fn-specialvaluemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-specialvaluemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-specialvaluemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-specialvaluemapoptionsresultwithtext) +* [`obj ValueMap`](#obj-valuemap) + * [`fn withOptions(value)`](#fn-valuemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-valuemapwithoptionsmixin) + * [`fn withType(value)`](#fn-valuemapwithtype) + +## Fields + +### obj RangeMap + + +#### fn RangeMap.withOptions + +```jsonnet +RangeMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withOptionsMixin + +```jsonnet +RangeMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withType + +```jsonnet +RangeMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RangeMap.options + + +##### fn RangeMap.options.withFrom + +```jsonnet +RangeMap.options.withFrom(value) +``` + +PARAMETERS: + +* **value** (`number`) + +to and from are `number | null` in current ts, really not sure what to do +##### fn RangeMap.options.withResult + +```jsonnet +RangeMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withResultMixin + +```jsonnet +RangeMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withTo + +```jsonnet +RangeMap.options.withTo(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +##### obj RangeMap.options.result + + +###### fn RangeMap.options.result.withColor + +```jsonnet +RangeMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIcon + +```jsonnet +RangeMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIndex + +```jsonnet +RangeMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RangeMap.options.result.withText + +```jsonnet +RangeMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj RegexMap + + +#### fn RegexMap.withOptions + +```jsonnet +RegexMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withOptionsMixin + +```jsonnet +RegexMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withType + +```jsonnet +RegexMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RegexMap.options + + +##### fn RegexMap.options.withPattern + +```jsonnet +RegexMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn RegexMap.options.withResult + +```jsonnet +RegexMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RegexMap.options.withResultMixin + +```jsonnet +RegexMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj RegexMap.options.result + + +###### fn RegexMap.options.result.withColor + +```jsonnet +RegexMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIcon + +```jsonnet +RegexMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIndex + +```jsonnet +RegexMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RegexMap.options.result.withText + +```jsonnet +RegexMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj SpecialValueMap + + +#### fn SpecialValueMap.withOptions + +```jsonnet +SpecialValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withOptionsMixin + +```jsonnet +SpecialValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withType + +```jsonnet +SpecialValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj SpecialValueMap.options + + +##### fn SpecialValueMap.options.withMatch + +```jsonnet +SpecialValueMap.options.withMatch(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"true"`, `"false"` + + +##### fn SpecialValueMap.options.withPattern + +```jsonnet +SpecialValueMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn SpecialValueMap.options.withResult + +```jsonnet +SpecialValueMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn SpecialValueMap.options.withResultMixin + +```jsonnet +SpecialValueMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj SpecialValueMap.options.result + + +###### fn SpecialValueMap.options.result.withColor + +```jsonnet +SpecialValueMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIcon + +```jsonnet +SpecialValueMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIndex + +```jsonnet +SpecialValueMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn SpecialValueMap.options.result.withText + +```jsonnet +SpecialValueMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj ValueMap + + +#### fn ValueMap.withOptions + +```jsonnet +ValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withOptionsMixin + +```jsonnet +ValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withType + +```jsonnet +ValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/geomap/standardOptions/override.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/geomap/standardOptions/override.md new file mode 100644 index 0000000000..154f3dbdac --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/geomap/standardOptions/override.md @@ -0,0 +1,244 @@ +# override + +Overrides allow you to customize visualization settings for specific fields or +series. This is accomplished by adding an override rule that targets +a particular set of fields and that can each define multiple options. + +```jsonnet +override.byType.new('number') ++ override.byType.withPropertiesFromOptions( + panel.standardOptions.withDecimals(2) + + panel.standardOptions.withUnit('s') +) +``` + + +## Index + +* [`obj byName`](#obj-byname) + * [`fn new(value)`](#fn-bynamenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bynamewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bynamewithproperty) +* [`obj byQuery`](#obj-byquery) + * [`fn new(value)`](#fn-byquerynew) + * [`fn withPropertiesFromOptions(options)`](#fn-byquerywithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byquerywithproperty) +* [`obj byRegexp`](#obj-byregexp) + * [`fn new(value)`](#fn-byregexpnew) + * [`fn withPropertiesFromOptions(options)`](#fn-byregexpwithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byregexpwithproperty) +* [`obj byType`](#obj-bytype) + * [`fn new(value)`](#fn-bytypenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bytypewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bytypewithproperty) +* [`obj byValue`](#obj-byvalue) + * [`fn new(value)`](#fn-byvaluenew) + * [`fn withPropertiesFromOptions(options)`](#fn-byvaluewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byvaluewithproperty) + +## Fields + +### obj byName + + +#### fn byName.new + +```jsonnet +byName.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byName`. +#### fn byName.withPropertiesFromOptions + +```jsonnet +byName.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byName.withProperty + +```jsonnet +byName.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byQuery + + +#### fn byQuery.new + +```jsonnet +byQuery.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byQuery`. +#### fn byQuery.withPropertiesFromOptions + +```jsonnet +byQuery.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byQuery.withProperty + +```jsonnet +byQuery.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byRegexp + + +#### fn byRegexp.new + +```jsonnet +byRegexp.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byRegexp`. +#### fn byRegexp.withPropertiesFromOptions + +```jsonnet +byRegexp.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byRegexp.withProperty + +```jsonnet +byRegexp.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byType + + +#### fn byType.new + +```jsonnet +byType.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byType`. +#### fn byType.withPropertiesFromOptions + +```jsonnet +byType.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byType.withProperty + +```jsonnet +byType.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byValue + + +#### fn byValue.new + +```jsonnet +byValue.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byValue`. +#### fn byValue.withPropertiesFromOptions + +```jsonnet +byValue.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byValue.withProperty + +```jsonnet +byValue.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/geomap/standardOptions/threshold/step.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/geomap/standardOptions/threshold/step.md new file mode 100644 index 0000000000..dd2dd227ff --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/geomap/standardOptions/threshold/step.md @@ -0,0 +1,60 @@ +# threshold.step + + + +## Index + +* [`fn withColor(value)`](#fn-withcolor) +* [`fn withIndex(value)`](#fn-withindex) +* [`fn withState(value)`](#fn-withstate) +* [`fn withValue(value)`](#fn-withvalue) + +## Fields + +### fn withColor + +```jsonnet +withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +### fn withIndex + +```jsonnet +withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Threshold index, an old property that is not needed an should only appear in older dashboards +### fn withState + +```jsonnet +withState(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO are the values here enumerable into a disjunction? +Some seem to be listed in typescript comment +### fn withValue + +```jsonnet +withValue(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +FIXME the corresponding typescript field is required/non-optional, but nulls currently appear here when serializing -Infinity to JSON \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/heatmap/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/heatmap/index.md new file mode 100644 index 0000000000..04322da2d5 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/heatmap/index.md @@ -0,0 +1,1804 @@ +# heatmap + +grafonnet.panel.heatmap + +## Subpackages + +* [panelOptions.link](panelOptions/link.md) +* [queryOptions.transformation](queryOptions/transformation.md) +* [standardOptions.mapping](standardOptions/mapping.md) +* [standardOptions.override](standardOptions/override.md) +* [standardOptions.threshold.step](standardOptions/threshold/step.md) + +## Index + +* [`fn new(title)`](#fn-new) +* [`obj fieldConfig`](#obj-fieldconfig) + * [`obj defaults`](#obj-fieldconfigdefaults) + * [`obj custom`](#obj-fieldconfigdefaultscustom) + * [`fn withHideFrom(value)`](#fn-fieldconfigdefaultscustomwithhidefrom) + * [`fn withHideFromMixin(value)`](#fn-fieldconfigdefaultscustomwithhidefrommixin) + * [`fn withScaleDistribution(value)`](#fn-fieldconfigdefaultscustomwithscaledistribution) + * [`fn withScaleDistributionMixin(value)`](#fn-fieldconfigdefaultscustomwithscaledistributionmixin) + * [`obj hideFrom`](#obj-fieldconfigdefaultscustomhidefrom) + * [`fn withLegend(value=true)`](#fn-fieldconfigdefaultscustomhidefromwithlegend) + * [`fn withTooltip(value=true)`](#fn-fieldconfigdefaultscustomhidefromwithtooltip) + * [`fn withViz(value=true)`](#fn-fieldconfigdefaultscustomhidefromwithviz) + * [`obj scaleDistribution`](#obj-fieldconfigdefaultscustomscaledistribution) + * [`fn withLinearThreshold(value)`](#fn-fieldconfigdefaultscustomscaledistributionwithlinearthreshold) + * [`fn withLog(value)`](#fn-fieldconfigdefaultscustomscaledistributionwithlog) + * [`fn withType(value)`](#fn-fieldconfigdefaultscustomscaledistributionwithtype) +* [`obj libraryPanel`](#obj-librarypanel) + * [`fn withName(value)`](#fn-librarypanelwithname) + * [`fn withUid(value)`](#fn-librarypanelwithuid) +* [`obj options`](#obj-options) + * [`fn withCalculate(value=true)`](#fn-optionswithcalculate) + * [`fn withCalculation(value)`](#fn-optionswithcalculation) + * [`fn withCalculationMixin(value)`](#fn-optionswithcalculationmixin) + * [`fn withCellGap(value=1)`](#fn-optionswithcellgap) + * [`fn withCellRadius(value)`](#fn-optionswithcellradius) + * [`fn withCellValues(value={})`](#fn-optionswithcellvalues) + * [`fn withCellValuesMixin(value={})`](#fn-optionswithcellvaluesmixin) + * [`fn withColor(value={"exponent": 0.5,"fill": "dark-orange","reverse": false,"scheme": "Oranges","steps": 64})`](#fn-optionswithcolor) + * [`fn withColorMixin(value={"exponent": 0.5,"fill": "dark-orange","reverse": false,"scheme": "Oranges","steps": 64})`](#fn-optionswithcolormixin) + * [`fn withExemplars(value)`](#fn-optionswithexemplars) + * [`fn withExemplarsMixin(value)`](#fn-optionswithexemplarsmixin) + * [`fn withFilterValues(value={"le": 0.000000001})`](#fn-optionswithfiltervalues) + * [`fn withFilterValuesMixin(value={"le": 0.000000001})`](#fn-optionswithfiltervaluesmixin) + * [`fn withLegend(value)`](#fn-optionswithlegend) + * [`fn withLegendMixin(value)`](#fn-optionswithlegendmixin) + * [`fn withRowsFrame(value)`](#fn-optionswithrowsframe) + * [`fn withRowsFrameMixin(value)`](#fn-optionswithrowsframemixin) + * [`fn withShowValue(value)`](#fn-optionswithshowvalue) + * [`fn withTooltip(value)`](#fn-optionswithtooltip) + * [`fn withTooltipMixin(value)`](#fn-optionswithtooltipmixin) + * [`fn withYAxis(value)`](#fn-optionswithyaxis) + * [`fn withYAxisMixin(value)`](#fn-optionswithyaxismixin) + * [`obj calculation`](#obj-optionscalculation) + * [`fn withXBuckets(value)`](#fn-optionscalculationwithxbuckets) + * [`fn withXBucketsMixin(value)`](#fn-optionscalculationwithxbucketsmixin) + * [`fn withYBuckets(value)`](#fn-optionscalculationwithybuckets) + * [`fn withYBucketsMixin(value)`](#fn-optionscalculationwithybucketsmixin) + * [`obj xBuckets`](#obj-optionscalculationxbuckets) + * [`fn withMode(value)`](#fn-optionscalculationxbucketswithmode) + * [`fn withScale(value)`](#fn-optionscalculationxbucketswithscale) + * [`fn withScaleMixin(value)`](#fn-optionscalculationxbucketswithscalemixin) + * [`fn withValue(value)`](#fn-optionscalculationxbucketswithvalue) + * [`obj scale`](#obj-optionscalculationxbucketsscale) + * [`fn withLinearThreshold(value)`](#fn-optionscalculationxbucketsscalewithlinearthreshold) + * [`fn withLog(value)`](#fn-optionscalculationxbucketsscalewithlog) + * [`fn withType(value)`](#fn-optionscalculationxbucketsscalewithtype) + * [`obj yBuckets`](#obj-optionscalculationybuckets) + * [`fn withMode(value)`](#fn-optionscalculationybucketswithmode) + * [`fn withScale(value)`](#fn-optionscalculationybucketswithscale) + * [`fn withScaleMixin(value)`](#fn-optionscalculationybucketswithscalemixin) + * [`fn withValue(value)`](#fn-optionscalculationybucketswithvalue) + * [`obj scale`](#obj-optionscalculationybucketsscale) + * [`fn withLinearThreshold(value)`](#fn-optionscalculationybucketsscalewithlinearthreshold) + * [`fn withLog(value)`](#fn-optionscalculationybucketsscalewithlog) + * [`fn withType(value)`](#fn-optionscalculationybucketsscalewithtype) + * [`obj cellValues`](#obj-optionscellvalues) + * [`fn withCellValues(value)`](#fn-optionscellvalueswithcellvalues) + * [`fn withCellValuesMixin(value)`](#fn-optionscellvalueswithcellvaluesmixin) + * [`obj CellValues`](#obj-optionscellvaluescellvalues) + * [`fn withDecimals(value)`](#fn-optionscellvaluescellvalueswithdecimals) + * [`fn withUnit(value)`](#fn-optionscellvaluescellvalueswithunit) + * [`obj color`](#obj-optionscolor) + * [`fn withHeatmapColorOptions(value)`](#fn-optionscolorwithheatmapcoloroptions) + * [`fn withHeatmapColorOptionsMixin(value)`](#fn-optionscolorwithheatmapcoloroptionsmixin) + * [`obj HeatmapColorOptions`](#obj-optionscolorheatmapcoloroptions) + * [`fn withExponent(value)`](#fn-optionscolorheatmapcoloroptionswithexponent) + * [`fn withFill(value)`](#fn-optionscolorheatmapcoloroptionswithfill) + * [`fn withMax(value)`](#fn-optionscolorheatmapcoloroptionswithmax) + * [`fn withMin(value)`](#fn-optionscolorheatmapcoloroptionswithmin) + * [`fn withMode(value)`](#fn-optionscolorheatmapcoloroptionswithmode) + * [`fn withReverse(value=true)`](#fn-optionscolorheatmapcoloroptionswithreverse) + * [`fn withScale(value)`](#fn-optionscolorheatmapcoloroptionswithscale) + * [`fn withScheme(value)`](#fn-optionscolorheatmapcoloroptionswithscheme) + * [`fn withSteps(value)`](#fn-optionscolorheatmapcoloroptionswithsteps) + * [`obj exemplars`](#obj-optionsexemplars) + * [`fn withColor(value)`](#fn-optionsexemplarswithcolor) + * [`obj filterValues`](#obj-optionsfiltervalues) + * [`fn withFilterValueRange(value)`](#fn-optionsfiltervalueswithfiltervaluerange) + * [`fn withFilterValueRangeMixin(value)`](#fn-optionsfiltervalueswithfiltervaluerangemixin) + * [`obj FilterValueRange`](#obj-optionsfiltervaluesfiltervaluerange) + * [`fn withGe(value)`](#fn-optionsfiltervaluesfiltervaluerangewithge) + * [`fn withLe(value)`](#fn-optionsfiltervaluesfiltervaluerangewithle) + * [`obj legend`](#obj-optionslegend) + * [`fn withShow(value=true)`](#fn-optionslegendwithshow) + * [`obj rowsFrame`](#obj-optionsrowsframe) + * [`fn withLayout(value)`](#fn-optionsrowsframewithlayout) + * [`fn withValue(value)`](#fn-optionsrowsframewithvalue) + * [`obj tooltip`](#obj-optionstooltip) + * [`fn withShow(value=true)`](#fn-optionstooltipwithshow) + * [`fn withYHistogram(value=true)`](#fn-optionstooltipwithyhistogram) + * [`obj yAxis`](#obj-optionsyaxis) + * [`fn withAxisCenteredZero(value=true)`](#fn-optionsyaxiswithaxiscenteredzero) + * [`fn withAxisColorMode(value)`](#fn-optionsyaxiswithaxiscolormode) + * [`fn withAxisGridShow(value=true)`](#fn-optionsyaxiswithaxisgridshow) + * [`fn withAxisLabel(value)`](#fn-optionsyaxiswithaxislabel) + * [`fn withAxisPlacement(value)`](#fn-optionsyaxiswithaxisplacement) + * [`fn withAxisSoftMax(value)`](#fn-optionsyaxiswithaxissoftmax) + * [`fn withAxisSoftMin(value)`](#fn-optionsyaxiswithaxissoftmin) + * [`fn withAxisWidth(value)`](#fn-optionsyaxiswithaxiswidth) + * [`fn withDecimals(value)`](#fn-optionsyaxiswithdecimals) + * [`fn withMax(value)`](#fn-optionsyaxiswithmax) + * [`fn withMin(value)`](#fn-optionsyaxiswithmin) + * [`fn withReverse(value=true)`](#fn-optionsyaxiswithreverse) + * [`fn withScaleDistribution(value)`](#fn-optionsyaxiswithscaledistribution) + * [`fn withScaleDistributionMixin(value)`](#fn-optionsyaxiswithscaledistributionmixin) + * [`fn withUnit(value)`](#fn-optionsyaxiswithunit) + * [`obj scaleDistribution`](#obj-optionsyaxisscaledistribution) + * [`fn withLinearThreshold(value)`](#fn-optionsyaxisscaledistributionwithlinearthreshold) + * [`fn withLog(value)`](#fn-optionsyaxisscaledistributionwithlog) + * [`fn withType(value)`](#fn-optionsyaxisscaledistributionwithtype) +* [`obj panelOptions`](#obj-paneloptions) + * [`fn withDescription(value)`](#fn-paneloptionswithdescription) + * [`fn withGridPos(h="null", w="null", x="null", y="null")`](#fn-paneloptionswithgridpos) + * [`fn withLinks(value)`](#fn-paneloptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-paneloptionswithlinksmixin) + * [`fn withRepeat(value)`](#fn-paneloptionswithrepeat) + * [`fn withRepeatDirection(value="h")`](#fn-paneloptionswithrepeatdirection) + * [`fn withTitle(value)`](#fn-paneloptionswithtitle) + * [`fn withTransparent(value=true)`](#fn-paneloptionswithtransparent) +* [`obj queryOptions`](#obj-queryoptions) + * [`fn withDatasource(type, uid)`](#fn-queryoptionswithdatasource) + * [`fn withDatasourceMixin(value)`](#fn-queryoptionswithdatasourcemixin) + * [`fn withInterval(value)`](#fn-queryoptionswithinterval) + * [`fn withMaxDataPoints(value)`](#fn-queryoptionswithmaxdatapoints) + * [`fn withTargets(value)`](#fn-queryoptionswithtargets) + * [`fn withTargetsMixin(value)`](#fn-queryoptionswithtargetsmixin) + * [`fn withTimeFrom(value)`](#fn-queryoptionswithtimefrom) + * [`fn withTimeShift(value)`](#fn-queryoptionswithtimeshift) + * [`fn withTransformations(value)`](#fn-queryoptionswithtransformations) + * [`fn withTransformationsMixin(value)`](#fn-queryoptionswithtransformationsmixin) +* [`obj standardOptions`](#obj-standardoptions) + * [`fn withDecimals(value)`](#fn-standardoptionswithdecimals) + * [`fn withDisplayName(value)`](#fn-standardoptionswithdisplayname) + * [`fn withFilterable(value=true)`](#fn-standardoptionswithfilterable) + * [`fn withLinks(value)`](#fn-standardoptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-standardoptionswithlinksmixin) + * [`fn withMappings(value)`](#fn-standardoptionswithmappings) + * [`fn withMappingsMixin(value)`](#fn-standardoptionswithmappingsmixin) + * [`fn withMax(value)`](#fn-standardoptionswithmax) + * [`fn withMin(value)`](#fn-standardoptionswithmin) + * [`fn withNoValue(value)`](#fn-standardoptionswithnovalue) + * [`fn withOverrides(value)`](#fn-standardoptionswithoverrides) + * [`fn withOverridesMixin(value)`](#fn-standardoptionswithoverridesmixin) + * [`fn withPath(value)`](#fn-standardoptionswithpath) + * [`fn withUnit(value)`](#fn-standardoptionswithunit) + * [`obj color`](#obj-standardoptionscolor) + * [`fn withFixedColor(value)`](#fn-standardoptionscolorwithfixedcolor) + * [`fn withMode(value)`](#fn-standardoptionscolorwithmode) + * [`fn withSeriesBy(value)`](#fn-standardoptionscolorwithseriesby) + * [`obj thresholds`](#obj-standardoptionsthresholds) + * [`fn withMode(value)`](#fn-standardoptionsthresholdswithmode) + * [`fn withSteps(value)`](#fn-standardoptionsthresholdswithsteps) + * [`fn withStepsMixin(value)`](#fn-standardoptionsthresholdswithstepsmixin) + +## Fields + +### fn new + +```jsonnet +new(title) +``` + +PARAMETERS: + +* **title** (`string`) + +Creates a new heatmap panel with a title. +### obj fieldConfig + + +#### obj fieldConfig.defaults + + +##### obj fieldConfig.defaults.custom + + +###### fn fieldConfig.defaults.custom.withHideFrom + +```jsonnet +fieldConfig.defaults.custom.withHideFrom(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn fieldConfig.defaults.custom.withHideFromMixin + +```jsonnet +fieldConfig.defaults.custom.withHideFromMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn fieldConfig.defaults.custom.withScaleDistribution + +```jsonnet +fieldConfig.defaults.custom.withScaleDistribution(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn fieldConfig.defaults.custom.withScaleDistributionMixin + +```jsonnet +fieldConfig.defaults.custom.withScaleDistributionMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### obj fieldConfig.defaults.custom.hideFrom + + +####### fn fieldConfig.defaults.custom.hideFrom.withLegend + +```jsonnet +fieldConfig.defaults.custom.hideFrom.withLegend(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +####### fn fieldConfig.defaults.custom.hideFrom.withTooltip + +```jsonnet +fieldConfig.defaults.custom.hideFrom.withTooltip(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +####### fn fieldConfig.defaults.custom.hideFrom.withViz + +```jsonnet +fieldConfig.defaults.custom.hideFrom.withViz(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +###### obj fieldConfig.defaults.custom.scaleDistribution + + +####### fn fieldConfig.defaults.custom.scaleDistribution.withLinearThreshold + +```jsonnet +fieldConfig.defaults.custom.scaleDistribution.withLinearThreshold(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +####### fn fieldConfig.defaults.custom.scaleDistribution.withLog + +```jsonnet +fieldConfig.defaults.custom.scaleDistribution.withLog(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +####### fn fieldConfig.defaults.custom.scaleDistribution.withType + +```jsonnet +fieldConfig.defaults.custom.scaleDistribution.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"linear"`, `"log"`, `"ordinal"`, `"symlog"` + +TODO docs +### obj libraryPanel + + +#### fn libraryPanel.withName + +```jsonnet +libraryPanel.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn libraryPanel.withUid + +```jsonnet +libraryPanel.withUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj options + + +#### fn options.withCalculate + +```jsonnet +options.withCalculate(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Controls if the heatmap should be calculated from data +#### fn options.withCalculation + +```jsonnet +options.withCalculation(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn options.withCalculationMixin + +```jsonnet +options.withCalculationMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn options.withCellGap + +```jsonnet +options.withCellGap(value=1) +``` + +PARAMETERS: + +* **value** (`integer`) + - default value: `1` + +Controls gap between cells +#### fn options.withCellRadius + +```jsonnet +options.withCellRadius(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Controls cell radius +#### fn options.withCellValues + +```jsonnet +options.withCellValues(value={}) +``` + +PARAMETERS: + +* **value** (`object`) + - default value: `{}` + +Controls cell value unit +#### fn options.withCellValuesMixin + +```jsonnet +options.withCellValuesMixin(value={}) +``` + +PARAMETERS: + +* **value** (`object`) + - default value: `{}` + +Controls cell value unit +#### fn options.withColor + +```jsonnet +options.withColor(value={"exponent": 0.5,"fill": "dark-orange","reverse": false,"scheme": "Oranges","steps": 64}) +``` + +PARAMETERS: + +* **value** (`object`) + - default value: `{"exponent": 0.5,"fill": "dark-orange","reverse": false,"scheme": "Oranges","steps": 64}` + +Controls the color options +#### fn options.withColorMixin + +```jsonnet +options.withColorMixin(value={"exponent": 0.5,"fill": "dark-orange","reverse": false,"scheme": "Oranges","steps": 64}) +``` + +PARAMETERS: + +* **value** (`object`) + - default value: `{"exponent": 0.5,"fill": "dark-orange","reverse": false,"scheme": "Oranges","steps": 64}` + +Controls the color options +#### fn options.withExemplars + +```jsonnet +options.withExemplars(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Controls exemplar options +#### fn options.withExemplarsMixin + +```jsonnet +options.withExemplarsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Controls exemplar options +#### fn options.withFilterValues + +```jsonnet +options.withFilterValues(value={"le": 0.000000001}) +``` + +PARAMETERS: + +* **value** (`object`) + - default value: `{"le": 0.000000001}` + +Filters values between a given range +#### fn options.withFilterValuesMixin + +```jsonnet +options.withFilterValuesMixin(value={"le": 0.000000001}) +``` + +PARAMETERS: + +* **value** (`object`) + - default value: `{"le": 0.000000001}` + +Filters values between a given range +#### fn options.withLegend + +```jsonnet +options.withLegend(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Controls legend options +#### fn options.withLegendMixin + +```jsonnet +options.withLegendMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Controls legend options +#### fn options.withRowsFrame + +```jsonnet +options.withRowsFrame(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Controls frame rows options +#### fn options.withRowsFrameMixin + +```jsonnet +options.withRowsFrameMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Controls frame rows options +#### fn options.withShowValue + +```jsonnet +options.withShowValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + +| *{ + layout: ui.HeatmapCellLayout & "auto" // TODO: fix after remove when https://github.com/grafana/cuetsy/issues/74 is fixed +} +Controls the display of the value in the cell +#### fn options.withTooltip + +```jsonnet +options.withTooltip(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Controls tooltip options +#### fn options.withTooltipMixin + +```jsonnet +options.withTooltipMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Controls tooltip options +#### fn options.withYAxis + +```jsonnet +options.withYAxis(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Configuration options for the yAxis +#### fn options.withYAxisMixin + +```jsonnet +options.withYAxisMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Configuration options for the yAxis +#### obj options.calculation + + +##### fn options.calculation.withXBuckets + +```jsonnet +options.calculation.withXBuckets(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn options.calculation.withXBucketsMixin + +```jsonnet +options.calculation.withXBucketsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn options.calculation.withYBuckets + +```jsonnet +options.calculation.withYBuckets(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn options.calculation.withYBucketsMixin + +```jsonnet +options.calculation.withYBucketsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### obj options.calculation.xBuckets + + +###### fn options.calculation.xBuckets.withMode + +```jsonnet +options.calculation.xBuckets.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"size"`, `"count"` + + +###### fn options.calculation.xBuckets.withScale + +```jsonnet +options.calculation.xBuckets.withScale(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn options.calculation.xBuckets.withScaleMixin + +```jsonnet +options.calculation.xBuckets.withScaleMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn options.calculation.xBuckets.withValue + +```jsonnet +options.calculation.xBuckets.withValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The number of buckets to use for the axis in the heatmap +###### obj options.calculation.xBuckets.scale + + +####### fn options.calculation.xBuckets.scale.withLinearThreshold + +```jsonnet +options.calculation.xBuckets.scale.withLinearThreshold(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +####### fn options.calculation.xBuckets.scale.withLog + +```jsonnet +options.calculation.xBuckets.scale.withLog(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +####### fn options.calculation.xBuckets.scale.withType + +```jsonnet +options.calculation.xBuckets.scale.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"linear"`, `"log"`, `"ordinal"`, `"symlog"` + +TODO docs +##### obj options.calculation.yBuckets + + +###### fn options.calculation.yBuckets.withMode + +```jsonnet +options.calculation.yBuckets.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"size"`, `"count"` + + +###### fn options.calculation.yBuckets.withScale + +```jsonnet +options.calculation.yBuckets.withScale(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn options.calculation.yBuckets.withScaleMixin + +```jsonnet +options.calculation.yBuckets.withScaleMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn options.calculation.yBuckets.withValue + +```jsonnet +options.calculation.yBuckets.withValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The number of buckets to use for the axis in the heatmap +###### obj options.calculation.yBuckets.scale + + +####### fn options.calculation.yBuckets.scale.withLinearThreshold + +```jsonnet +options.calculation.yBuckets.scale.withLinearThreshold(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +####### fn options.calculation.yBuckets.scale.withLog + +```jsonnet +options.calculation.yBuckets.scale.withLog(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +####### fn options.calculation.yBuckets.scale.withType + +```jsonnet +options.calculation.yBuckets.scale.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"linear"`, `"log"`, `"ordinal"`, `"symlog"` + +TODO docs +#### obj options.cellValues + + +##### fn options.cellValues.withCellValues + +```jsonnet +options.cellValues.withCellValues(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Controls cell value options +##### fn options.cellValues.withCellValuesMixin + +```jsonnet +options.cellValues.withCellValuesMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Controls cell value options +##### obj options.cellValues.CellValues + + +###### fn options.cellValues.CellValues.withDecimals + +```jsonnet +options.cellValues.CellValues.withDecimals(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Controls the number of decimals for cell values +###### fn options.cellValues.CellValues.withUnit + +```jsonnet +options.cellValues.CellValues.withUnit(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Controls the cell value unit +#### obj options.color + + +##### fn options.color.withHeatmapColorOptions + +```jsonnet +options.color.withHeatmapColorOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Controls various color options +##### fn options.color.withHeatmapColorOptionsMixin + +```jsonnet +options.color.withHeatmapColorOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Controls various color options +##### obj options.color.HeatmapColorOptions + + +###### fn options.color.HeatmapColorOptions.withExponent + +```jsonnet +options.color.HeatmapColorOptions.withExponent(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Controls the exponent when scale is set to exponential +###### fn options.color.HeatmapColorOptions.withFill + +```jsonnet +options.color.HeatmapColorOptions.withFill(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Controls the color fill when in opacity mode +###### fn options.color.HeatmapColorOptions.withMax + +```jsonnet +options.color.HeatmapColorOptions.withMax(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Sets the maximum value for the color scale +###### fn options.color.HeatmapColorOptions.withMin + +```jsonnet +options.color.HeatmapColorOptions.withMin(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Sets the minimum value for the color scale +###### fn options.color.HeatmapColorOptions.withMode + +```jsonnet +options.color.HeatmapColorOptions.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"opacity"`, `"scheme"` + +Controls the color mode of the heatmap +###### fn options.color.HeatmapColorOptions.withReverse + +```jsonnet +options.color.HeatmapColorOptions.withReverse(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Reverses the color scheme +###### fn options.color.HeatmapColorOptions.withScale + +```jsonnet +options.color.HeatmapColorOptions.withScale(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"linear"`, `"exponential"` + +Controls the color scale of the heatmap +###### fn options.color.HeatmapColorOptions.withScheme + +```jsonnet +options.color.HeatmapColorOptions.withScheme(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Controls the color scheme used +###### fn options.color.HeatmapColorOptions.withSteps + +```jsonnet +options.color.HeatmapColorOptions.withSteps(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Controls the number of color steps +#### obj options.exemplars + + +##### fn options.exemplars.withColor + +```jsonnet +options.exemplars.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Sets the color of the exemplar markers +#### obj options.filterValues + + +##### fn options.filterValues.withFilterValueRange + +```jsonnet +options.filterValues.withFilterValueRange(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Controls the value filter range +##### fn options.filterValues.withFilterValueRangeMixin + +```jsonnet +options.filterValues.withFilterValueRangeMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Controls the value filter range +##### obj options.filterValues.FilterValueRange + + +###### fn options.filterValues.FilterValueRange.withGe + +```jsonnet +options.filterValues.FilterValueRange.withGe(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Sets the filter range to values greater than or equal to the given value +###### fn options.filterValues.FilterValueRange.withLe + +```jsonnet +options.filterValues.FilterValueRange.withLe(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Sets the filter range to values less than or equal to the given value +#### obj options.legend + + +##### fn options.legend.withShow + +```jsonnet +options.legend.withShow(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Controls if the legend is shown +#### obj options.rowsFrame + + +##### fn options.rowsFrame.withLayout + +```jsonnet +options.rowsFrame.withLayout(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"le"`, `"ge"`, `"unknown"`, `"auto"` + + +##### fn options.rowsFrame.withValue + +```jsonnet +options.rowsFrame.withValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Sets the name of the cell when not calculating from data +#### obj options.tooltip + + +##### fn options.tooltip.withShow + +```jsonnet +options.tooltip.withShow(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Controls if the tooltip is shown +##### fn options.tooltip.withYHistogram + +```jsonnet +options.tooltip.withYHistogram(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Controls if the tooltip shows a histogram of the y-axis values +#### obj options.yAxis + + +##### fn options.yAxis.withAxisCenteredZero + +```jsonnet +options.yAxis.withAxisCenteredZero(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.yAxis.withAxisColorMode + +```jsonnet +options.yAxis.withAxisColorMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"text"`, `"series"` + +TODO docs +##### fn options.yAxis.withAxisGridShow + +```jsonnet +options.yAxis.withAxisGridShow(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.yAxis.withAxisLabel + +```jsonnet +options.yAxis.withAxisLabel(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn options.yAxis.withAxisPlacement + +```jsonnet +options.yAxis.withAxisPlacement(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"auto"`, `"top"`, `"right"`, `"bottom"`, `"left"`, `"hidden"` + +TODO docs +##### fn options.yAxis.withAxisSoftMax + +```jsonnet +options.yAxis.withAxisSoftMax(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +##### fn options.yAxis.withAxisSoftMin + +```jsonnet +options.yAxis.withAxisSoftMin(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +##### fn options.yAxis.withAxisWidth + +```jsonnet +options.yAxis.withAxisWidth(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +##### fn options.yAxis.withDecimals + +```jsonnet +options.yAxis.withDecimals(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Controls the number of decimals for yAxis values +##### fn options.yAxis.withMax + +```jsonnet +options.yAxis.withMax(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Sets the maximum value for the yAxis +##### fn options.yAxis.withMin + +```jsonnet +options.yAxis.withMin(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Sets the minimum value for the yAxis +##### fn options.yAxis.withReverse + +```jsonnet +options.yAxis.withReverse(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Reverses the yAxis +##### fn options.yAxis.withScaleDistribution + +```jsonnet +options.yAxis.withScaleDistribution(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn options.yAxis.withScaleDistributionMixin + +```jsonnet +options.yAxis.withScaleDistributionMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn options.yAxis.withUnit + +```jsonnet +options.yAxis.withUnit(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Sets the yAxis unit +##### obj options.yAxis.scaleDistribution + + +###### fn options.yAxis.scaleDistribution.withLinearThreshold + +```jsonnet +options.yAxis.scaleDistribution.withLinearThreshold(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +###### fn options.yAxis.scaleDistribution.withLog + +```jsonnet +options.yAxis.scaleDistribution.withLog(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +###### fn options.yAxis.scaleDistribution.withType + +```jsonnet +options.yAxis.scaleDistribution.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"linear"`, `"log"`, `"ordinal"`, `"symlog"` + +TODO docs +### obj panelOptions + + +#### fn panelOptions.withDescription + +```jsonnet +panelOptions.withDescription(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Description. +#### fn panelOptions.withGridPos + +```jsonnet +panelOptions.withGridPos(h="null", w="null", x="null", y="null") +``` + +PARAMETERS: + +* **h** (`number`) + - default value: `"null"` +* **w** (`number`) + - default value: `"null"` +* **x** (`number`) + - default value: `"null"` +* **y** (`number`) + - default value: `"null"` + +`withGridPos` configures the height, width and xy coordinates of the panel. Also see `grafonnet.util.grid` for helper functions to calculate these fields. + +All arguments default to `null`, which means they will remain unchanged or unset. + +#### fn panelOptions.withLinks + +```jsonnet +panelOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withLinksMixin + +```jsonnet +panelOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withRepeat + +```jsonnet +panelOptions.withRepeat(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of template variable to repeat for. +#### fn panelOptions.withRepeatDirection + +```jsonnet +panelOptions.withRepeatDirection(value="h") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"h"` + - valid values: `"h"`, `"v"` + +Direction to repeat in if 'repeat' is set. +"h" for horizontal, "v" for vertical. +TODO this is probably optional +#### fn panelOptions.withTitle + +```jsonnet +panelOptions.withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Panel title. +#### fn panelOptions.withTransparent + +```jsonnet +panelOptions.withTransparent(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Whether to display the panel without a background. +### obj queryOptions + + +#### fn queryOptions.withDatasource + +```jsonnet +queryOptions.withDatasource(type, uid) +``` + +PARAMETERS: + +* **type** (`string`) +* **uid** (`string`) + +`withDatasource` sets the datasource for all queries in a panel. + +The default datasource for a panel is set to 'Mixed datasource' so panels can be datasource agnostic, which is a lot more interesting from a reusability standpoint. Note that this requires query targets to explicitly set datasource for the same reason. + +#### fn queryOptions.withDatasourceMixin + +```jsonnet +queryOptions.withDatasourceMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +The datasource used in all targets. +#### fn queryOptions.withInterval + +```jsonnet +queryOptions.withInterval(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withMaxDataPoints + +```jsonnet +queryOptions.withMaxDataPoints(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +#### fn queryOptions.withTargets + +```jsonnet +queryOptions.withTargets(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTargetsMixin + +```jsonnet +queryOptions.withTargetsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTimeFrom + +```jsonnet +queryOptions.withTimeFrom(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTimeShift + +```jsonnet +queryOptions.withTimeShift(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTransformations + +```jsonnet +queryOptions.withTransformations(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn queryOptions.withTransformationsMixin + +```jsonnet +queryOptions.withTransformationsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### obj standardOptions + + +#### fn standardOptions.withDecimals + +```jsonnet +standardOptions.withDecimals(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Significant digits (for display) +#### fn standardOptions.withDisplayName + +```jsonnet +standardOptions.withDisplayName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The display value for this field. This supports template variables blank is auto +#### fn standardOptions.withFilterable + +```jsonnet +standardOptions.withFilterable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +True if data source field supports ad-hoc filters +#### fn standardOptions.withLinks + +```jsonnet +standardOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withLinksMixin + +```jsonnet +standardOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withMappings + +```jsonnet +standardOptions.withMappings(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMappingsMixin + +```jsonnet +standardOptions.withMappingsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMax + +```jsonnet +standardOptions.withMax(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withMin + +```jsonnet +standardOptions.withMin(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withNoValue + +```jsonnet +standardOptions.withNoValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Alternative to empty string +#### fn standardOptions.withOverrides + +```jsonnet +standardOptions.withOverrides(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withOverridesMixin + +```jsonnet +standardOptions.withOverridesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withPath + +```jsonnet +standardOptions.withPath(value) +``` + +PARAMETERS: + +* **value** (`string`) + +An explicit path to the field in the datasource. When the frame meta includes a path, +This will default to `${frame.meta.path}/${field.name} + +When defined, this value can be used as an identifier within the datasource scope, and +may be used to update the results +#### fn standardOptions.withUnit + +```jsonnet +standardOptions.withUnit(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Numeric Options +#### obj standardOptions.color + + +##### fn standardOptions.color.withFixedColor + +```jsonnet +standardOptions.color.withFixedColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Stores the fixed color value if mode is fixed +##### fn standardOptions.color.withMode + +```jsonnet +standardOptions.color.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The main color scheme mode +##### fn standardOptions.color.withSeriesBy + +```jsonnet +standardOptions.color.withSeriesBy(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"min"`, `"max"`, `"last"` + +TODO docs +#### obj standardOptions.thresholds + + +##### fn standardOptions.thresholds.withMode + +```jsonnet +standardOptions.thresholds.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"absolute"`, `"percentage"` + + +##### fn standardOptions.thresholds.withSteps + +```jsonnet +standardOptions.thresholds.withSteps(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity +##### fn standardOptions.thresholds.withStepsMixin + +```jsonnet +standardOptions.thresholds.withStepsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/heatmap/panelOptions/link.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/heatmap/panelOptions/link.md new file mode 100644 index 0000000000..106f9d2edb --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/heatmap/panelOptions/link.md @@ -0,0 +1,145 @@ +# link + + + +## Index + +* [`fn withAsDropdown(value=true)`](#fn-withasdropdown) +* [`fn withIcon(value)`](#fn-withicon) +* [`fn withIncludeVars(value=true)`](#fn-withincludevars) +* [`fn withKeepTime(value=true)`](#fn-withkeeptime) +* [`fn withTags(value)`](#fn-withtags) +* [`fn withTagsMixin(value)`](#fn-withtagsmixin) +* [`fn withTargetBlank(value=true)`](#fn-withtargetblank) +* [`fn withTitle(value)`](#fn-withtitle) +* [`fn withTooltip(value)`](#fn-withtooltip) +* [`fn withType(value)`](#fn-withtype) +* [`fn withUrl(value)`](#fn-withurl) + +## Fields + +### fn withAsDropdown + +```jsonnet +withAsDropdown(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withIcon + +```jsonnet +withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withIncludeVars + +```jsonnet +withIncludeVars(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withKeepTime + +```jsonnet +withKeepTime(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTags + +```jsonnet +withTags(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTagsMixin + +```jsonnet +withTagsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTargetBlank + +```jsonnet +withTargetBlank(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTitle + +```jsonnet +withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withTooltip + +```jsonnet +withTooltip(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withType + +```jsonnet +withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"link"`, `"dashboards"` + +TODO docs +### fn withUrl + +```jsonnet +withUrl(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/heatmap/queryOptions/transformation.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/heatmap/queryOptions/transformation.md new file mode 100644 index 0000000000..dc832f653d --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/heatmap/queryOptions/transformation.md @@ -0,0 +1,99 @@ +# transformation + + + +## Index + +* [`fn withDisabled(value=true)`](#fn-withdisabled) +* [`fn withFilter(value)`](#fn-withfilter) +* [`fn withFilterMixin(value)`](#fn-withfiltermixin) +* [`fn withId(value)`](#fn-withid) +* [`fn withOptions(value)`](#fn-withoptions) +* [`obj filter`](#obj-filter) + * [`fn withId(value="")`](#fn-filterwithid) + * [`fn withOptions(value)`](#fn-filterwithoptions) + +## Fields + +### fn withDisabled + +```jsonnet +withDisabled(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Disabled transformations are skipped +### fn withFilter + +```jsonnet +withFilter(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withFilterMixin + +```jsonnet +withFilterMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withId + +```jsonnet +withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Unique identifier of transformer +### fn withOptions + +```jsonnet +withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Options to be passed to the transformer +Valid options depend on the transformer id +### obj filter + + +#### fn filter.withId + +```jsonnet +filter.withId(value="") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `""` + + +#### fn filter.withOptions + +```jsonnet +filter.withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/heatmap/standardOptions/mapping.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/heatmap/standardOptions/mapping.md new file mode 100644 index 0000000000..93296972e8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/heatmap/standardOptions/mapping.md @@ -0,0 +1,469 @@ +# mapping + + + +## Index + +* [`obj RangeMap`](#obj-rangemap) + * [`fn withOptions(value)`](#fn-rangemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-rangemapwithoptionsmixin) + * [`fn withType(value)`](#fn-rangemapwithtype) + * [`obj options`](#obj-rangemapoptions) + * [`fn withFrom(value)`](#fn-rangemapoptionswithfrom) + * [`fn withResult(value)`](#fn-rangemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-rangemapoptionswithresultmixin) + * [`fn withTo(value)`](#fn-rangemapoptionswithto) + * [`obj result`](#obj-rangemapoptionsresult) + * [`fn withColor(value)`](#fn-rangemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-rangemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-rangemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-rangemapoptionsresultwithtext) +* [`obj RegexMap`](#obj-regexmap) + * [`fn withOptions(value)`](#fn-regexmapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-regexmapwithoptionsmixin) + * [`fn withType(value)`](#fn-regexmapwithtype) + * [`obj options`](#obj-regexmapoptions) + * [`fn withPattern(value)`](#fn-regexmapoptionswithpattern) + * [`fn withResult(value)`](#fn-regexmapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-regexmapoptionswithresultmixin) + * [`obj result`](#obj-regexmapoptionsresult) + * [`fn withColor(value)`](#fn-regexmapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-regexmapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-regexmapoptionsresultwithindex) + * [`fn withText(value)`](#fn-regexmapoptionsresultwithtext) +* [`obj SpecialValueMap`](#obj-specialvaluemap) + * [`fn withOptions(value)`](#fn-specialvaluemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-specialvaluemapwithoptionsmixin) + * [`fn withType(value)`](#fn-specialvaluemapwithtype) + * [`obj options`](#obj-specialvaluemapoptions) + * [`fn withMatch(value)`](#fn-specialvaluemapoptionswithmatch) + * [`fn withPattern(value)`](#fn-specialvaluemapoptionswithpattern) + * [`fn withResult(value)`](#fn-specialvaluemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-specialvaluemapoptionswithresultmixin) + * [`obj result`](#obj-specialvaluemapoptionsresult) + * [`fn withColor(value)`](#fn-specialvaluemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-specialvaluemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-specialvaluemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-specialvaluemapoptionsresultwithtext) +* [`obj ValueMap`](#obj-valuemap) + * [`fn withOptions(value)`](#fn-valuemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-valuemapwithoptionsmixin) + * [`fn withType(value)`](#fn-valuemapwithtype) + +## Fields + +### obj RangeMap + + +#### fn RangeMap.withOptions + +```jsonnet +RangeMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withOptionsMixin + +```jsonnet +RangeMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withType + +```jsonnet +RangeMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RangeMap.options + + +##### fn RangeMap.options.withFrom + +```jsonnet +RangeMap.options.withFrom(value) +``` + +PARAMETERS: + +* **value** (`number`) + +to and from are `number | null` in current ts, really not sure what to do +##### fn RangeMap.options.withResult + +```jsonnet +RangeMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withResultMixin + +```jsonnet +RangeMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withTo + +```jsonnet +RangeMap.options.withTo(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +##### obj RangeMap.options.result + + +###### fn RangeMap.options.result.withColor + +```jsonnet +RangeMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIcon + +```jsonnet +RangeMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIndex + +```jsonnet +RangeMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RangeMap.options.result.withText + +```jsonnet +RangeMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj RegexMap + + +#### fn RegexMap.withOptions + +```jsonnet +RegexMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withOptionsMixin + +```jsonnet +RegexMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withType + +```jsonnet +RegexMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RegexMap.options + + +##### fn RegexMap.options.withPattern + +```jsonnet +RegexMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn RegexMap.options.withResult + +```jsonnet +RegexMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RegexMap.options.withResultMixin + +```jsonnet +RegexMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj RegexMap.options.result + + +###### fn RegexMap.options.result.withColor + +```jsonnet +RegexMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIcon + +```jsonnet +RegexMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIndex + +```jsonnet +RegexMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RegexMap.options.result.withText + +```jsonnet +RegexMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj SpecialValueMap + + +#### fn SpecialValueMap.withOptions + +```jsonnet +SpecialValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withOptionsMixin + +```jsonnet +SpecialValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withType + +```jsonnet +SpecialValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj SpecialValueMap.options + + +##### fn SpecialValueMap.options.withMatch + +```jsonnet +SpecialValueMap.options.withMatch(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"true"`, `"false"` + + +##### fn SpecialValueMap.options.withPattern + +```jsonnet +SpecialValueMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn SpecialValueMap.options.withResult + +```jsonnet +SpecialValueMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn SpecialValueMap.options.withResultMixin + +```jsonnet +SpecialValueMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj SpecialValueMap.options.result + + +###### fn SpecialValueMap.options.result.withColor + +```jsonnet +SpecialValueMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIcon + +```jsonnet +SpecialValueMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIndex + +```jsonnet +SpecialValueMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn SpecialValueMap.options.result.withText + +```jsonnet +SpecialValueMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj ValueMap + + +#### fn ValueMap.withOptions + +```jsonnet +ValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withOptionsMixin + +```jsonnet +ValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withType + +```jsonnet +ValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/heatmap/standardOptions/override.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/heatmap/standardOptions/override.md new file mode 100644 index 0000000000..154f3dbdac --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/heatmap/standardOptions/override.md @@ -0,0 +1,244 @@ +# override + +Overrides allow you to customize visualization settings for specific fields or +series. This is accomplished by adding an override rule that targets +a particular set of fields and that can each define multiple options. + +```jsonnet +override.byType.new('number') ++ override.byType.withPropertiesFromOptions( + panel.standardOptions.withDecimals(2) + + panel.standardOptions.withUnit('s') +) +``` + + +## Index + +* [`obj byName`](#obj-byname) + * [`fn new(value)`](#fn-bynamenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bynamewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bynamewithproperty) +* [`obj byQuery`](#obj-byquery) + * [`fn new(value)`](#fn-byquerynew) + * [`fn withPropertiesFromOptions(options)`](#fn-byquerywithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byquerywithproperty) +* [`obj byRegexp`](#obj-byregexp) + * [`fn new(value)`](#fn-byregexpnew) + * [`fn withPropertiesFromOptions(options)`](#fn-byregexpwithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byregexpwithproperty) +* [`obj byType`](#obj-bytype) + * [`fn new(value)`](#fn-bytypenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bytypewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bytypewithproperty) +* [`obj byValue`](#obj-byvalue) + * [`fn new(value)`](#fn-byvaluenew) + * [`fn withPropertiesFromOptions(options)`](#fn-byvaluewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byvaluewithproperty) + +## Fields + +### obj byName + + +#### fn byName.new + +```jsonnet +byName.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byName`. +#### fn byName.withPropertiesFromOptions + +```jsonnet +byName.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byName.withProperty + +```jsonnet +byName.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byQuery + + +#### fn byQuery.new + +```jsonnet +byQuery.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byQuery`. +#### fn byQuery.withPropertiesFromOptions + +```jsonnet +byQuery.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byQuery.withProperty + +```jsonnet +byQuery.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byRegexp + + +#### fn byRegexp.new + +```jsonnet +byRegexp.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byRegexp`. +#### fn byRegexp.withPropertiesFromOptions + +```jsonnet +byRegexp.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byRegexp.withProperty + +```jsonnet +byRegexp.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byType + + +#### fn byType.new + +```jsonnet +byType.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byType`. +#### fn byType.withPropertiesFromOptions + +```jsonnet +byType.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byType.withProperty + +```jsonnet +byType.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byValue + + +#### fn byValue.new + +```jsonnet +byValue.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byValue`. +#### fn byValue.withPropertiesFromOptions + +```jsonnet +byValue.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byValue.withProperty + +```jsonnet +byValue.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/heatmap/standardOptions/threshold/step.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/heatmap/standardOptions/threshold/step.md new file mode 100644 index 0000000000..dd2dd227ff --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/heatmap/standardOptions/threshold/step.md @@ -0,0 +1,60 @@ +# threshold.step + + + +## Index + +* [`fn withColor(value)`](#fn-withcolor) +* [`fn withIndex(value)`](#fn-withindex) +* [`fn withState(value)`](#fn-withstate) +* [`fn withValue(value)`](#fn-withvalue) + +## Fields + +### fn withColor + +```jsonnet +withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +### fn withIndex + +```jsonnet +withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Threshold index, an old property that is not needed an should only appear in older dashboards +### fn withState + +```jsonnet +withState(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO are the values here enumerable into a disjunction? +Some seem to be listed in typescript comment +### fn withValue + +```jsonnet +withValue(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +FIXME the corresponding typescript field is required/non-optional, but nulls currently appear here when serializing -Infinity to JSON \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/histogram/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/histogram/index.md new file mode 100644 index 0000000000..48daae8edb --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/histogram/index.md @@ -0,0 +1,1098 @@ +# histogram + +grafonnet.panel.histogram + +## Subpackages + +* [panelOptions.link](panelOptions/link.md) +* [queryOptions.transformation](queryOptions/transformation.md) +* [standardOptions.mapping](standardOptions/mapping.md) +* [standardOptions.override](standardOptions/override.md) +* [standardOptions.threshold.step](standardOptions/threshold/step.md) + +## Index + +* [`fn new(title)`](#fn-new) +* [`obj fieldConfig`](#obj-fieldconfig) + * [`obj defaults`](#obj-fieldconfigdefaults) + * [`obj custom`](#obj-fieldconfigdefaultscustom) + * [`fn withAxisCenteredZero(value=true)`](#fn-fieldconfigdefaultscustomwithaxiscenteredzero) + * [`fn withAxisColorMode(value)`](#fn-fieldconfigdefaultscustomwithaxiscolormode) + * [`fn withAxisGridShow(value=true)`](#fn-fieldconfigdefaultscustomwithaxisgridshow) + * [`fn withAxisLabel(value)`](#fn-fieldconfigdefaultscustomwithaxislabel) + * [`fn withAxisPlacement(value)`](#fn-fieldconfigdefaultscustomwithaxisplacement) + * [`fn withAxisSoftMax(value)`](#fn-fieldconfigdefaultscustomwithaxissoftmax) + * [`fn withAxisSoftMin(value)`](#fn-fieldconfigdefaultscustomwithaxissoftmin) + * [`fn withAxisWidth(value)`](#fn-fieldconfigdefaultscustomwithaxiswidth) + * [`fn withFillOpacity(value=80)`](#fn-fieldconfigdefaultscustomwithfillopacity) + * [`fn withGradientMode(value)`](#fn-fieldconfigdefaultscustomwithgradientmode) + * [`fn withHideFrom(value)`](#fn-fieldconfigdefaultscustomwithhidefrom) + * [`fn withHideFromMixin(value)`](#fn-fieldconfigdefaultscustomwithhidefrommixin) + * [`fn withLineWidth(value=1)`](#fn-fieldconfigdefaultscustomwithlinewidth) + * [`fn withScaleDistribution(value)`](#fn-fieldconfigdefaultscustomwithscaledistribution) + * [`fn withScaleDistributionMixin(value)`](#fn-fieldconfigdefaultscustomwithscaledistributionmixin) + * [`obj hideFrom`](#obj-fieldconfigdefaultscustomhidefrom) + * [`fn withLegend(value=true)`](#fn-fieldconfigdefaultscustomhidefromwithlegend) + * [`fn withTooltip(value=true)`](#fn-fieldconfigdefaultscustomhidefromwithtooltip) + * [`fn withViz(value=true)`](#fn-fieldconfigdefaultscustomhidefromwithviz) + * [`obj scaleDistribution`](#obj-fieldconfigdefaultscustomscaledistribution) + * [`fn withLinearThreshold(value)`](#fn-fieldconfigdefaultscustomscaledistributionwithlinearthreshold) + * [`fn withLog(value)`](#fn-fieldconfigdefaultscustomscaledistributionwithlog) + * [`fn withType(value)`](#fn-fieldconfigdefaultscustomscaledistributionwithtype) +* [`obj libraryPanel`](#obj-librarypanel) + * [`fn withName(value)`](#fn-librarypanelwithname) + * [`fn withUid(value)`](#fn-librarypanelwithuid) +* [`obj options`](#obj-options) + * [`fn withBucketOffset(value=0)`](#fn-optionswithbucketoffset) + * [`fn withBucketSize(value)`](#fn-optionswithbucketsize) + * [`fn withCombine(value=true)`](#fn-optionswithcombine) + * [`fn withLegend(value)`](#fn-optionswithlegend) + * [`fn withLegendMixin(value)`](#fn-optionswithlegendmixin) + * [`fn withTooltip(value)`](#fn-optionswithtooltip) + * [`fn withTooltipMixin(value)`](#fn-optionswithtooltipmixin) + * [`obj legend`](#obj-optionslegend) + * [`fn withAsTable(value=true)`](#fn-optionslegendwithastable) + * [`fn withCalcs(value)`](#fn-optionslegendwithcalcs) + * [`fn withCalcsMixin(value)`](#fn-optionslegendwithcalcsmixin) + * [`fn withDisplayMode(value)`](#fn-optionslegendwithdisplaymode) + * [`fn withIsVisible(value=true)`](#fn-optionslegendwithisvisible) + * [`fn withPlacement(value)`](#fn-optionslegendwithplacement) + * [`fn withShowLegend(value=true)`](#fn-optionslegendwithshowlegend) + * [`fn withSortBy(value)`](#fn-optionslegendwithsortby) + * [`fn withSortDesc(value=true)`](#fn-optionslegendwithsortdesc) + * [`fn withWidth(value)`](#fn-optionslegendwithwidth) + * [`obj tooltip`](#obj-optionstooltip) + * [`fn withMode(value)`](#fn-optionstooltipwithmode) + * [`fn withSort(value)`](#fn-optionstooltipwithsort) +* [`obj panelOptions`](#obj-paneloptions) + * [`fn withDescription(value)`](#fn-paneloptionswithdescription) + * [`fn withGridPos(h="null", w="null", x="null", y="null")`](#fn-paneloptionswithgridpos) + * [`fn withLinks(value)`](#fn-paneloptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-paneloptionswithlinksmixin) + * [`fn withRepeat(value)`](#fn-paneloptionswithrepeat) + * [`fn withRepeatDirection(value="h")`](#fn-paneloptionswithrepeatdirection) + * [`fn withTitle(value)`](#fn-paneloptionswithtitle) + * [`fn withTransparent(value=true)`](#fn-paneloptionswithtransparent) +* [`obj queryOptions`](#obj-queryoptions) + * [`fn withDatasource(type, uid)`](#fn-queryoptionswithdatasource) + * [`fn withDatasourceMixin(value)`](#fn-queryoptionswithdatasourcemixin) + * [`fn withInterval(value)`](#fn-queryoptionswithinterval) + * [`fn withMaxDataPoints(value)`](#fn-queryoptionswithmaxdatapoints) + * [`fn withTargets(value)`](#fn-queryoptionswithtargets) + * [`fn withTargetsMixin(value)`](#fn-queryoptionswithtargetsmixin) + * [`fn withTimeFrom(value)`](#fn-queryoptionswithtimefrom) + * [`fn withTimeShift(value)`](#fn-queryoptionswithtimeshift) + * [`fn withTransformations(value)`](#fn-queryoptionswithtransformations) + * [`fn withTransformationsMixin(value)`](#fn-queryoptionswithtransformationsmixin) +* [`obj standardOptions`](#obj-standardoptions) + * [`fn withDecimals(value)`](#fn-standardoptionswithdecimals) + * [`fn withDisplayName(value)`](#fn-standardoptionswithdisplayname) + * [`fn withFilterable(value=true)`](#fn-standardoptionswithfilterable) + * [`fn withLinks(value)`](#fn-standardoptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-standardoptionswithlinksmixin) + * [`fn withMappings(value)`](#fn-standardoptionswithmappings) + * [`fn withMappingsMixin(value)`](#fn-standardoptionswithmappingsmixin) + * [`fn withMax(value)`](#fn-standardoptionswithmax) + * [`fn withMin(value)`](#fn-standardoptionswithmin) + * [`fn withNoValue(value)`](#fn-standardoptionswithnovalue) + * [`fn withOverrides(value)`](#fn-standardoptionswithoverrides) + * [`fn withOverridesMixin(value)`](#fn-standardoptionswithoverridesmixin) + * [`fn withPath(value)`](#fn-standardoptionswithpath) + * [`fn withUnit(value)`](#fn-standardoptionswithunit) + * [`obj color`](#obj-standardoptionscolor) + * [`fn withFixedColor(value)`](#fn-standardoptionscolorwithfixedcolor) + * [`fn withMode(value)`](#fn-standardoptionscolorwithmode) + * [`fn withSeriesBy(value)`](#fn-standardoptionscolorwithseriesby) + * [`obj thresholds`](#obj-standardoptionsthresholds) + * [`fn withMode(value)`](#fn-standardoptionsthresholdswithmode) + * [`fn withSteps(value)`](#fn-standardoptionsthresholdswithsteps) + * [`fn withStepsMixin(value)`](#fn-standardoptionsthresholdswithstepsmixin) + +## Fields + +### fn new + +```jsonnet +new(title) +``` + +PARAMETERS: + +* **title** (`string`) + +Creates a new histogram panel with a title. +### obj fieldConfig + + +#### obj fieldConfig.defaults + + +##### obj fieldConfig.defaults.custom + + +###### fn fieldConfig.defaults.custom.withAxisCenteredZero + +```jsonnet +fieldConfig.defaults.custom.withAxisCenteredZero(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +###### fn fieldConfig.defaults.custom.withAxisColorMode + +```jsonnet +fieldConfig.defaults.custom.withAxisColorMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"text"`, `"series"` + +TODO docs +###### fn fieldConfig.defaults.custom.withAxisGridShow + +```jsonnet +fieldConfig.defaults.custom.withAxisGridShow(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +###### fn fieldConfig.defaults.custom.withAxisLabel + +```jsonnet +fieldConfig.defaults.custom.withAxisLabel(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn fieldConfig.defaults.custom.withAxisPlacement + +```jsonnet +fieldConfig.defaults.custom.withAxisPlacement(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"auto"`, `"top"`, `"right"`, `"bottom"`, `"left"`, `"hidden"` + +TODO docs +###### fn fieldConfig.defaults.custom.withAxisSoftMax + +```jsonnet +fieldConfig.defaults.custom.withAxisSoftMax(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +###### fn fieldConfig.defaults.custom.withAxisSoftMin + +```jsonnet +fieldConfig.defaults.custom.withAxisSoftMin(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +###### fn fieldConfig.defaults.custom.withAxisWidth + +```jsonnet +fieldConfig.defaults.custom.withAxisWidth(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +###### fn fieldConfig.defaults.custom.withFillOpacity + +```jsonnet +fieldConfig.defaults.custom.withFillOpacity(value=80) +``` + +PARAMETERS: + +* **value** (`integer`) + - default value: `80` + +Controls the fill opacity of the bars. +###### fn fieldConfig.defaults.custom.withGradientMode + +```jsonnet +fieldConfig.defaults.custom.withGradientMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Set the mode of the gradient fill. Fill gradient is based on the line color. To change the color, use the standard color scheme field option. +Gradient appearance is influenced by the Fill opacity setting. +###### fn fieldConfig.defaults.custom.withHideFrom + +```jsonnet +fieldConfig.defaults.custom.withHideFrom(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn fieldConfig.defaults.custom.withHideFromMixin + +```jsonnet +fieldConfig.defaults.custom.withHideFromMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn fieldConfig.defaults.custom.withLineWidth + +```jsonnet +fieldConfig.defaults.custom.withLineWidth(value=1) +``` + +PARAMETERS: + +* **value** (`integer`) + - default value: `1` + +Controls line width of the bars. +###### fn fieldConfig.defaults.custom.withScaleDistribution + +```jsonnet +fieldConfig.defaults.custom.withScaleDistribution(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn fieldConfig.defaults.custom.withScaleDistributionMixin + +```jsonnet +fieldConfig.defaults.custom.withScaleDistributionMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### obj fieldConfig.defaults.custom.hideFrom + + +####### fn fieldConfig.defaults.custom.hideFrom.withLegend + +```jsonnet +fieldConfig.defaults.custom.hideFrom.withLegend(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +####### fn fieldConfig.defaults.custom.hideFrom.withTooltip + +```jsonnet +fieldConfig.defaults.custom.hideFrom.withTooltip(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +####### fn fieldConfig.defaults.custom.hideFrom.withViz + +```jsonnet +fieldConfig.defaults.custom.hideFrom.withViz(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +###### obj fieldConfig.defaults.custom.scaleDistribution + + +####### fn fieldConfig.defaults.custom.scaleDistribution.withLinearThreshold + +```jsonnet +fieldConfig.defaults.custom.scaleDistribution.withLinearThreshold(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +####### fn fieldConfig.defaults.custom.scaleDistribution.withLog + +```jsonnet +fieldConfig.defaults.custom.scaleDistribution.withLog(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +####### fn fieldConfig.defaults.custom.scaleDistribution.withType + +```jsonnet +fieldConfig.defaults.custom.scaleDistribution.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"linear"`, `"log"`, `"ordinal"`, `"symlog"` + +TODO docs +### obj libraryPanel + + +#### fn libraryPanel.withName + +```jsonnet +libraryPanel.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn libraryPanel.withUid + +```jsonnet +libraryPanel.withUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj options + + +#### fn options.withBucketOffset + +```jsonnet +options.withBucketOffset(value=0) +``` + +PARAMETERS: + +* **value** (`integer`) + - default value: `0` + +Offset buckets by this amount +#### fn options.withBucketSize + +```jsonnet +options.withBucketSize(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Size of each bucket +#### fn options.withCombine + +```jsonnet +options.withCombine(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Combines multiple series into a single histogram +#### fn options.withLegend + +```jsonnet +options.withLegend(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withLegendMixin + +```jsonnet +options.withLegendMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withTooltip + +```jsonnet +options.withTooltip(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withTooltipMixin + +```jsonnet +options.withTooltipMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### obj options.legend + + +##### fn options.legend.withAsTable + +```jsonnet +options.legend.withAsTable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.legend.withCalcs + +```jsonnet +options.legend.withCalcs(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +##### fn options.legend.withCalcsMixin + +```jsonnet +options.legend.withCalcsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +##### fn options.legend.withDisplayMode + +```jsonnet +options.legend.withDisplayMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"list"`, `"table"`, `"hidden"` + +TODO docs +Note: "hidden" needs to remain as an option for plugins compatibility +##### fn options.legend.withIsVisible + +```jsonnet +options.legend.withIsVisible(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.legend.withPlacement + +```jsonnet +options.legend.withPlacement(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"bottom"`, `"right"` + +TODO docs +##### fn options.legend.withShowLegend + +```jsonnet +options.legend.withShowLegend(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.legend.withSortBy + +```jsonnet +options.legend.withSortBy(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn options.legend.withSortDesc + +```jsonnet +options.legend.withSortDesc(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.legend.withWidth + +```jsonnet +options.legend.withWidth(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### obj options.tooltip + + +##### fn options.tooltip.withMode + +```jsonnet +options.tooltip.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"single"`, `"multi"`, `"none"` + +TODO docs +##### fn options.tooltip.withSort + +```jsonnet +options.tooltip.withSort(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"asc"`, `"desc"`, `"none"` + +TODO docs +### obj panelOptions + + +#### fn panelOptions.withDescription + +```jsonnet +panelOptions.withDescription(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Description. +#### fn panelOptions.withGridPos + +```jsonnet +panelOptions.withGridPos(h="null", w="null", x="null", y="null") +``` + +PARAMETERS: + +* **h** (`number`) + - default value: `"null"` +* **w** (`number`) + - default value: `"null"` +* **x** (`number`) + - default value: `"null"` +* **y** (`number`) + - default value: `"null"` + +`withGridPos` configures the height, width and xy coordinates of the panel. Also see `grafonnet.util.grid` for helper functions to calculate these fields. + +All arguments default to `null`, which means they will remain unchanged or unset. + +#### fn panelOptions.withLinks + +```jsonnet +panelOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withLinksMixin + +```jsonnet +panelOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withRepeat + +```jsonnet +panelOptions.withRepeat(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of template variable to repeat for. +#### fn panelOptions.withRepeatDirection + +```jsonnet +panelOptions.withRepeatDirection(value="h") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"h"` + - valid values: `"h"`, `"v"` + +Direction to repeat in if 'repeat' is set. +"h" for horizontal, "v" for vertical. +TODO this is probably optional +#### fn panelOptions.withTitle + +```jsonnet +panelOptions.withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Panel title. +#### fn panelOptions.withTransparent + +```jsonnet +panelOptions.withTransparent(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Whether to display the panel without a background. +### obj queryOptions + + +#### fn queryOptions.withDatasource + +```jsonnet +queryOptions.withDatasource(type, uid) +``` + +PARAMETERS: + +* **type** (`string`) +* **uid** (`string`) + +`withDatasource` sets the datasource for all queries in a panel. + +The default datasource for a panel is set to 'Mixed datasource' so panels can be datasource agnostic, which is a lot more interesting from a reusability standpoint. Note that this requires query targets to explicitly set datasource for the same reason. + +#### fn queryOptions.withDatasourceMixin + +```jsonnet +queryOptions.withDatasourceMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +The datasource used in all targets. +#### fn queryOptions.withInterval + +```jsonnet +queryOptions.withInterval(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withMaxDataPoints + +```jsonnet +queryOptions.withMaxDataPoints(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +#### fn queryOptions.withTargets + +```jsonnet +queryOptions.withTargets(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTargetsMixin + +```jsonnet +queryOptions.withTargetsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTimeFrom + +```jsonnet +queryOptions.withTimeFrom(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTimeShift + +```jsonnet +queryOptions.withTimeShift(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTransformations + +```jsonnet +queryOptions.withTransformations(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn queryOptions.withTransformationsMixin + +```jsonnet +queryOptions.withTransformationsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### obj standardOptions + + +#### fn standardOptions.withDecimals + +```jsonnet +standardOptions.withDecimals(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Significant digits (for display) +#### fn standardOptions.withDisplayName + +```jsonnet +standardOptions.withDisplayName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The display value for this field. This supports template variables blank is auto +#### fn standardOptions.withFilterable + +```jsonnet +standardOptions.withFilterable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +True if data source field supports ad-hoc filters +#### fn standardOptions.withLinks + +```jsonnet +standardOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withLinksMixin + +```jsonnet +standardOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withMappings + +```jsonnet +standardOptions.withMappings(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMappingsMixin + +```jsonnet +standardOptions.withMappingsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMax + +```jsonnet +standardOptions.withMax(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withMin + +```jsonnet +standardOptions.withMin(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withNoValue + +```jsonnet +standardOptions.withNoValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Alternative to empty string +#### fn standardOptions.withOverrides + +```jsonnet +standardOptions.withOverrides(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withOverridesMixin + +```jsonnet +standardOptions.withOverridesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withPath + +```jsonnet +standardOptions.withPath(value) +``` + +PARAMETERS: + +* **value** (`string`) + +An explicit path to the field in the datasource. When the frame meta includes a path, +This will default to `${frame.meta.path}/${field.name} + +When defined, this value can be used as an identifier within the datasource scope, and +may be used to update the results +#### fn standardOptions.withUnit + +```jsonnet +standardOptions.withUnit(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Numeric Options +#### obj standardOptions.color + + +##### fn standardOptions.color.withFixedColor + +```jsonnet +standardOptions.color.withFixedColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Stores the fixed color value if mode is fixed +##### fn standardOptions.color.withMode + +```jsonnet +standardOptions.color.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The main color scheme mode +##### fn standardOptions.color.withSeriesBy + +```jsonnet +standardOptions.color.withSeriesBy(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"min"`, `"max"`, `"last"` + +TODO docs +#### obj standardOptions.thresholds + + +##### fn standardOptions.thresholds.withMode + +```jsonnet +standardOptions.thresholds.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"absolute"`, `"percentage"` + + +##### fn standardOptions.thresholds.withSteps + +```jsonnet +standardOptions.thresholds.withSteps(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity +##### fn standardOptions.thresholds.withStepsMixin + +```jsonnet +standardOptions.thresholds.withStepsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/histogram/panelOptions/link.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/histogram/panelOptions/link.md new file mode 100644 index 0000000000..106f9d2edb --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/histogram/panelOptions/link.md @@ -0,0 +1,145 @@ +# link + + + +## Index + +* [`fn withAsDropdown(value=true)`](#fn-withasdropdown) +* [`fn withIcon(value)`](#fn-withicon) +* [`fn withIncludeVars(value=true)`](#fn-withincludevars) +* [`fn withKeepTime(value=true)`](#fn-withkeeptime) +* [`fn withTags(value)`](#fn-withtags) +* [`fn withTagsMixin(value)`](#fn-withtagsmixin) +* [`fn withTargetBlank(value=true)`](#fn-withtargetblank) +* [`fn withTitle(value)`](#fn-withtitle) +* [`fn withTooltip(value)`](#fn-withtooltip) +* [`fn withType(value)`](#fn-withtype) +* [`fn withUrl(value)`](#fn-withurl) + +## Fields + +### fn withAsDropdown + +```jsonnet +withAsDropdown(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withIcon + +```jsonnet +withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withIncludeVars + +```jsonnet +withIncludeVars(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withKeepTime + +```jsonnet +withKeepTime(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTags + +```jsonnet +withTags(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTagsMixin + +```jsonnet +withTagsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTargetBlank + +```jsonnet +withTargetBlank(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTitle + +```jsonnet +withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withTooltip + +```jsonnet +withTooltip(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withType + +```jsonnet +withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"link"`, `"dashboards"` + +TODO docs +### fn withUrl + +```jsonnet +withUrl(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/histogram/queryOptions/transformation.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/histogram/queryOptions/transformation.md new file mode 100644 index 0000000000..dc832f653d --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/histogram/queryOptions/transformation.md @@ -0,0 +1,99 @@ +# transformation + + + +## Index + +* [`fn withDisabled(value=true)`](#fn-withdisabled) +* [`fn withFilter(value)`](#fn-withfilter) +* [`fn withFilterMixin(value)`](#fn-withfiltermixin) +* [`fn withId(value)`](#fn-withid) +* [`fn withOptions(value)`](#fn-withoptions) +* [`obj filter`](#obj-filter) + * [`fn withId(value="")`](#fn-filterwithid) + * [`fn withOptions(value)`](#fn-filterwithoptions) + +## Fields + +### fn withDisabled + +```jsonnet +withDisabled(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Disabled transformations are skipped +### fn withFilter + +```jsonnet +withFilter(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withFilterMixin + +```jsonnet +withFilterMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withId + +```jsonnet +withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Unique identifier of transformer +### fn withOptions + +```jsonnet +withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Options to be passed to the transformer +Valid options depend on the transformer id +### obj filter + + +#### fn filter.withId + +```jsonnet +filter.withId(value="") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `""` + + +#### fn filter.withOptions + +```jsonnet +filter.withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/histogram/standardOptions/mapping.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/histogram/standardOptions/mapping.md new file mode 100644 index 0000000000..93296972e8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/histogram/standardOptions/mapping.md @@ -0,0 +1,469 @@ +# mapping + + + +## Index + +* [`obj RangeMap`](#obj-rangemap) + * [`fn withOptions(value)`](#fn-rangemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-rangemapwithoptionsmixin) + * [`fn withType(value)`](#fn-rangemapwithtype) + * [`obj options`](#obj-rangemapoptions) + * [`fn withFrom(value)`](#fn-rangemapoptionswithfrom) + * [`fn withResult(value)`](#fn-rangemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-rangemapoptionswithresultmixin) + * [`fn withTo(value)`](#fn-rangemapoptionswithto) + * [`obj result`](#obj-rangemapoptionsresult) + * [`fn withColor(value)`](#fn-rangemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-rangemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-rangemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-rangemapoptionsresultwithtext) +* [`obj RegexMap`](#obj-regexmap) + * [`fn withOptions(value)`](#fn-regexmapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-regexmapwithoptionsmixin) + * [`fn withType(value)`](#fn-regexmapwithtype) + * [`obj options`](#obj-regexmapoptions) + * [`fn withPattern(value)`](#fn-regexmapoptionswithpattern) + * [`fn withResult(value)`](#fn-regexmapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-regexmapoptionswithresultmixin) + * [`obj result`](#obj-regexmapoptionsresult) + * [`fn withColor(value)`](#fn-regexmapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-regexmapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-regexmapoptionsresultwithindex) + * [`fn withText(value)`](#fn-regexmapoptionsresultwithtext) +* [`obj SpecialValueMap`](#obj-specialvaluemap) + * [`fn withOptions(value)`](#fn-specialvaluemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-specialvaluemapwithoptionsmixin) + * [`fn withType(value)`](#fn-specialvaluemapwithtype) + * [`obj options`](#obj-specialvaluemapoptions) + * [`fn withMatch(value)`](#fn-specialvaluemapoptionswithmatch) + * [`fn withPattern(value)`](#fn-specialvaluemapoptionswithpattern) + * [`fn withResult(value)`](#fn-specialvaluemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-specialvaluemapoptionswithresultmixin) + * [`obj result`](#obj-specialvaluemapoptionsresult) + * [`fn withColor(value)`](#fn-specialvaluemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-specialvaluemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-specialvaluemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-specialvaluemapoptionsresultwithtext) +* [`obj ValueMap`](#obj-valuemap) + * [`fn withOptions(value)`](#fn-valuemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-valuemapwithoptionsmixin) + * [`fn withType(value)`](#fn-valuemapwithtype) + +## Fields + +### obj RangeMap + + +#### fn RangeMap.withOptions + +```jsonnet +RangeMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withOptionsMixin + +```jsonnet +RangeMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withType + +```jsonnet +RangeMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RangeMap.options + + +##### fn RangeMap.options.withFrom + +```jsonnet +RangeMap.options.withFrom(value) +``` + +PARAMETERS: + +* **value** (`number`) + +to and from are `number | null` in current ts, really not sure what to do +##### fn RangeMap.options.withResult + +```jsonnet +RangeMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withResultMixin + +```jsonnet +RangeMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withTo + +```jsonnet +RangeMap.options.withTo(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +##### obj RangeMap.options.result + + +###### fn RangeMap.options.result.withColor + +```jsonnet +RangeMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIcon + +```jsonnet +RangeMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIndex + +```jsonnet +RangeMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RangeMap.options.result.withText + +```jsonnet +RangeMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj RegexMap + + +#### fn RegexMap.withOptions + +```jsonnet +RegexMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withOptionsMixin + +```jsonnet +RegexMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withType + +```jsonnet +RegexMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RegexMap.options + + +##### fn RegexMap.options.withPattern + +```jsonnet +RegexMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn RegexMap.options.withResult + +```jsonnet +RegexMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RegexMap.options.withResultMixin + +```jsonnet +RegexMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj RegexMap.options.result + + +###### fn RegexMap.options.result.withColor + +```jsonnet +RegexMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIcon + +```jsonnet +RegexMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIndex + +```jsonnet +RegexMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RegexMap.options.result.withText + +```jsonnet +RegexMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj SpecialValueMap + + +#### fn SpecialValueMap.withOptions + +```jsonnet +SpecialValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withOptionsMixin + +```jsonnet +SpecialValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withType + +```jsonnet +SpecialValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj SpecialValueMap.options + + +##### fn SpecialValueMap.options.withMatch + +```jsonnet +SpecialValueMap.options.withMatch(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"true"`, `"false"` + + +##### fn SpecialValueMap.options.withPattern + +```jsonnet +SpecialValueMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn SpecialValueMap.options.withResult + +```jsonnet +SpecialValueMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn SpecialValueMap.options.withResultMixin + +```jsonnet +SpecialValueMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj SpecialValueMap.options.result + + +###### fn SpecialValueMap.options.result.withColor + +```jsonnet +SpecialValueMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIcon + +```jsonnet +SpecialValueMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIndex + +```jsonnet +SpecialValueMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn SpecialValueMap.options.result.withText + +```jsonnet +SpecialValueMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj ValueMap + + +#### fn ValueMap.withOptions + +```jsonnet +ValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withOptionsMixin + +```jsonnet +ValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withType + +```jsonnet +ValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/histogram/standardOptions/override.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/histogram/standardOptions/override.md new file mode 100644 index 0000000000..154f3dbdac --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/histogram/standardOptions/override.md @@ -0,0 +1,244 @@ +# override + +Overrides allow you to customize visualization settings for specific fields or +series. This is accomplished by adding an override rule that targets +a particular set of fields and that can each define multiple options. + +```jsonnet +override.byType.new('number') ++ override.byType.withPropertiesFromOptions( + panel.standardOptions.withDecimals(2) + + panel.standardOptions.withUnit('s') +) +``` + + +## Index + +* [`obj byName`](#obj-byname) + * [`fn new(value)`](#fn-bynamenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bynamewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bynamewithproperty) +* [`obj byQuery`](#obj-byquery) + * [`fn new(value)`](#fn-byquerynew) + * [`fn withPropertiesFromOptions(options)`](#fn-byquerywithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byquerywithproperty) +* [`obj byRegexp`](#obj-byregexp) + * [`fn new(value)`](#fn-byregexpnew) + * [`fn withPropertiesFromOptions(options)`](#fn-byregexpwithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byregexpwithproperty) +* [`obj byType`](#obj-bytype) + * [`fn new(value)`](#fn-bytypenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bytypewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bytypewithproperty) +* [`obj byValue`](#obj-byvalue) + * [`fn new(value)`](#fn-byvaluenew) + * [`fn withPropertiesFromOptions(options)`](#fn-byvaluewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byvaluewithproperty) + +## Fields + +### obj byName + + +#### fn byName.new + +```jsonnet +byName.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byName`. +#### fn byName.withPropertiesFromOptions + +```jsonnet +byName.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byName.withProperty + +```jsonnet +byName.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byQuery + + +#### fn byQuery.new + +```jsonnet +byQuery.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byQuery`. +#### fn byQuery.withPropertiesFromOptions + +```jsonnet +byQuery.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byQuery.withProperty + +```jsonnet +byQuery.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byRegexp + + +#### fn byRegexp.new + +```jsonnet +byRegexp.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byRegexp`. +#### fn byRegexp.withPropertiesFromOptions + +```jsonnet +byRegexp.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byRegexp.withProperty + +```jsonnet +byRegexp.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byType + + +#### fn byType.new + +```jsonnet +byType.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byType`. +#### fn byType.withPropertiesFromOptions + +```jsonnet +byType.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byType.withProperty + +```jsonnet +byType.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byValue + + +#### fn byValue.new + +```jsonnet +byValue.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byValue`. +#### fn byValue.withPropertiesFromOptions + +```jsonnet +byValue.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byValue.withProperty + +```jsonnet +byValue.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/histogram/standardOptions/threshold/step.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/histogram/standardOptions/threshold/step.md new file mode 100644 index 0000000000..dd2dd227ff --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/histogram/standardOptions/threshold/step.md @@ -0,0 +1,60 @@ +# threshold.step + + + +## Index + +* [`fn withColor(value)`](#fn-withcolor) +* [`fn withIndex(value)`](#fn-withindex) +* [`fn withState(value)`](#fn-withstate) +* [`fn withValue(value)`](#fn-withvalue) + +## Fields + +### fn withColor + +```jsonnet +withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +### fn withIndex + +```jsonnet +withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Threshold index, an old property that is not needed an should only appear in older dashboards +### fn withState + +```jsonnet +withState(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO are the values here enumerable into a disjunction? +Some seem to be listed in typescript comment +### fn withValue + +```jsonnet +withValue(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +FIXME the corresponding typescript field is required/non-optional, but nulls currently appear here when serializing -Infinity to JSON \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/index.md new file mode 100644 index 0000000000..d29f1572a8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/index.md @@ -0,0 +1,33 @@ +# panel + +grafonnet.panel + +## Subpackages + +* [alertGroups](alertGroups/index.md) +* [alertList](alertList/index.md) +* [annotationsList](annotationsList/index.md) +* [barChart](barChart/index.md) +* [barGauge](barGauge/index.md) +* [candlestick](candlestick/index.md) +* [canvas](canvas/index.md) +* [dashboardList](dashboardList/index.md) +* [datagrid](datagrid/index.md) +* [debug](debug/index.md) +* [gauge](gauge/index.md) +* [geomap](geomap/index.md) +* [heatmap](heatmap/index.md) +* [histogram](histogram/index.md) +* [logs](logs/index.md) +* [news](news/index.md) +* [nodeGraph](nodeGraph/index.md) +* [pieChart](pieChart/index.md) +* [row](row.md) +* [stat](stat/index.md) +* [stateTimeline](stateTimeline/index.md) +* [statusHistory](statusHistory/index.md) +* [table](table/index.md) +* [text](text/index.md) +* [timeSeries](timeSeries/index.md) +* [trend](trend/index.md) +* [xyChart](xyChart/index.md) diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/logs/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/logs/index.md new file mode 100644 index 0000000000..4d1f3ad2b4 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/logs/index.md @@ -0,0 +1,672 @@ +# logs + +grafonnet.panel.logs + +## Subpackages + +* [panelOptions.link](panelOptions/link.md) +* [queryOptions.transformation](queryOptions/transformation.md) +* [standardOptions.mapping](standardOptions/mapping.md) +* [standardOptions.override](standardOptions/override.md) +* [standardOptions.threshold.step](standardOptions/threshold/step.md) + +## Index + +* [`fn new(title)`](#fn-new) +* [`obj libraryPanel`](#obj-librarypanel) + * [`fn withName(value)`](#fn-librarypanelwithname) + * [`fn withUid(value)`](#fn-librarypanelwithuid) +* [`obj options`](#obj-options) + * [`fn withDedupStrategy(value)`](#fn-optionswithdedupstrategy) + * [`fn withEnableLogDetails(value=true)`](#fn-optionswithenablelogdetails) + * [`fn withPrettifyLogMessage(value=true)`](#fn-optionswithprettifylogmessage) + * [`fn withShowCommonLabels(value=true)`](#fn-optionswithshowcommonlabels) + * [`fn withShowLabels(value=true)`](#fn-optionswithshowlabels) + * [`fn withShowTime(value=true)`](#fn-optionswithshowtime) + * [`fn withSortOrder(value)`](#fn-optionswithsortorder) + * [`fn withWrapLogMessage(value=true)`](#fn-optionswithwraplogmessage) +* [`obj panelOptions`](#obj-paneloptions) + * [`fn withDescription(value)`](#fn-paneloptionswithdescription) + * [`fn withGridPos(h="null", w="null", x="null", y="null")`](#fn-paneloptionswithgridpos) + * [`fn withLinks(value)`](#fn-paneloptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-paneloptionswithlinksmixin) + * [`fn withRepeat(value)`](#fn-paneloptionswithrepeat) + * [`fn withRepeatDirection(value="h")`](#fn-paneloptionswithrepeatdirection) + * [`fn withTitle(value)`](#fn-paneloptionswithtitle) + * [`fn withTransparent(value=true)`](#fn-paneloptionswithtransparent) +* [`obj queryOptions`](#obj-queryoptions) + * [`fn withDatasource(type, uid)`](#fn-queryoptionswithdatasource) + * [`fn withDatasourceMixin(value)`](#fn-queryoptionswithdatasourcemixin) + * [`fn withInterval(value)`](#fn-queryoptionswithinterval) + * [`fn withMaxDataPoints(value)`](#fn-queryoptionswithmaxdatapoints) + * [`fn withTargets(value)`](#fn-queryoptionswithtargets) + * [`fn withTargetsMixin(value)`](#fn-queryoptionswithtargetsmixin) + * [`fn withTimeFrom(value)`](#fn-queryoptionswithtimefrom) + * [`fn withTimeShift(value)`](#fn-queryoptionswithtimeshift) + * [`fn withTransformations(value)`](#fn-queryoptionswithtransformations) + * [`fn withTransformationsMixin(value)`](#fn-queryoptionswithtransformationsmixin) +* [`obj standardOptions`](#obj-standardoptions) + * [`fn withDecimals(value)`](#fn-standardoptionswithdecimals) + * [`fn withDisplayName(value)`](#fn-standardoptionswithdisplayname) + * [`fn withFilterable(value=true)`](#fn-standardoptionswithfilterable) + * [`fn withLinks(value)`](#fn-standardoptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-standardoptionswithlinksmixin) + * [`fn withMappings(value)`](#fn-standardoptionswithmappings) + * [`fn withMappingsMixin(value)`](#fn-standardoptionswithmappingsmixin) + * [`fn withMax(value)`](#fn-standardoptionswithmax) + * [`fn withMin(value)`](#fn-standardoptionswithmin) + * [`fn withNoValue(value)`](#fn-standardoptionswithnovalue) + * [`fn withOverrides(value)`](#fn-standardoptionswithoverrides) + * [`fn withOverridesMixin(value)`](#fn-standardoptionswithoverridesmixin) + * [`fn withPath(value)`](#fn-standardoptionswithpath) + * [`fn withUnit(value)`](#fn-standardoptionswithunit) + * [`obj color`](#obj-standardoptionscolor) + * [`fn withFixedColor(value)`](#fn-standardoptionscolorwithfixedcolor) + * [`fn withMode(value)`](#fn-standardoptionscolorwithmode) + * [`fn withSeriesBy(value)`](#fn-standardoptionscolorwithseriesby) + * [`obj thresholds`](#obj-standardoptionsthresholds) + * [`fn withMode(value)`](#fn-standardoptionsthresholdswithmode) + * [`fn withSteps(value)`](#fn-standardoptionsthresholdswithsteps) + * [`fn withStepsMixin(value)`](#fn-standardoptionsthresholdswithstepsmixin) + +## Fields + +### fn new + +```jsonnet +new(title) +``` + +PARAMETERS: + +* **title** (`string`) + +Creates a new logs panel with a title. +### obj libraryPanel + + +#### fn libraryPanel.withName + +```jsonnet +libraryPanel.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn libraryPanel.withUid + +```jsonnet +libraryPanel.withUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj options + + +#### fn options.withDedupStrategy + +```jsonnet +options.withDedupStrategy(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"none"`, `"exact"`, `"numbers"`, `"signature"` + + +#### fn options.withEnableLogDetails + +```jsonnet +options.withEnableLogDetails(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +#### fn options.withPrettifyLogMessage + +```jsonnet +options.withPrettifyLogMessage(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +#### fn options.withShowCommonLabels + +```jsonnet +options.withShowCommonLabels(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +#### fn options.withShowLabels + +```jsonnet +options.withShowLabels(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +#### fn options.withShowTime + +```jsonnet +options.withShowTime(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +#### fn options.withSortOrder + +```jsonnet +options.withSortOrder(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"Descending"`, `"Ascending"` + + +#### fn options.withWrapLogMessage + +```jsonnet +options.withWrapLogMessage(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### obj panelOptions + + +#### fn panelOptions.withDescription + +```jsonnet +panelOptions.withDescription(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Description. +#### fn panelOptions.withGridPos + +```jsonnet +panelOptions.withGridPos(h="null", w="null", x="null", y="null") +``` + +PARAMETERS: + +* **h** (`number`) + - default value: `"null"` +* **w** (`number`) + - default value: `"null"` +* **x** (`number`) + - default value: `"null"` +* **y** (`number`) + - default value: `"null"` + +`withGridPos` configures the height, width and xy coordinates of the panel. Also see `grafonnet.util.grid` for helper functions to calculate these fields. + +All arguments default to `null`, which means they will remain unchanged or unset. + +#### fn panelOptions.withLinks + +```jsonnet +panelOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withLinksMixin + +```jsonnet +panelOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withRepeat + +```jsonnet +panelOptions.withRepeat(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of template variable to repeat for. +#### fn panelOptions.withRepeatDirection + +```jsonnet +panelOptions.withRepeatDirection(value="h") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"h"` + - valid values: `"h"`, `"v"` + +Direction to repeat in if 'repeat' is set. +"h" for horizontal, "v" for vertical. +TODO this is probably optional +#### fn panelOptions.withTitle + +```jsonnet +panelOptions.withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Panel title. +#### fn panelOptions.withTransparent + +```jsonnet +panelOptions.withTransparent(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Whether to display the panel without a background. +### obj queryOptions + + +#### fn queryOptions.withDatasource + +```jsonnet +queryOptions.withDatasource(type, uid) +``` + +PARAMETERS: + +* **type** (`string`) +* **uid** (`string`) + +`withDatasource` sets the datasource for all queries in a panel. + +The default datasource for a panel is set to 'Mixed datasource' so panels can be datasource agnostic, which is a lot more interesting from a reusability standpoint. Note that this requires query targets to explicitly set datasource for the same reason. + +#### fn queryOptions.withDatasourceMixin + +```jsonnet +queryOptions.withDatasourceMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +The datasource used in all targets. +#### fn queryOptions.withInterval + +```jsonnet +queryOptions.withInterval(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withMaxDataPoints + +```jsonnet +queryOptions.withMaxDataPoints(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +#### fn queryOptions.withTargets + +```jsonnet +queryOptions.withTargets(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTargetsMixin + +```jsonnet +queryOptions.withTargetsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTimeFrom + +```jsonnet +queryOptions.withTimeFrom(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTimeShift + +```jsonnet +queryOptions.withTimeShift(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTransformations + +```jsonnet +queryOptions.withTransformations(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn queryOptions.withTransformationsMixin + +```jsonnet +queryOptions.withTransformationsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### obj standardOptions + + +#### fn standardOptions.withDecimals + +```jsonnet +standardOptions.withDecimals(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Significant digits (for display) +#### fn standardOptions.withDisplayName + +```jsonnet +standardOptions.withDisplayName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The display value for this field. This supports template variables blank is auto +#### fn standardOptions.withFilterable + +```jsonnet +standardOptions.withFilterable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +True if data source field supports ad-hoc filters +#### fn standardOptions.withLinks + +```jsonnet +standardOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withLinksMixin + +```jsonnet +standardOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withMappings + +```jsonnet +standardOptions.withMappings(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMappingsMixin + +```jsonnet +standardOptions.withMappingsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMax + +```jsonnet +standardOptions.withMax(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withMin + +```jsonnet +standardOptions.withMin(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withNoValue + +```jsonnet +standardOptions.withNoValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Alternative to empty string +#### fn standardOptions.withOverrides + +```jsonnet +standardOptions.withOverrides(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withOverridesMixin + +```jsonnet +standardOptions.withOverridesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withPath + +```jsonnet +standardOptions.withPath(value) +``` + +PARAMETERS: + +* **value** (`string`) + +An explicit path to the field in the datasource. When the frame meta includes a path, +This will default to `${frame.meta.path}/${field.name} + +When defined, this value can be used as an identifier within the datasource scope, and +may be used to update the results +#### fn standardOptions.withUnit + +```jsonnet +standardOptions.withUnit(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Numeric Options +#### obj standardOptions.color + + +##### fn standardOptions.color.withFixedColor + +```jsonnet +standardOptions.color.withFixedColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Stores the fixed color value if mode is fixed +##### fn standardOptions.color.withMode + +```jsonnet +standardOptions.color.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The main color scheme mode +##### fn standardOptions.color.withSeriesBy + +```jsonnet +standardOptions.color.withSeriesBy(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"min"`, `"max"`, `"last"` + +TODO docs +#### obj standardOptions.thresholds + + +##### fn standardOptions.thresholds.withMode + +```jsonnet +standardOptions.thresholds.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"absolute"`, `"percentage"` + + +##### fn standardOptions.thresholds.withSteps + +```jsonnet +standardOptions.thresholds.withSteps(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity +##### fn standardOptions.thresholds.withStepsMixin + +```jsonnet +standardOptions.thresholds.withStepsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/logs/panelOptions/link.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/logs/panelOptions/link.md new file mode 100644 index 0000000000..106f9d2edb --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/logs/panelOptions/link.md @@ -0,0 +1,145 @@ +# link + + + +## Index + +* [`fn withAsDropdown(value=true)`](#fn-withasdropdown) +* [`fn withIcon(value)`](#fn-withicon) +* [`fn withIncludeVars(value=true)`](#fn-withincludevars) +* [`fn withKeepTime(value=true)`](#fn-withkeeptime) +* [`fn withTags(value)`](#fn-withtags) +* [`fn withTagsMixin(value)`](#fn-withtagsmixin) +* [`fn withTargetBlank(value=true)`](#fn-withtargetblank) +* [`fn withTitle(value)`](#fn-withtitle) +* [`fn withTooltip(value)`](#fn-withtooltip) +* [`fn withType(value)`](#fn-withtype) +* [`fn withUrl(value)`](#fn-withurl) + +## Fields + +### fn withAsDropdown + +```jsonnet +withAsDropdown(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withIcon + +```jsonnet +withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withIncludeVars + +```jsonnet +withIncludeVars(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withKeepTime + +```jsonnet +withKeepTime(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTags + +```jsonnet +withTags(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTagsMixin + +```jsonnet +withTagsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTargetBlank + +```jsonnet +withTargetBlank(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTitle + +```jsonnet +withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withTooltip + +```jsonnet +withTooltip(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withType + +```jsonnet +withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"link"`, `"dashboards"` + +TODO docs +### fn withUrl + +```jsonnet +withUrl(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/logs/queryOptions/transformation.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/logs/queryOptions/transformation.md new file mode 100644 index 0000000000..dc832f653d --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/logs/queryOptions/transformation.md @@ -0,0 +1,99 @@ +# transformation + + + +## Index + +* [`fn withDisabled(value=true)`](#fn-withdisabled) +* [`fn withFilter(value)`](#fn-withfilter) +* [`fn withFilterMixin(value)`](#fn-withfiltermixin) +* [`fn withId(value)`](#fn-withid) +* [`fn withOptions(value)`](#fn-withoptions) +* [`obj filter`](#obj-filter) + * [`fn withId(value="")`](#fn-filterwithid) + * [`fn withOptions(value)`](#fn-filterwithoptions) + +## Fields + +### fn withDisabled + +```jsonnet +withDisabled(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Disabled transformations are skipped +### fn withFilter + +```jsonnet +withFilter(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withFilterMixin + +```jsonnet +withFilterMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withId + +```jsonnet +withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Unique identifier of transformer +### fn withOptions + +```jsonnet +withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Options to be passed to the transformer +Valid options depend on the transformer id +### obj filter + + +#### fn filter.withId + +```jsonnet +filter.withId(value="") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `""` + + +#### fn filter.withOptions + +```jsonnet +filter.withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/logs/standardOptions/mapping.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/logs/standardOptions/mapping.md new file mode 100644 index 0000000000..93296972e8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/logs/standardOptions/mapping.md @@ -0,0 +1,469 @@ +# mapping + + + +## Index + +* [`obj RangeMap`](#obj-rangemap) + * [`fn withOptions(value)`](#fn-rangemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-rangemapwithoptionsmixin) + * [`fn withType(value)`](#fn-rangemapwithtype) + * [`obj options`](#obj-rangemapoptions) + * [`fn withFrom(value)`](#fn-rangemapoptionswithfrom) + * [`fn withResult(value)`](#fn-rangemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-rangemapoptionswithresultmixin) + * [`fn withTo(value)`](#fn-rangemapoptionswithto) + * [`obj result`](#obj-rangemapoptionsresult) + * [`fn withColor(value)`](#fn-rangemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-rangemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-rangemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-rangemapoptionsresultwithtext) +* [`obj RegexMap`](#obj-regexmap) + * [`fn withOptions(value)`](#fn-regexmapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-regexmapwithoptionsmixin) + * [`fn withType(value)`](#fn-regexmapwithtype) + * [`obj options`](#obj-regexmapoptions) + * [`fn withPattern(value)`](#fn-regexmapoptionswithpattern) + * [`fn withResult(value)`](#fn-regexmapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-regexmapoptionswithresultmixin) + * [`obj result`](#obj-regexmapoptionsresult) + * [`fn withColor(value)`](#fn-regexmapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-regexmapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-regexmapoptionsresultwithindex) + * [`fn withText(value)`](#fn-regexmapoptionsresultwithtext) +* [`obj SpecialValueMap`](#obj-specialvaluemap) + * [`fn withOptions(value)`](#fn-specialvaluemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-specialvaluemapwithoptionsmixin) + * [`fn withType(value)`](#fn-specialvaluemapwithtype) + * [`obj options`](#obj-specialvaluemapoptions) + * [`fn withMatch(value)`](#fn-specialvaluemapoptionswithmatch) + * [`fn withPattern(value)`](#fn-specialvaluemapoptionswithpattern) + * [`fn withResult(value)`](#fn-specialvaluemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-specialvaluemapoptionswithresultmixin) + * [`obj result`](#obj-specialvaluemapoptionsresult) + * [`fn withColor(value)`](#fn-specialvaluemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-specialvaluemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-specialvaluemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-specialvaluemapoptionsresultwithtext) +* [`obj ValueMap`](#obj-valuemap) + * [`fn withOptions(value)`](#fn-valuemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-valuemapwithoptionsmixin) + * [`fn withType(value)`](#fn-valuemapwithtype) + +## Fields + +### obj RangeMap + + +#### fn RangeMap.withOptions + +```jsonnet +RangeMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withOptionsMixin + +```jsonnet +RangeMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withType + +```jsonnet +RangeMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RangeMap.options + + +##### fn RangeMap.options.withFrom + +```jsonnet +RangeMap.options.withFrom(value) +``` + +PARAMETERS: + +* **value** (`number`) + +to and from are `number | null` in current ts, really not sure what to do +##### fn RangeMap.options.withResult + +```jsonnet +RangeMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withResultMixin + +```jsonnet +RangeMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withTo + +```jsonnet +RangeMap.options.withTo(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +##### obj RangeMap.options.result + + +###### fn RangeMap.options.result.withColor + +```jsonnet +RangeMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIcon + +```jsonnet +RangeMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIndex + +```jsonnet +RangeMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RangeMap.options.result.withText + +```jsonnet +RangeMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj RegexMap + + +#### fn RegexMap.withOptions + +```jsonnet +RegexMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withOptionsMixin + +```jsonnet +RegexMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withType + +```jsonnet +RegexMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RegexMap.options + + +##### fn RegexMap.options.withPattern + +```jsonnet +RegexMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn RegexMap.options.withResult + +```jsonnet +RegexMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RegexMap.options.withResultMixin + +```jsonnet +RegexMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj RegexMap.options.result + + +###### fn RegexMap.options.result.withColor + +```jsonnet +RegexMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIcon + +```jsonnet +RegexMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIndex + +```jsonnet +RegexMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RegexMap.options.result.withText + +```jsonnet +RegexMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj SpecialValueMap + + +#### fn SpecialValueMap.withOptions + +```jsonnet +SpecialValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withOptionsMixin + +```jsonnet +SpecialValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withType + +```jsonnet +SpecialValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj SpecialValueMap.options + + +##### fn SpecialValueMap.options.withMatch + +```jsonnet +SpecialValueMap.options.withMatch(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"true"`, `"false"` + + +##### fn SpecialValueMap.options.withPattern + +```jsonnet +SpecialValueMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn SpecialValueMap.options.withResult + +```jsonnet +SpecialValueMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn SpecialValueMap.options.withResultMixin + +```jsonnet +SpecialValueMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj SpecialValueMap.options.result + + +###### fn SpecialValueMap.options.result.withColor + +```jsonnet +SpecialValueMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIcon + +```jsonnet +SpecialValueMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIndex + +```jsonnet +SpecialValueMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn SpecialValueMap.options.result.withText + +```jsonnet +SpecialValueMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj ValueMap + + +#### fn ValueMap.withOptions + +```jsonnet +ValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withOptionsMixin + +```jsonnet +ValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withType + +```jsonnet +ValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/logs/standardOptions/override.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/logs/standardOptions/override.md new file mode 100644 index 0000000000..154f3dbdac --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/logs/standardOptions/override.md @@ -0,0 +1,244 @@ +# override + +Overrides allow you to customize visualization settings for specific fields or +series. This is accomplished by adding an override rule that targets +a particular set of fields and that can each define multiple options. + +```jsonnet +override.byType.new('number') ++ override.byType.withPropertiesFromOptions( + panel.standardOptions.withDecimals(2) + + panel.standardOptions.withUnit('s') +) +``` + + +## Index + +* [`obj byName`](#obj-byname) + * [`fn new(value)`](#fn-bynamenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bynamewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bynamewithproperty) +* [`obj byQuery`](#obj-byquery) + * [`fn new(value)`](#fn-byquerynew) + * [`fn withPropertiesFromOptions(options)`](#fn-byquerywithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byquerywithproperty) +* [`obj byRegexp`](#obj-byregexp) + * [`fn new(value)`](#fn-byregexpnew) + * [`fn withPropertiesFromOptions(options)`](#fn-byregexpwithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byregexpwithproperty) +* [`obj byType`](#obj-bytype) + * [`fn new(value)`](#fn-bytypenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bytypewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bytypewithproperty) +* [`obj byValue`](#obj-byvalue) + * [`fn new(value)`](#fn-byvaluenew) + * [`fn withPropertiesFromOptions(options)`](#fn-byvaluewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byvaluewithproperty) + +## Fields + +### obj byName + + +#### fn byName.new + +```jsonnet +byName.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byName`. +#### fn byName.withPropertiesFromOptions + +```jsonnet +byName.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byName.withProperty + +```jsonnet +byName.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byQuery + + +#### fn byQuery.new + +```jsonnet +byQuery.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byQuery`. +#### fn byQuery.withPropertiesFromOptions + +```jsonnet +byQuery.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byQuery.withProperty + +```jsonnet +byQuery.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byRegexp + + +#### fn byRegexp.new + +```jsonnet +byRegexp.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byRegexp`. +#### fn byRegexp.withPropertiesFromOptions + +```jsonnet +byRegexp.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byRegexp.withProperty + +```jsonnet +byRegexp.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byType + + +#### fn byType.new + +```jsonnet +byType.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byType`. +#### fn byType.withPropertiesFromOptions + +```jsonnet +byType.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byType.withProperty + +```jsonnet +byType.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byValue + + +#### fn byValue.new + +```jsonnet +byValue.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byValue`. +#### fn byValue.withPropertiesFromOptions + +```jsonnet +byValue.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byValue.withProperty + +```jsonnet +byValue.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/logs/standardOptions/threshold/step.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/logs/standardOptions/threshold/step.md new file mode 100644 index 0000000000..dd2dd227ff --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/logs/standardOptions/threshold/step.md @@ -0,0 +1,60 @@ +# threshold.step + + + +## Index + +* [`fn withColor(value)`](#fn-withcolor) +* [`fn withIndex(value)`](#fn-withindex) +* [`fn withState(value)`](#fn-withstate) +* [`fn withValue(value)`](#fn-withvalue) + +## Fields + +### fn withColor + +```jsonnet +withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +### fn withIndex + +```jsonnet +withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Threshold index, an old property that is not needed an should only appear in older dashboards +### fn withState + +```jsonnet +withState(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO are the values here enumerable into a disjunction? +Some seem to be listed in typescript comment +### fn withValue + +```jsonnet +withValue(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +FIXME the corresponding typescript field is required/non-optional, but nulls currently appear here when serializing -Infinity to JSON \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/news/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/news/index.md new file mode 100644 index 0000000000..bdad9a6e8b --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/news/index.md @@ -0,0 +1,593 @@ +# news + +grafonnet.panel.news + +## Subpackages + +* [panelOptions.link](panelOptions/link.md) +* [queryOptions.transformation](queryOptions/transformation.md) +* [standardOptions.mapping](standardOptions/mapping.md) +* [standardOptions.override](standardOptions/override.md) +* [standardOptions.threshold.step](standardOptions/threshold/step.md) + +## Index + +* [`fn new(title)`](#fn-new) +* [`obj libraryPanel`](#obj-librarypanel) + * [`fn withName(value)`](#fn-librarypanelwithname) + * [`fn withUid(value)`](#fn-librarypanelwithuid) +* [`obj options`](#obj-options) + * [`fn withFeedUrl(value)`](#fn-optionswithfeedurl) + * [`fn withShowImage(value=true)`](#fn-optionswithshowimage) +* [`obj panelOptions`](#obj-paneloptions) + * [`fn withDescription(value)`](#fn-paneloptionswithdescription) + * [`fn withGridPos(h="null", w="null", x="null", y="null")`](#fn-paneloptionswithgridpos) + * [`fn withLinks(value)`](#fn-paneloptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-paneloptionswithlinksmixin) + * [`fn withRepeat(value)`](#fn-paneloptionswithrepeat) + * [`fn withRepeatDirection(value="h")`](#fn-paneloptionswithrepeatdirection) + * [`fn withTitle(value)`](#fn-paneloptionswithtitle) + * [`fn withTransparent(value=true)`](#fn-paneloptionswithtransparent) +* [`obj queryOptions`](#obj-queryoptions) + * [`fn withDatasource(type, uid)`](#fn-queryoptionswithdatasource) + * [`fn withDatasourceMixin(value)`](#fn-queryoptionswithdatasourcemixin) + * [`fn withInterval(value)`](#fn-queryoptionswithinterval) + * [`fn withMaxDataPoints(value)`](#fn-queryoptionswithmaxdatapoints) + * [`fn withTargets(value)`](#fn-queryoptionswithtargets) + * [`fn withTargetsMixin(value)`](#fn-queryoptionswithtargetsmixin) + * [`fn withTimeFrom(value)`](#fn-queryoptionswithtimefrom) + * [`fn withTimeShift(value)`](#fn-queryoptionswithtimeshift) + * [`fn withTransformations(value)`](#fn-queryoptionswithtransformations) + * [`fn withTransformationsMixin(value)`](#fn-queryoptionswithtransformationsmixin) +* [`obj standardOptions`](#obj-standardoptions) + * [`fn withDecimals(value)`](#fn-standardoptionswithdecimals) + * [`fn withDisplayName(value)`](#fn-standardoptionswithdisplayname) + * [`fn withFilterable(value=true)`](#fn-standardoptionswithfilterable) + * [`fn withLinks(value)`](#fn-standardoptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-standardoptionswithlinksmixin) + * [`fn withMappings(value)`](#fn-standardoptionswithmappings) + * [`fn withMappingsMixin(value)`](#fn-standardoptionswithmappingsmixin) + * [`fn withMax(value)`](#fn-standardoptionswithmax) + * [`fn withMin(value)`](#fn-standardoptionswithmin) + * [`fn withNoValue(value)`](#fn-standardoptionswithnovalue) + * [`fn withOverrides(value)`](#fn-standardoptionswithoverrides) + * [`fn withOverridesMixin(value)`](#fn-standardoptionswithoverridesmixin) + * [`fn withPath(value)`](#fn-standardoptionswithpath) + * [`fn withUnit(value)`](#fn-standardoptionswithunit) + * [`obj color`](#obj-standardoptionscolor) + * [`fn withFixedColor(value)`](#fn-standardoptionscolorwithfixedcolor) + * [`fn withMode(value)`](#fn-standardoptionscolorwithmode) + * [`fn withSeriesBy(value)`](#fn-standardoptionscolorwithseriesby) + * [`obj thresholds`](#obj-standardoptionsthresholds) + * [`fn withMode(value)`](#fn-standardoptionsthresholdswithmode) + * [`fn withSteps(value)`](#fn-standardoptionsthresholdswithsteps) + * [`fn withStepsMixin(value)`](#fn-standardoptionsthresholdswithstepsmixin) + +## Fields + +### fn new + +```jsonnet +new(title) +``` + +PARAMETERS: + +* **title** (`string`) + +Creates a new news panel with a title. +### obj libraryPanel + + +#### fn libraryPanel.withName + +```jsonnet +libraryPanel.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn libraryPanel.withUid + +```jsonnet +libraryPanel.withUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj options + + +#### fn options.withFeedUrl + +```jsonnet +options.withFeedUrl(value) +``` + +PARAMETERS: + +* **value** (`string`) + +empty/missing will default to grafana blog +#### fn options.withShowImage + +```jsonnet +options.withShowImage(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### obj panelOptions + + +#### fn panelOptions.withDescription + +```jsonnet +panelOptions.withDescription(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Description. +#### fn panelOptions.withGridPos + +```jsonnet +panelOptions.withGridPos(h="null", w="null", x="null", y="null") +``` + +PARAMETERS: + +* **h** (`number`) + - default value: `"null"` +* **w** (`number`) + - default value: `"null"` +* **x** (`number`) + - default value: `"null"` +* **y** (`number`) + - default value: `"null"` + +`withGridPos` configures the height, width and xy coordinates of the panel. Also see `grafonnet.util.grid` for helper functions to calculate these fields. + +All arguments default to `null`, which means they will remain unchanged or unset. + +#### fn panelOptions.withLinks + +```jsonnet +panelOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withLinksMixin + +```jsonnet +panelOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withRepeat + +```jsonnet +panelOptions.withRepeat(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of template variable to repeat for. +#### fn panelOptions.withRepeatDirection + +```jsonnet +panelOptions.withRepeatDirection(value="h") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"h"` + - valid values: `"h"`, `"v"` + +Direction to repeat in if 'repeat' is set. +"h" for horizontal, "v" for vertical. +TODO this is probably optional +#### fn panelOptions.withTitle + +```jsonnet +panelOptions.withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Panel title. +#### fn panelOptions.withTransparent + +```jsonnet +panelOptions.withTransparent(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Whether to display the panel without a background. +### obj queryOptions + + +#### fn queryOptions.withDatasource + +```jsonnet +queryOptions.withDatasource(type, uid) +``` + +PARAMETERS: + +* **type** (`string`) +* **uid** (`string`) + +`withDatasource` sets the datasource for all queries in a panel. + +The default datasource for a panel is set to 'Mixed datasource' so panels can be datasource agnostic, which is a lot more interesting from a reusability standpoint. Note that this requires query targets to explicitly set datasource for the same reason. + +#### fn queryOptions.withDatasourceMixin + +```jsonnet +queryOptions.withDatasourceMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +The datasource used in all targets. +#### fn queryOptions.withInterval + +```jsonnet +queryOptions.withInterval(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withMaxDataPoints + +```jsonnet +queryOptions.withMaxDataPoints(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +#### fn queryOptions.withTargets + +```jsonnet +queryOptions.withTargets(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTargetsMixin + +```jsonnet +queryOptions.withTargetsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTimeFrom + +```jsonnet +queryOptions.withTimeFrom(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTimeShift + +```jsonnet +queryOptions.withTimeShift(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTransformations + +```jsonnet +queryOptions.withTransformations(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn queryOptions.withTransformationsMixin + +```jsonnet +queryOptions.withTransformationsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### obj standardOptions + + +#### fn standardOptions.withDecimals + +```jsonnet +standardOptions.withDecimals(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Significant digits (for display) +#### fn standardOptions.withDisplayName + +```jsonnet +standardOptions.withDisplayName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The display value for this field. This supports template variables blank is auto +#### fn standardOptions.withFilterable + +```jsonnet +standardOptions.withFilterable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +True if data source field supports ad-hoc filters +#### fn standardOptions.withLinks + +```jsonnet +standardOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withLinksMixin + +```jsonnet +standardOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withMappings + +```jsonnet +standardOptions.withMappings(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMappingsMixin + +```jsonnet +standardOptions.withMappingsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMax + +```jsonnet +standardOptions.withMax(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withMin + +```jsonnet +standardOptions.withMin(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withNoValue + +```jsonnet +standardOptions.withNoValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Alternative to empty string +#### fn standardOptions.withOverrides + +```jsonnet +standardOptions.withOverrides(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withOverridesMixin + +```jsonnet +standardOptions.withOverridesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withPath + +```jsonnet +standardOptions.withPath(value) +``` + +PARAMETERS: + +* **value** (`string`) + +An explicit path to the field in the datasource. When the frame meta includes a path, +This will default to `${frame.meta.path}/${field.name} + +When defined, this value can be used as an identifier within the datasource scope, and +may be used to update the results +#### fn standardOptions.withUnit + +```jsonnet +standardOptions.withUnit(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Numeric Options +#### obj standardOptions.color + + +##### fn standardOptions.color.withFixedColor + +```jsonnet +standardOptions.color.withFixedColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Stores the fixed color value if mode is fixed +##### fn standardOptions.color.withMode + +```jsonnet +standardOptions.color.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The main color scheme mode +##### fn standardOptions.color.withSeriesBy + +```jsonnet +standardOptions.color.withSeriesBy(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"min"`, `"max"`, `"last"` + +TODO docs +#### obj standardOptions.thresholds + + +##### fn standardOptions.thresholds.withMode + +```jsonnet +standardOptions.thresholds.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"absolute"`, `"percentage"` + + +##### fn standardOptions.thresholds.withSteps + +```jsonnet +standardOptions.thresholds.withSteps(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity +##### fn standardOptions.thresholds.withStepsMixin + +```jsonnet +standardOptions.thresholds.withStepsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/news/panelOptions/link.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/news/panelOptions/link.md new file mode 100644 index 0000000000..106f9d2edb --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/news/panelOptions/link.md @@ -0,0 +1,145 @@ +# link + + + +## Index + +* [`fn withAsDropdown(value=true)`](#fn-withasdropdown) +* [`fn withIcon(value)`](#fn-withicon) +* [`fn withIncludeVars(value=true)`](#fn-withincludevars) +* [`fn withKeepTime(value=true)`](#fn-withkeeptime) +* [`fn withTags(value)`](#fn-withtags) +* [`fn withTagsMixin(value)`](#fn-withtagsmixin) +* [`fn withTargetBlank(value=true)`](#fn-withtargetblank) +* [`fn withTitle(value)`](#fn-withtitle) +* [`fn withTooltip(value)`](#fn-withtooltip) +* [`fn withType(value)`](#fn-withtype) +* [`fn withUrl(value)`](#fn-withurl) + +## Fields + +### fn withAsDropdown + +```jsonnet +withAsDropdown(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withIcon + +```jsonnet +withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withIncludeVars + +```jsonnet +withIncludeVars(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withKeepTime + +```jsonnet +withKeepTime(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTags + +```jsonnet +withTags(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTagsMixin + +```jsonnet +withTagsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTargetBlank + +```jsonnet +withTargetBlank(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTitle + +```jsonnet +withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withTooltip + +```jsonnet +withTooltip(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withType + +```jsonnet +withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"link"`, `"dashboards"` + +TODO docs +### fn withUrl + +```jsonnet +withUrl(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/news/queryOptions/transformation.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/news/queryOptions/transformation.md new file mode 100644 index 0000000000..dc832f653d --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/news/queryOptions/transformation.md @@ -0,0 +1,99 @@ +# transformation + + + +## Index + +* [`fn withDisabled(value=true)`](#fn-withdisabled) +* [`fn withFilter(value)`](#fn-withfilter) +* [`fn withFilterMixin(value)`](#fn-withfiltermixin) +* [`fn withId(value)`](#fn-withid) +* [`fn withOptions(value)`](#fn-withoptions) +* [`obj filter`](#obj-filter) + * [`fn withId(value="")`](#fn-filterwithid) + * [`fn withOptions(value)`](#fn-filterwithoptions) + +## Fields + +### fn withDisabled + +```jsonnet +withDisabled(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Disabled transformations are skipped +### fn withFilter + +```jsonnet +withFilter(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withFilterMixin + +```jsonnet +withFilterMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withId + +```jsonnet +withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Unique identifier of transformer +### fn withOptions + +```jsonnet +withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Options to be passed to the transformer +Valid options depend on the transformer id +### obj filter + + +#### fn filter.withId + +```jsonnet +filter.withId(value="") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `""` + + +#### fn filter.withOptions + +```jsonnet +filter.withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/news/standardOptions/mapping.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/news/standardOptions/mapping.md new file mode 100644 index 0000000000..93296972e8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/news/standardOptions/mapping.md @@ -0,0 +1,469 @@ +# mapping + + + +## Index + +* [`obj RangeMap`](#obj-rangemap) + * [`fn withOptions(value)`](#fn-rangemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-rangemapwithoptionsmixin) + * [`fn withType(value)`](#fn-rangemapwithtype) + * [`obj options`](#obj-rangemapoptions) + * [`fn withFrom(value)`](#fn-rangemapoptionswithfrom) + * [`fn withResult(value)`](#fn-rangemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-rangemapoptionswithresultmixin) + * [`fn withTo(value)`](#fn-rangemapoptionswithto) + * [`obj result`](#obj-rangemapoptionsresult) + * [`fn withColor(value)`](#fn-rangemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-rangemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-rangemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-rangemapoptionsresultwithtext) +* [`obj RegexMap`](#obj-regexmap) + * [`fn withOptions(value)`](#fn-regexmapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-regexmapwithoptionsmixin) + * [`fn withType(value)`](#fn-regexmapwithtype) + * [`obj options`](#obj-regexmapoptions) + * [`fn withPattern(value)`](#fn-regexmapoptionswithpattern) + * [`fn withResult(value)`](#fn-regexmapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-regexmapoptionswithresultmixin) + * [`obj result`](#obj-regexmapoptionsresult) + * [`fn withColor(value)`](#fn-regexmapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-regexmapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-regexmapoptionsresultwithindex) + * [`fn withText(value)`](#fn-regexmapoptionsresultwithtext) +* [`obj SpecialValueMap`](#obj-specialvaluemap) + * [`fn withOptions(value)`](#fn-specialvaluemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-specialvaluemapwithoptionsmixin) + * [`fn withType(value)`](#fn-specialvaluemapwithtype) + * [`obj options`](#obj-specialvaluemapoptions) + * [`fn withMatch(value)`](#fn-specialvaluemapoptionswithmatch) + * [`fn withPattern(value)`](#fn-specialvaluemapoptionswithpattern) + * [`fn withResult(value)`](#fn-specialvaluemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-specialvaluemapoptionswithresultmixin) + * [`obj result`](#obj-specialvaluemapoptionsresult) + * [`fn withColor(value)`](#fn-specialvaluemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-specialvaluemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-specialvaluemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-specialvaluemapoptionsresultwithtext) +* [`obj ValueMap`](#obj-valuemap) + * [`fn withOptions(value)`](#fn-valuemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-valuemapwithoptionsmixin) + * [`fn withType(value)`](#fn-valuemapwithtype) + +## Fields + +### obj RangeMap + + +#### fn RangeMap.withOptions + +```jsonnet +RangeMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withOptionsMixin + +```jsonnet +RangeMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withType + +```jsonnet +RangeMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RangeMap.options + + +##### fn RangeMap.options.withFrom + +```jsonnet +RangeMap.options.withFrom(value) +``` + +PARAMETERS: + +* **value** (`number`) + +to and from are `number | null` in current ts, really not sure what to do +##### fn RangeMap.options.withResult + +```jsonnet +RangeMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withResultMixin + +```jsonnet +RangeMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withTo + +```jsonnet +RangeMap.options.withTo(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +##### obj RangeMap.options.result + + +###### fn RangeMap.options.result.withColor + +```jsonnet +RangeMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIcon + +```jsonnet +RangeMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIndex + +```jsonnet +RangeMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RangeMap.options.result.withText + +```jsonnet +RangeMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj RegexMap + + +#### fn RegexMap.withOptions + +```jsonnet +RegexMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withOptionsMixin + +```jsonnet +RegexMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withType + +```jsonnet +RegexMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RegexMap.options + + +##### fn RegexMap.options.withPattern + +```jsonnet +RegexMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn RegexMap.options.withResult + +```jsonnet +RegexMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RegexMap.options.withResultMixin + +```jsonnet +RegexMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj RegexMap.options.result + + +###### fn RegexMap.options.result.withColor + +```jsonnet +RegexMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIcon + +```jsonnet +RegexMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIndex + +```jsonnet +RegexMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RegexMap.options.result.withText + +```jsonnet +RegexMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj SpecialValueMap + + +#### fn SpecialValueMap.withOptions + +```jsonnet +SpecialValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withOptionsMixin + +```jsonnet +SpecialValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withType + +```jsonnet +SpecialValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj SpecialValueMap.options + + +##### fn SpecialValueMap.options.withMatch + +```jsonnet +SpecialValueMap.options.withMatch(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"true"`, `"false"` + + +##### fn SpecialValueMap.options.withPattern + +```jsonnet +SpecialValueMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn SpecialValueMap.options.withResult + +```jsonnet +SpecialValueMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn SpecialValueMap.options.withResultMixin + +```jsonnet +SpecialValueMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj SpecialValueMap.options.result + + +###### fn SpecialValueMap.options.result.withColor + +```jsonnet +SpecialValueMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIcon + +```jsonnet +SpecialValueMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIndex + +```jsonnet +SpecialValueMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn SpecialValueMap.options.result.withText + +```jsonnet +SpecialValueMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj ValueMap + + +#### fn ValueMap.withOptions + +```jsonnet +ValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withOptionsMixin + +```jsonnet +ValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withType + +```jsonnet +ValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/news/standardOptions/override.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/news/standardOptions/override.md new file mode 100644 index 0000000000..154f3dbdac --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/news/standardOptions/override.md @@ -0,0 +1,244 @@ +# override + +Overrides allow you to customize visualization settings for specific fields or +series. This is accomplished by adding an override rule that targets +a particular set of fields and that can each define multiple options. + +```jsonnet +override.byType.new('number') ++ override.byType.withPropertiesFromOptions( + panel.standardOptions.withDecimals(2) + + panel.standardOptions.withUnit('s') +) +``` + + +## Index + +* [`obj byName`](#obj-byname) + * [`fn new(value)`](#fn-bynamenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bynamewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bynamewithproperty) +* [`obj byQuery`](#obj-byquery) + * [`fn new(value)`](#fn-byquerynew) + * [`fn withPropertiesFromOptions(options)`](#fn-byquerywithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byquerywithproperty) +* [`obj byRegexp`](#obj-byregexp) + * [`fn new(value)`](#fn-byregexpnew) + * [`fn withPropertiesFromOptions(options)`](#fn-byregexpwithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byregexpwithproperty) +* [`obj byType`](#obj-bytype) + * [`fn new(value)`](#fn-bytypenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bytypewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bytypewithproperty) +* [`obj byValue`](#obj-byvalue) + * [`fn new(value)`](#fn-byvaluenew) + * [`fn withPropertiesFromOptions(options)`](#fn-byvaluewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byvaluewithproperty) + +## Fields + +### obj byName + + +#### fn byName.new + +```jsonnet +byName.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byName`. +#### fn byName.withPropertiesFromOptions + +```jsonnet +byName.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byName.withProperty + +```jsonnet +byName.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byQuery + + +#### fn byQuery.new + +```jsonnet +byQuery.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byQuery`. +#### fn byQuery.withPropertiesFromOptions + +```jsonnet +byQuery.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byQuery.withProperty + +```jsonnet +byQuery.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byRegexp + + +#### fn byRegexp.new + +```jsonnet +byRegexp.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byRegexp`. +#### fn byRegexp.withPropertiesFromOptions + +```jsonnet +byRegexp.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byRegexp.withProperty + +```jsonnet +byRegexp.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byType + + +#### fn byType.new + +```jsonnet +byType.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byType`. +#### fn byType.withPropertiesFromOptions + +```jsonnet +byType.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byType.withProperty + +```jsonnet +byType.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byValue + + +#### fn byValue.new + +```jsonnet +byValue.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byValue`. +#### fn byValue.withPropertiesFromOptions + +```jsonnet +byValue.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byValue.withProperty + +```jsonnet +byValue.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/news/standardOptions/threshold/step.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/news/standardOptions/threshold/step.md new file mode 100644 index 0000000000..dd2dd227ff --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/news/standardOptions/threshold/step.md @@ -0,0 +1,60 @@ +# threshold.step + + + +## Index + +* [`fn withColor(value)`](#fn-withcolor) +* [`fn withIndex(value)`](#fn-withindex) +* [`fn withState(value)`](#fn-withstate) +* [`fn withValue(value)`](#fn-withvalue) + +## Fields + +### fn withColor + +```jsonnet +withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +### fn withIndex + +```jsonnet +withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Threshold index, an old property that is not needed an should only appear in older dashboards +### fn withState + +```jsonnet +withState(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO are the values here enumerable into a disjunction? +Some seem to be listed in typescript comment +### fn withValue + +```jsonnet +withValue(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +FIXME the corresponding typescript field is required/non-optional, but nulls currently appear here when serializing -Infinity to JSON \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/nodeGraph/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/nodeGraph/index.md new file mode 100644 index 0000000000..694775f663 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/nodeGraph/index.md @@ -0,0 +1,697 @@ +# nodeGraph + +grafonnet.panel.nodeGraph + +## Subpackages + +* [options.nodes.arcs](options/nodes/arcs.md) +* [panelOptions.link](panelOptions/link.md) +* [queryOptions.transformation](queryOptions/transformation.md) +* [standardOptions.mapping](standardOptions/mapping.md) +* [standardOptions.override](standardOptions/override.md) +* [standardOptions.threshold.step](standardOptions/threshold/step.md) + +## Index + +* [`fn new(title)`](#fn-new) +* [`obj libraryPanel`](#obj-librarypanel) + * [`fn withName(value)`](#fn-librarypanelwithname) + * [`fn withUid(value)`](#fn-librarypanelwithuid) +* [`obj options`](#obj-options) + * [`fn withEdges(value)`](#fn-optionswithedges) + * [`fn withEdgesMixin(value)`](#fn-optionswithedgesmixin) + * [`fn withNodes(value)`](#fn-optionswithnodes) + * [`fn withNodesMixin(value)`](#fn-optionswithnodesmixin) + * [`obj edges`](#obj-optionsedges) + * [`fn withMainStatUnit(value)`](#fn-optionsedgeswithmainstatunit) + * [`fn withSecondaryStatUnit(value)`](#fn-optionsedgeswithsecondarystatunit) + * [`obj nodes`](#obj-optionsnodes) + * [`fn withArcs(value)`](#fn-optionsnodeswitharcs) + * [`fn withArcsMixin(value)`](#fn-optionsnodeswitharcsmixin) + * [`fn withMainStatUnit(value)`](#fn-optionsnodeswithmainstatunit) + * [`fn withSecondaryStatUnit(value)`](#fn-optionsnodeswithsecondarystatunit) +* [`obj panelOptions`](#obj-paneloptions) + * [`fn withDescription(value)`](#fn-paneloptionswithdescription) + * [`fn withGridPos(h="null", w="null", x="null", y="null")`](#fn-paneloptionswithgridpos) + * [`fn withLinks(value)`](#fn-paneloptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-paneloptionswithlinksmixin) + * [`fn withRepeat(value)`](#fn-paneloptionswithrepeat) + * [`fn withRepeatDirection(value="h")`](#fn-paneloptionswithrepeatdirection) + * [`fn withTitle(value)`](#fn-paneloptionswithtitle) + * [`fn withTransparent(value=true)`](#fn-paneloptionswithtransparent) +* [`obj queryOptions`](#obj-queryoptions) + * [`fn withDatasource(type, uid)`](#fn-queryoptionswithdatasource) + * [`fn withDatasourceMixin(value)`](#fn-queryoptionswithdatasourcemixin) + * [`fn withInterval(value)`](#fn-queryoptionswithinterval) + * [`fn withMaxDataPoints(value)`](#fn-queryoptionswithmaxdatapoints) + * [`fn withTargets(value)`](#fn-queryoptionswithtargets) + * [`fn withTargetsMixin(value)`](#fn-queryoptionswithtargetsmixin) + * [`fn withTimeFrom(value)`](#fn-queryoptionswithtimefrom) + * [`fn withTimeShift(value)`](#fn-queryoptionswithtimeshift) + * [`fn withTransformations(value)`](#fn-queryoptionswithtransformations) + * [`fn withTransformationsMixin(value)`](#fn-queryoptionswithtransformationsmixin) +* [`obj standardOptions`](#obj-standardoptions) + * [`fn withDecimals(value)`](#fn-standardoptionswithdecimals) + * [`fn withDisplayName(value)`](#fn-standardoptionswithdisplayname) + * [`fn withFilterable(value=true)`](#fn-standardoptionswithfilterable) + * [`fn withLinks(value)`](#fn-standardoptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-standardoptionswithlinksmixin) + * [`fn withMappings(value)`](#fn-standardoptionswithmappings) + * [`fn withMappingsMixin(value)`](#fn-standardoptionswithmappingsmixin) + * [`fn withMax(value)`](#fn-standardoptionswithmax) + * [`fn withMin(value)`](#fn-standardoptionswithmin) + * [`fn withNoValue(value)`](#fn-standardoptionswithnovalue) + * [`fn withOverrides(value)`](#fn-standardoptionswithoverrides) + * [`fn withOverridesMixin(value)`](#fn-standardoptionswithoverridesmixin) + * [`fn withPath(value)`](#fn-standardoptionswithpath) + * [`fn withUnit(value)`](#fn-standardoptionswithunit) + * [`obj color`](#obj-standardoptionscolor) + * [`fn withFixedColor(value)`](#fn-standardoptionscolorwithfixedcolor) + * [`fn withMode(value)`](#fn-standardoptionscolorwithmode) + * [`fn withSeriesBy(value)`](#fn-standardoptionscolorwithseriesby) + * [`obj thresholds`](#obj-standardoptionsthresholds) + * [`fn withMode(value)`](#fn-standardoptionsthresholdswithmode) + * [`fn withSteps(value)`](#fn-standardoptionsthresholdswithsteps) + * [`fn withStepsMixin(value)`](#fn-standardoptionsthresholdswithstepsmixin) + +## Fields + +### fn new + +```jsonnet +new(title) +``` + +PARAMETERS: + +* **title** (`string`) + +Creates a new nodeGraph panel with a title. +### obj libraryPanel + + +#### fn libraryPanel.withName + +```jsonnet +libraryPanel.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn libraryPanel.withUid + +```jsonnet +libraryPanel.withUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj options + + +#### fn options.withEdges + +```jsonnet +options.withEdges(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn options.withEdgesMixin + +```jsonnet +options.withEdgesMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn options.withNodes + +```jsonnet +options.withNodes(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn options.withNodesMixin + +```jsonnet +options.withNodesMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### obj options.edges + + +##### fn options.edges.withMainStatUnit + +```jsonnet +options.edges.withMainStatUnit(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Unit for the main stat to override what ever is set in the data frame. +##### fn options.edges.withSecondaryStatUnit + +```jsonnet +options.edges.withSecondaryStatUnit(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Unit for the secondary stat to override what ever is set in the data frame. +#### obj options.nodes + + +##### fn options.nodes.withArcs + +```jsonnet +options.nodes.withArcs(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Define which fields are shown as part of the node arc (colored circle around the node). +##### fn options.nodes.withArcsMixin + +```jsonnet +options.nodes.withArcsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Define which fields are shown as part of the node arc (colored circle around the node). +##### fn options.nodes.withMainStatUnit + +```jsonnet +options.nodes.withMainStatUnit(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Unit for the main stat to override what ever is set in the data frame. +##### fn options.nodes.withSecondaryStatUnit + +```jsonnet +options.nodes.withSecondaryStatUnit(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Unit for the secondary stat to override what ever is set in the data frame. +### obj panelOptions + + +#### fn panelOptions.withDescription + +```jsonnet +panelOptions.withDescription(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Description. +#### fn panelOptions.withGridPos + +```jsonnet +panelOptions.withGridPos(h="null", w="null", x="null", y="null") +``` + +PARAMETERS: + +* **h** (`number`) + - default value: `"null"` +* **w** (`number`) + - default value: `"null"` +* **x** (`number`) + - default value: `"null"` +* **y** (`number`) + - default value: `"null"` + +`withGridPos` configures the height, width and xy coordinates of the panel. Also see `grafonnet.util.grid` for helper functions to calculate these fields. + +All arguments default to `null`, which means they will remain unchanged or unset. + +#### fn panelOptions.withLinks + +```jsonnet +panelOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withLinksMixin + +```jsonnet +panelOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withRepeat + +```jsonnet +panelOptions.withRepeat(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of template variable to repeat for. +#### fn panelOptions.withRepeatDirection + +```jsonnet +panelOptions.withRepeatDirection(value="h") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"h"` + - valid values: `"h"`, `"v"` + +Direction to repeat in if 'repeat' is set. +"h" for horizontal, "v" for vertical. +TODO this is probably optional +#### fn panelOptions.withTitle + +```jsonnet +panelOptions.withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Panel title. +#### fn panelOptions.withTransparent + +```jsonnet +panelOptions.withTransparent(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Whether to display the panel without a background. +### obj queryOptions + + +#### fn queryOptions.withDatasource + +```jsonnet +queryOptions.withDatasource(type, uid) +``` + +PARAMETERS: + +* **type** (`string`) +* **uid** (`string`) + +`withDatasource` sets the datasource for all queries in a panel. + +The default datasource for a panel is set to 'Mixed datasource' so panels can be datasource agnostic, which is a lot more interesting from a reusability standpoint. Note that this requires query targets to explicitly set datasource for the same reason. + +#### fn queryOptions.withDatasourceMixin + +```jsonnet +queryOptions.withDatasourceMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +The datasource used in all targets. +#### fn queryOptions.withInterval + +```jsonnet +queryOptions.withInterval(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withMaxDataPoints + +```jsonnet +queryOptions.withMaxDataPoints(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +#### fn queryOptions.withTargets + +```jsonnet +queryOptions.withTargets(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTargetsMixin + +```jsonnet +queryOptions.withTargetsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTimeFrom + +```jsonnet +queryOptions.withTimeFrom(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTimeShift + +```jsonnet +queryOptions.withTimeShift(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTransformations + +```jsonnet +queryOptions.withTransformations(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn queryOptions.withTransformationsMixin + +```jsonnet +queryOptions.withTransformationsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### obj standardOptions + + +#### fn standardOptions.withDecimals + +```jsonnet +standardOptions.withDecimals(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Significant digits (for display) +#### fn standardOptions.withDisplayName + +```jsonnet +standardOptions.withDisplayName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The display value for this field. This supports template variables blank is auto +#### fn standardOptions.withFilterable + +```jsonnet +standardOptions.withFilterable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +True if data source field supports ad-hoc filters +#### fn standardOptions.withLinks + +```jsonnet +standardOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withLinksMixin + +```jsonnet +standardOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withMappings + +```jsonnet +standardOptions.withMappings(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMappingsMixin + +```jsonnet +standardOptions.withMappingsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMax + +```jsonnet +standardOptions.withMax(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withMin + +```jsonnet +standardOptions.withMin(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withNoValue + +```jsonnet +standardOptions.withNoValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Alternative to empty string +#### fn standardOptions.withOverrides + +```jsonnet +standardOptions.withOverrides(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withOverridesMixin + +```jsonnet +standardOptions.withOverridesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withPath + +```jsonnet +standardOptions.withPath(value) +``` + +PARAMETERS: + +* **value** (`string`) + +An explicit path to the field in the datasource. When the frame meta includes a path, +This will default to `${frame.meta.path}/${field.name} + +When defined, this value can be used as an identifier within the datasource scope, and +may be used to update the results +#### fn standardOptions.withUnit + +```jsonnet +standardOptions.withUnit(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Numeric Options +#### obj standardOptions.color + + +##### fn standardOptions.color.withFixedColor + +```jsonnet +standardOptions.color.withFixedColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Stores the fixed color value if mode is fixed +##### fn standardOptions.color.withMode + +```jsonnet +standardOptions.color.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The main color scheme mode +##### fn standardOptions.color.withSeriesBy + +```jsonnet +standardOptions.color.withSeriesBy(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"min"`, `"max"`, `"last"` + +TODO docs +#### obj standardOptions.thresholds + + +##### fn standardOptions.thresholds.withMode + +```jsonnet +standardOptions.thresholds.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"absolute"`, `"percentage"` + + +##### fn standardOptions.thresholds.withSteps + +```jsonnet +standardOptions.thresholds.withSteps(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity +##### fn standardOptions.thresholds.withStepsMixin + +```jsonnet +standardOptions.thresholds.withStepsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/nodeGraph/options/nodes/arcs.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/nodeGraph/options/nodes/arcs.md new file mode 100644 index 0000000000..f80fe24133 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/nodeGraph/options/nodes/arcs.md @@ -0,0 +1,33 @@ +# arcs + + + +## Index + +* [`fn withColor(value)`](#fn-withcolor) +* [`fn withField(value)`](#fn-withfield) + +## Fields + +### fn withColor + +```jsonnet +withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The color of the arc. +### fn withField + +```jsonnet +withField(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Field from which to get the value. Values should be less than 1, representing fraction of a circle. \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/nodeGraph/panelOptions/link.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/nodeGraph/panelOptions/link.md new file mode 100644 index 0000000000..106f9d2edb --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/nodeGraph/panelOptions/link.md @@ -0,0 +1,145 @@ +# link + + + +## Index + +* [`fn withAsDropdown(value=true)`](#fn-withasdropdown) +* [`fn withIcon(value)`](#fn-withicon) +* [`fn withIncludeVars(value=true)`](#fn-withincludevars) +* [`fn withKeepTime(value=true)`](#fn-withkeeptime) +* [`fn withTags(value)`](#fn-withtags) +* [`fn withTagsMixin(value)`](#fn-withtagsmixin) +* [`fn withTargetBlank(value=true)`](#fn-withtargetblank) +* [`fn withTitle(value)`](#fn-withtitle) +* [`fn withTooltip(value)`](#fn-withtooltip) +* [`fn withType(value)`](#fn-withtype) +* [`fn withUrl(value)`](#fn-withurl) + +## Fields + +### fn withAsDropdown + +```jsonnet +withAsDropdown(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withIcon + +```jsonnet +withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withIncludeVars + +```jsonnet +withIncludeVars(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withKeepTime + +```jsonnet +withKeepTime(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTags + +```jsonnet +withTags(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTagsMixin + +```jsonnet +withTagsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTargetBlank + +```jsonnet +withTargetBlank(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTitle + +```jsonnet +withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withTooltip + +```jsonnet +withTooltip(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withType + +```jsonnet +withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"link"`, `"dashboards"` + +TODO docs +### fn withUrl + +```jsonnet +withUrl(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/nodeGraph/queryOptions/transformation.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/nodeGraph/queryOptions/transformation.md new file mode 100644 index 0000000000..dc832f653d --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/nodeGraph/queryOptions/transformation.md @@ -0,0 +1,99 @@ +# transformation + + + +## Index + +* [`fn withDisabled(value=true)`](#fn-withdisabled) +* [`fn withFilter(value)`](#fn-withfilter) +* [`fn withFilterMixin(value)`](#fn-withfiltermixin) +* [`fn withId(value)`](#fn-withid) +* [`fn withOptions(value)`](#fn-withoptions) +* [`obj filter`](#obj-filter) + * [`fn withId(value="")`](#fn-filterwithid) + * [`fn withOptions(value)`](#fn-filterwithoptions) + +## Fields + +### fn withDisabled + +```jsonnet +withDisabled(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Disabled transformations are skipped +### fn withFilter + +```jsonnet +withFilter(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withFilterMixin + +```jsonnet +withFilterMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withId + +```jsonnet +withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Unique identifier of transformer +### fn withOptions + +```jsonnet +withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Options to be passed to the transformer +Valid options depend on the transformer id +### obj filter + + +#### fn filter.withId + +```jsonnet +filter.withId(value="") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `""` + + +#### fn filter.withOptions + +```jsonnet +filter.withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/nodeGraph/standardOptions/mapping.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/nodeGraph/standardOptions/mapping.md new file mode 100644 index 0000000000..93296972e8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/nodeGraph/standardOptions/mapping.md @@ -0,0 +1,469 @@ +# mapping + + + +## Index + +* [`obj RangeMap`](#obj-rangemap) + * [`fn withOptions(value)`](#fn-rangemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-rangemapwithoptionsmixin) + * [`fn withType(value)`](#fn-rangemapwithtype) + * [`obj options`](#obj-rangemapoptions) + * [`fn withFrom(value)`](#fn-rangemapoptionswithfrom) + * [`fn withResult(value)`](#fn-rangemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-rangemapoptionswithresultmixin) + * [`fn withTo(value)`](#fn-rangemapoptionswithto) + * [`obj result`](#obj-rangemapoptionsresult) + * [`fn withColor(value)`](#fn-rangemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-rangemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-rangemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-rangemapoptionsresultwithtext) +* [`obj RegexMap`](#obj-regexmap) + * [`fn withOptions(value)`](#fn-regexmapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-regexmapwithoptionsmixin) + * [`fn withType(value)`](#fn-regexmapwithtype) + * [`obj options`](#obj-regexmapoptions) + * [`fn withPattern(value)`](#fn-regexmapoptionswithpattern) + * [`fn withResult(value)`](#fn-regexmapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-regexmapoptionswithresultmixin) + * [`obj result`](#obj-regexmapoptionsresult) + * [`fn withColor(value)`](#fn-regexmapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-regexmapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-regexmapoptionsresultwithindex) + * [`fn withText(value)`](#fn-regexmapoptionsresultwithtext) +* [`obj SpecialValueMap`](#obj-specialvaluemap) + * [`fn withOptions(value)`](#fn-specialvaluemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-specialvaluemapwithoptionsmixin) + * [`fn withType(value)`](#fn-specialvaluemapwithtype) + * [`obj options`](#obj-specialvaluemapoptions) + * [`fn withMatch(value)`](#fn-specialvaluemapoptionswithmatch) + * [`fn withPattern(value)`](#fn-specialvaluemapoptionswithpattern) + * [`fn withResult(value)`](#fn-specialvaluemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-specialvaluemapoptionswithresultmixin) + * [`obj result`](#obj-specialvaluemapoptionsresult) + * [`fn withColor(value)`](#fn-specialvaluemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-specialvaluemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-specialvaluemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-specialvaluemapoptionsresultwithtext) +* [`obj ValueMap`](#obj-valuemap) + * [`fn withOptions(value)`](#fn-valuemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-valuemapwithoptionsmixin) + * [`fn withType(value)`](#fn-valuemapwithtype) + +## Fields + +### obj RangeMap + + +#### fn RangeMap.withOptions + +```jsonnet +RangeMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withOptionsMixin + +```jsonnet +RangeMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withType + +```jsonnet +RangeMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RangeMap.options + + +##### fn RangeMap.options.withFrom + +```jsonnet +RangeMap.options.withFrom(value) +``` + +PARAMETERS: + +* **value** (`number`) + +to and from are `number | null` in current ts, really not sure what to do +##### fn RangeMap.options.withResult + +```jsonnet +RangeMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withResultMixin + +```jsonnet +RangeMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withTo + +```jsonnet +RangeMap.options.withTo(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +##### obj RangeMap.options.result + + +###### fn RangeMap.options.result.withColor + +```jsonnet +RangeMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIcon + +```jsonnet +RangeMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIndex + +```jsonnet +RangeMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RangeMap.options.result.withText + +```jsonnet +RangeMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj RegexMap + + +#### fn RegexMap.withOptions + +```jsonnet +RegexMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withOptionsMixin + +```jsonnet +RegexMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withType + +```jsonnet +RegexMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RegexMap.options + + +##### fn RegexMap.options.withPattern + +```jsonnet +RegexMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn RegexMap.options.withResult + +```jsonnet +RegexMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RegexMap.options.withResultMixin + +```jsonnet +RegexMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj RegexMap.options.result + + +###### fn RegexMap.options.result.withColor + +```jsonnet +RegexMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIcon + +```jsonnet +RegexMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIndex + +```jsonnet +RegexMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RegexMap.options.result.withText + +```jsonnet +RegexMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj SpecialValueMap + + +#### fn SpecialValueMap.withOptions + +```jsonnet +SpecialValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withOptionsMixin + +```jsonnet +SpecialValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withType + +```jsonnet +SpecialValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj SpecialValueMap.options + + +##### fn SpecialValueMap.options.withMatch + +```jsonnet +SpecialValueMap.options.withMatch(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"true"`, `"false"` + + +##### fn SpecialValueMap.options.withPattern + +```jsonnet +SpecialValueMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn SpecialValueMap.options.withResult + +```jsonnet +SpecialValueMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn SpecialValueMap.options.withResultMixin + +```jsonnet +SpecialValueMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj SpecialValueMap.options.result + + +###### fn SpecialValueMap.options.result.withColor + +```jsonnet +SpecialValueMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIcon + +```jsonnet +SpecialValueMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIndex + +```jsonnet +SpecialValueMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn SpecialValueMap.options.result.withText + +```jsonnet +SpecialValueMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj ValueMap + + +#### fn ValueMap.withOptions + +```jsonnet +ValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withOptionsMixin + +```jsonnet +ValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withType + +```jsonnet +ValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/nodeGraph/standardOptions/override.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/nodeGraph/standardOptions/override.md new file mode 100644 index 0000000000..154f3dbdac --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/nodeGraph/standardOptions/override.md @@ -0,0 +1,244 @@ +# override + +Overrides allow you to customize visualization settings for specific fields or +series. This is accomplished by adding an override rule that targets +a particular set of fields and that can each define multiple options. + +```jsonnet +override.byType.new('number') ++ override.byType.withPropertiesFromOptions( + panel.standardOptions.withDecimals(2) + + panel.standardOptions.withUnit('s') +) +``` + + +## Index + +* [`obj byName`](#obj-byname) + * [`fn new(value)`](#fn-bynamenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bynamewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bynamewithproperty) +* [`obj byQuery`](#obj-byquery) + * [`fn new(value)`](#fn-byquerynew) + * [`fn withPropertiesFromOptions(options)`](#fn-byquerywithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byquerywithproperty) +* [`obj byRegexp`](#obj-byregexp) + * [`fn new(value)`](#fn-byregexpnew) + * [`fn withPropertiesFromOptions(options)`](#fn-byregexpwithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byregexpwithproperty) +* [`obj byType`](#obj-bytype) + * [`fn new(value)`](#fn-bytypenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bytypewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bytypewithproperty) +* [`obj byValue`](#obj-byvalue) + * [`fn new(value)`](#fn-byvaluenew) + * [`fn withPropertiesFromOptions(options)`](#fn-byvaluewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byvaluewithproperty) + +## Fields + +### obj byName + + +#### fn byName.new + +```jsonnet +byName.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byName`. +#### fn byName.withPropertiesFromOptions + +```jsonnet +byName.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byName.withProperty + +```jsonnet +byName.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byQuery + + +#### fn byQuery.new + +```jsonnet +byQuery.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byQuery`. +#### fn byQuery.withPropertiesFromOptions + +```jsonnet +byQuery.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byQuery.withProperty + +```jsonnet +byQuery.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byRegexp + + +#### fn byRegexp.new + +```jsonnet +byRegexp.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byRegexp`. +#### fn byRegexp.withPropertiesFromOptions + +```jsonnet +byRegexp.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byRegexp.withProperty + +```jsonnet +byRegexp.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byType + + +#### fn byType.new + +```jsonnet +byType.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byType`. +#### fn byType.withPropertiesFromOptions + +```jsonnet +byType.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byType.withProperty + +```jsonnet +byType.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byValue + + +#### fn byValue.new + +```jsonnet +byValue.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byValue`. +#### fn byValue.withPropertiesFromOptions + +```jsonnet +byValue.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byValue.withProperty + +```jsonnet +byValue.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/nodeGraph/standardOptions/threshold/step.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/nodeGraph/standardOptions/threshold/step.md new file mode 100644 index 0000000000..dd2dd227ff --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/nodeGraph/standardOptions/threshold/step.md @@ -0,0 +1,60 @@ +# threshold.step + + + +## Index + +* [`fn withColor(value)`](#fn-withcolor) +* [`fn withIndex(value)`](#fn-withindex) +* [`fn withState(value)`](#fn-withstate) +* [`fn withValue(value)`](#fn-withvalue) + +## Fields + +### fn withColor + +```jsonnet +withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +### fn withIndex + +```jsonnet +withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Threshold index, an old property that is not needed an should only appear in older dashboards +### fn withState + +```jsonnet +withState(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO are the values here enumerable into a disjunction? +Some seem to be listed in typescript comment +### fn withValue + +```jsonnet +withValue(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +FIXME the corresponding typescript field is required/non-optional, but nulls currently appear here when serializing -Infinity to JSON \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/pieChart/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/pieChart/index.md new file mode 100644 index 0000000000..b431d7427c --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/pieChart/index.md @@ -0,0 +1,1071 @@ +# pieChart + +grafonnet.panel.pieChart + +## Subpackages + +* [panelOptions.link](panelOptions/link.md) +* [queryOptions.transformation](queryOptions/transformation.md) +* [standardOptions.mapping](standardOptions/mapping.md) +* [standardOptions.override](standardOptions/override.md) +* [standardOptions.threshold.step](standardOptions/threshold/step.md) + +## Index + +* [`fn new(title)`](#fn-new) +* [`obj fieldConfig`](#obj-fieldconfig) + * [`obj defaults`](#obj-fieldconfigdefaults) + * [`obj custom`](#obj-fieldconfigdefaultscustom) + * [`fn withHideFrom(value)`](#fn-fieldconfigdefaultscustomwithhidefrom) + * [`fn withHideFromMixin(value)`](#fn-fieldconfigdefaultscustomwithhidefrommixin) + * [`obj hideFrom`](#obj-fieldconfigdefaultscustomhidefrom) + * [`fn withLegend(value=true)`](#fn-fieldconfigdefaultscustomhidefromwithlegend) + * [`fn withTooltip(value=true)`](#fn-fieldconfigdefaultscustomhidefromwithtooltip) + * [`fn withViz(value=true)`](#fn-fieldconfigdefaultscustomhidefromwithviz) +* [`obj libraryPanel`](#obj-librarypanel) + * [`fn withName(value)`](#fn-librarypanelwithname) + * [`fn withUid(value)`](#fn-librarypanelwithuid) +* [`obj options`](#obj-options) + * [`fn withDisplayLabels(value)`](#fn-optionswithdisplaylabels) + * [`fn withDisplayLabelsMixin(value)`](#fn-optionswithdisplaylabelsmixin) + * [`fn withLegend(value)`](#fn-optionswithlegend) + * [`fn withLegendMixin(value)`](#fn-optionswithlegendmixin) + * [`fn withOrientation(value)`](#fn-optionswithorientation) + * [`fn withPieType(value)`](#fn-optionswithpietype) + * [`fn withReduceOptions(value)`](#fn-optionswithreduceoptions) + * [`fn withReduceOptionsMixin(value)`](#fn-optionswithreduceoptionsmixin) + * [`fn withText(value)`](#fn-optionswithtext) + * [`fn withTextMixin(value)`](#fn-optionswithtextmixin) + * [`fn withTooltip(value)`](#fn-optionswithtooltip) + * [`fn withTooltipMixin(value)`](#fn-optionswithtooltipmixin) + * [`obj legend`](#obj-optionslegend) + * [`fn withAsTable(value=true)`](#fn-optionslegendwithastable) + * [`fn withCalcs(value)`](#fn-optionslegendwithcalcs) + * [`fn withCalcsMixin(value)`](#fn-optionslegendwithcalcsmixin) + * [`fn withDisplayMode(value)`](#fn-optionslegendwithdisplaymode) + * [`fn withIsVisible(value=true)`](#fn-optionslegendwithisvisible) + * [`fn withPlacement(value)`](#fn-optionslegendwithplacement) + * [`fn withShowLegend(value=true)`](#fn-optionslegendwithshowlegend) + * [`fn withSortBy(value)`](#fn-optionslegendwithsortby) + * [`fn withSortDesc(value=true)`](#fn-optionslegendwithsortdesc) + * [`fn withValues(value)`](#fn-optionslegendwithvalues) + * [`fn withValuesMixin(value)`](#fn-optionslegendwithvaluesmixin) + * [`fn withWidth(value)`](#fn-optionslegendwithwidth) + * [`obj reduceOptions`](#obj-optionsreduceoptions) + * [`fn withCalcs(value)`](#fn-optionsreduceoptionswithcalcs) + * [`fn withCalcsMixin(value)`](#fn-optionsreduceoptionswithcalcsmixin) + * [`fn withFields(value)`](#fn-optionsreduceoptionswithfields) + * [`fn withLimit(value)`](#fn-optionsreduceoptionswithlimit) + * [`fn withValues(value=true)`](#fn-optionsreduceoptionswithvalues) + * [`obj text`](#obj-optionstext) + * [`fn withTitleSize(value)`](#fn-optionstextwithtitlesize) + * [`fn withValueSize(value)`](#fn-optionstextwithvaluesize) + * [`obj tooltip`](#obj-optionstooltip) + * [`fn withMode(value)`](#fn-optionstooltipwithmode) + * [`fn withSort(value)`](#fn-optionstooltipwithsort) +* [`obj panelOptions`](#obj-paneloptions) + * [`fn withDescription(value)`](#fn-paneloptionswithdescription) + * [`fn withGridPos(h="null", w="null", x="null", y="null")`](#fn-paneloptionswithgridpos) + * [`fn withLinks(value)`](#fn-paneloptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-paneloptionswithlinksmixin) + * [`fn withRepeat(value)`](#fn-paneloptionswithrepeat) + * [`fn withRepeatDirection(value="h")`](#fn-paneloptionswithrepeatdirection) + * [`fn withTitle(value)`](#fn-paneloptionswithtitle) + * [`fn withTransparent(value=true)`](#fn-paneloptionswithtransparent) +* [`obj queryOptions`](#obj-queryoptions) + * [`fn withDatasource(type, uid)`](#fn-queryoptionswithdatasource) + * [`fn withDatasourceMixin(value)`](#fn-queryoptionswithdatasourcemixin) + * [`fn withInterval(value)`](#fn-queryoptionswithinterval) + * [`fn withMaxDataPoints(value)`](#fn-queryoptionswithmaxdatapoints) + * [`fn withTargets(value)`](#fn-queryoptionswithtargets) + * [`fn withTargetsMixin(value)`](#fn-queryoptionswithtargetsmixin) + * [`fn withTimeFrom(value)`](#fn-queryoptionswithtimefrom) + * [`fn withTimeShift(value)`](#fn-queryoptionswithtimeshift) + * [`fn withTransformations(value)`](#fn-queryoptionswithtransformations) + * [`fn withTransformationsMixin(value)`](#fn-queryoptionswithtransformationsmixin) +* [`obj standardOptions`](#obj-standardoptions) + * [`fn withDecimals(value)`](#fn-standardoptionswithdecimals) + * [`fn withDisplayName(value)`](#fn-standardoptionswithdisplayname) + * [`fn withFilterable(value=true)`](#fn-standardoptionswithfilterable) + * [`fn withLinks(value)`](#fn-standardoptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-standardoptionswithlinksmixin) + * [`fn withMappings(value)`](#fn-standardoptionswithmappings) + * [`fn withMappingsMixin(value)`](#fn-standardoptionswithmappingsmixin) + * [`fn withMax(value)`](#fn-standardoptionswithmax) + * [`fn withMin(value)`](#fn-standardoptionswithmin) + * [`fn withNoValue(value)`](#fn-standardoptionswithnovalue) + * [`fn withOverrides(value)`](#fn-standardoptionswithoverrides) + * [`fn withOverridesMixin(value)`](#fn-standardoptionswithoverridesmixin) + * [`fn withPath(value)`](#fn-standardoptionswithpath) + * [`fn withUnit(value)`](#fn-standardoptionswithunit) + * [`obj color`](#obj-standardoptionscolor) + * [`fn withFixedColor(value)`](#fn-standardoptionscolorwithfixedcolor) + * [`fn withMode(value)`](#fn-standardoptionscolorwithmode) + * [`fn withSeriesBy(value)`](#fn-standardoptionscolorwithseriesby) + * [`obj thresholds`](#obj-standardoptionsthresholds) + * [`fn withMode(value)`](#fn-standardoptionsthresholdswithmode) + * [`fn withSteps(value)`](#fn-standardoptionsthresholdswithsteps) + * [`fn withStepsMixin(value)`](#fn-standardoptionsthresholdswithstepsmixin) + +## Fields + +### fn new + +```jsonnet +new(title) +``` + +PARAMETERS: + +* **title** (`string`) + +Creates a new pieChart panel with a title. +### obj fieldConfig + + +#### obj fieldConfig.defaults + + +##### obj fieldConfig.defaults.custom + + +###### fn fieldConfig.defaults.custom.withHideFrom + +```jsonnet +fieldConfig.defaults.custom.withHideFrom(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn fieldConfig.defaults.custom.withHideFromMixin + +```jsonnet +fieldConfig.defaults.custom.withHideFromMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### obj fieldConfig.defaults.custom.hideFrom + + +####### fn fieldConfig.defaults.custom.hideFrom.withLegend + +```jsonnet +fieldConfig.defaults.custom.hideFrom.withLegend(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +####### fn fieldConfig.defaults.custom.hideFrom.withTooltip + +```jsonnet +fieldConfig.defaults.custom.hideFrom.withTooltip(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +####### fn fieldConfig.defaults.custom.hideFrom.withViz + +```jsonnet +fieldConfig.defaults.custom.hideFrom.withViz(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### obj libraryPanel + + +#### fn libraryPanel.withName + +```jsonnet +libraryPanel.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn libraryPanel.withUid + +```jsonnet +libraryPanel.withUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj options + + +#### fn options.withDisplayLabels + +```jsonnet +options.withDisplayLabels(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn options.withDisplayLabelsMixin + +```jsonnet +options.withDisplayLabelsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn options.withLegend + +```jsonnet +options.withLegend(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn options.withLegendMixin + +```jsonnet +options.withLegendMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn options.withOrientation + +```jsonnet +options.withOrientation(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"auto"`, `"vertical"`, `"horizontal"` + +TODO docs +#### fn options.withPieType + +```jsonnet +options.withPieType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"pie"`, `"donut"` + +Select the pie chart display style. +#### fn options.withReduceOptions + +```jsonnet +options.withReduceOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withReduceOptionsMixin + +```jsonnet +options.withReduceOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withText + +```jsonnet +options.withText(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withTextMixin + +```jsonnet +options.withTextMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withTooltip + +```jsonnet +options.withTooltip(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withTooltipMixin + +```jsonnet +options.withTooltipMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### obj options.legend + + +##### fn options.legend.withAsTable + +```jsonnet +options.legend.withAsTable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.legend.withCalcs + +```jsonnet +options.legend.withCalcs(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +##### fn options.legend.withCalcsMixin + +```jsonnet +options.legend.withCalcsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +##### fn options.legend.withDisplayMode + +```jsonnet +options.legend.withDisplayMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"list"`, `"table"`, `"hidden"` + +TODO docs +Note: "hidden" needs to remain as an option for plugins compatibility +##### fn options.legend.withIsVisible + +```jsonnet +options.legend.withIsVisible(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.legend.withPlacement + +```jsonnet +options.legend.withPlacement(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"bottom"`, `"right"` + +TODO docs +##### fn options.legend.withShowLegend + +```jsonnet +options.legend.withShowLegend(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.legend.withSortBy + +```jsonnet +options.legend.withSortBy(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn options.legend.withSortDesc + +```jsonnet +options.legend.withSortDesc(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.legend.withValues + +```jsonnet +options.legend.withValues(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +##### fn options.legend.withValuesMixin + +```jsonnet +options.legend.withValuesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +##### fn options.legend.withWidth + +```jsonnet +options.legend.withWidth(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### obj options.reduceOptions + + +##### fn options.reduceOptions.withCalcs + +```jsonnet +options.reduceOptions.withCalcs(value) +``` + +PARAMETERS: + +* **value** (`array`) + +When !values, pick one value for the whole field +##### fn options.reduceOptions.withCalcsMixin + +```jsonnet +options.reduceOptions.withCalcsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +When !values, pick one value for the whole field +##### fn options.reduceOptions.withFields + +```jsonnet +options.reduceOptions.withFields(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Which fields to show. By default this is only numeric fields +##### fn options.reduceOptions.withLimit + +```jsonnet +options.reduceOptions.withLimit(value) +``` + +PARAMETERS: + +* **value** (`number`) + +if showing all values limit +##### fn options.reduceOptions.withValues + +```jsonnet +options.reduceOptions.withValues(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +If true show each row value +#### obj options.text + + +##### fn options.text.withTitleSize + +```jsonnet +options.text.withTitleSize(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Explicit title text size +##### fn options.text.withValueSize + +```jsonnet +options.text.withValueSize(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Explicit value text size +#### obj options.tooltip + + +##### fn options.tooltip.withMode + +```jsonnet +options.tooltip.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"single"`, `"multi"`, `"none"` + +TODO docs +##### fn options.tooltip.withSort + +```jsonnet +options.tooltip.withSort(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"asc"`, `"desc"`, `"none"` + +TODO docs +### obj panelOptions + + +#### fn panelOptions.withDescription + +```jsonnet +panelOptions.withDescription(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Description. +#### fn panelOptions.withGridPos + +```jsonnet +panelOptions.withGridPos(h="null", w="null", x="null", y="null") +``` + +PARAMETERS: + +* **h** (`number`) + - default value: `"null"` +* **w** (`number`) + - default value: `"null"` +* **x** (`number`) + - default value: `"null"` +* **y** (`number`) + - default value: `"null"` + +`withGridPos` configures the height, width and xy coordinates of the panel. Also see `grafonnet.util.grid` for helper functions to calculate these fields. + +All arguments default to `null`, which means they will remain unchanged or unset. + +#### fn panelOptions.withLinks + +```jsonnet +panelOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withLinksMixin + +```jsonnet +panelOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withRepeat + +```jsonnet +panelOptions.withRepeat(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of template variable to repeat for. +#### fn panelOptions.withRepeatDirection + +```jsonnet +panelOptions.withRepeatDirection(value="h") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"h"` + - valid values: `"h"`, `"v"` + +Direction to repeat in if 'repeat' is set. +"h" for horizontal, "v" for vertical. +TODO this is probably optional +#### fn panelOptions.withTitle + +```jsonnet +panelOptions.withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Panel title. +#### fn panelOptions.withTransparent + +```jsonnet +panelOptions.withTransparent(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Whether to display the panel without a background. +### obj queryOptions + + +#### fn queryOptions.withDatasource + +```jsonnet +queryOptions.withDatasource(type, uid) +``` + +PARAMETERS: + +* **type** (`string`) +* **uid** (`string`) + +`withDatasource` sets the datasource for all queries in a panel. + +The default datasource for a panel is set to 'Mixed datasource' so panels can be datasource agnostic, which is a lot more interesting from a reusability standpoint. Note that this requires query targets to explicitly set datasource for the same reason. + +#### fn queryOptions.withDatasourceMixin + +```jsonnet +queryOptions.withDatasourceMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +The datasource used in all targets. +#### fn queryOptions.withInterval + +```jsonnet +queryOptions.withInterval(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withMaxDataPoints + +```jsonnet +queryOptions.withMaxDataPoints(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +#### fn queryOptions.withTargets + +```jsonnet +queryOptions.withTargets(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTargetsMixin + +```jsonnet +queryOptions.withTargetsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTimeFrom + +```jsonnet +queryOptions.withTimeFrom(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTimeShift + +```jsonnet +queryOptions.withTimeShift(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTransformations + +```jsonnet +queryOptions.withTransformations(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn queryOptions.withTransformationsMixin + +```jsonnet +queryOptions.withTransformationsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### obj standardOptions + + +#### fn standardOptions.withDecimals + +```jsonnet +standardOptions.withDecimals(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Significant digits (for display) +#### fn standardOptions.withDisplayName + +```jsonnet +standardOptions.withDisplayName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The display value for this field. This supports template variables blank is auto +#### fn standardOptions.withFilterable + +```jsonnet +standardOptions.withFilterable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +True if data source field supports ad-hoc filters +#### fn standardOptions.withLinks + +```jsonnet +standardOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withLinksMixin + +```jsonnet +standardOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withMappings + +```jsonnet +standardOptions.withMappings(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMappingsMixin + +```jsonnet +standardOptions.withMappingsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMax + +```jsonnet +standardOptions.withMax(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withMin + +```jsonnet +standardOptions.withMin(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withNoValue + +```jsonnet +standardOptions.withNoValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Alternative to empty string +#### fn standardOptions.withOverrides + +```jsonnet +standardOptions.withOverrides(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withOverridesMixin + +```jsonnet +standardOptions.withOverridesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withPath + +```jsonnet +standardOptions.withPath(value) +``` + +PARAMETERS: + +* **value** (`string`) + +An explicit path to the field in the datasource. When the frame meta includes a path, +This will default to `${frame.meta.path}/${field.name} + +When defined, this value can be used as an identifier within the datasource scope, and +may be used to update the results +#### fn standardOptions.withUnit + +```jsonnet +standardOptions.withUnit(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Numeric Options +#### obj standardOptions.color + + +##### fn standardOptions.color.withFixedColor + +```jsonnet +standardOptions.color.withFixedColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Stores the fixed color value if mode is fixed +##### fn standardOptions.color.withMode + +```jsonnet +standardOptions.color.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The main color scheme mode +##### fn standardOptions.color.withSeriesBy + +```jsonnet +standardOptions.color.withSeriesBy(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"min"`, `"max"`, `"last"` + +TODO docs +#### obj standardOptions.thresholds + + +##### fn standardOptions.thresholds.withMode + +```jsonnet +standardOptions.thresholds.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"absolute"`, `"percentage"` + + +##### fn standardOptions.thresholds.withSteps + +```jsonnet +standardOptions.thresholds.withSteps(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity +##### fn standardOptions.thresholds.withStepsMixin + +```jsonnet +standardOptions.thresholds.withStepsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/pieChart/panelOptions/link.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/pieChart/panelOptions/link.md new file mode 100644 index 0000000000..106f9d2edb --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/pieChart/panelOptions/link.md @@ -0,0 +1,145 @@ +# link + + + +## Index + +* [`fn withAsDropdown(value=true)`](#fn-withasdropdown) +* [`fn withIcon(value)`](#fn-withicon) +* [`fn withIncludeVars(value=true)`](#fn-withincludevars) +* [`fn withKeepTime(value=true)`](#fn-withkeeptime) +* [`fn withTags(value)`](#fn-withtags) +* [`fn withTagsMixin(value)`](#fn-withtagsmixin) +* [`fn withTargetBlank(value=true)`](#fn-withtargetblank) +* [`fn withTitle(value)`](#fn-withtitle) +* [`fn withTooltip(value)`](#fn-withtooltip) +* [`fn withType(value)`](#fn-withtype) +* [`fn withUrl(value)`](#fn-withurl) + +## Fields + +### fn withAsDropdown + +```jsonnet +withAsDropdown(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withIcon + +```jsonnet +withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withIncludeVars + +```jsonnet +withIncludeVars(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withKeepTime + +```jsonnet +withKeepTime(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTags + +```jsonnet +withTags(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTagsMixin + +```jsonnet +withTagsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTargetBlank + +```jsonnet +withTargetBlank(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTitle + +```jsonnet +withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withTooltip + +```jsonnet +withTooltip(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withType + +```jsonnet +withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"link"`, `"dashboards"` + +TODO docs +### fn withUrl + +```jsonnet +withUrl(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/pieChart/queryOptions/transformation.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/pieChart/queryOptions/transformation.md new file mode 100644 index 0000000000..dc832f653d --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/pieChart/queryOptions/transformation.md @@ -0,0 +1,99 @@ +# transformation + + + +## Index + +* [`fn withDisabled(value=true)`](#fn-withdisabled) +* [`fn withFilter(value)`](#fn-withfilter) +* [`fn withFilterMixin(value)`](#fn-withfiltermixin) +* [`fn withId(value)`](#fn-withid) +* [`fn withOptions(value)`](#fn-withoptions) +* [`obj filter`](#obj-filter) + * [`fn withId(value="")`](#fn-filterwithid) + * [`fn withOptions(value)`](#fn-filterwithoptions) + +## Fields + +### fn withDisabled + +```jsonnet +withDisabled(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Disabled transformations are skipped +### fn withFilter + +```jsonnet +withFilter(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withFilterMixin + +```jsonnet +withFilterMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withId + +```jsonnet +withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Unique identifier of transformer +### fn withOptions + +```jsonnet +withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Options to be passed to the transformer +Valid options depend on the transformer id +### obj filter + + +#### fn filter.withId + +```jsonnet +filter.withId(value="") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `""` + + +#### fn filter.withOptions + +```jsonnet +filter.withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/pieChart/standardOptions/mapping.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/pieChart/standardOptions/mapping.md new file mode 100644 index 0000000000..93296972e8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/pieChart/standardOptions/mapping.md @@ -0,0 +1,469 @@ +# mapping + + + +## Index + +* [`obj RangeMap`](#obj-rangemap) + * [`fn withOptions(value)`](#fn-rangemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-rangemapwithoptionsmixin) + * [`fn withType(value)`](#fn-rangemapwithtype) + * [`obj options`](#obj-rangemapoptions) + * [`fn withFrom(value)`](#fn-rangemapoptionswithfrom) + * [`fn withResult(value)`](#fn-rangemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-rangemapoptionswithresultmixin) + * [`fn withTo(value)`](#fn-rangemapoptionswithto) + * [`obj result`](#obj-rangemapoptionsresult) + * [`fn withColor(value)`](#fn-rangemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-rangemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-rangemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-rangemapoptionsresultwithtext) +* [`obj RegexMap`](#obj-regexmap) + * [`fn withOptions(value)`](#fn-regexmapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-regexmapwithoptionsmixin) + * [`fn withType(value)`](#fn-regexmapwithtype) + * [`obj options`](#obj-regexmapoptions) + * [`fn withPattern(value)`](#fn-regexmapoptionswithpattern) + * [`fn withResult(value)`](#fn-regexmapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-regexmapoptionswithresultmixin) + * [`obj result`](#obj-regexmapoptionsresult) + * [`fn withColor(value)`](#fn-regexmapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-regexmapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-regexmapoptionsresultwithindex) + * [`fn withText(value)`](#fn-regexmapoptionsresultwithtext) +* [`obj SpecialValueMap`](#obj-specialvaluemap) + * [`fn withOptions(value)`](#fn-specialvaluemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-specialvaluemapwithoptionsmixin) + * [`fn withType(value)`](#fn-specialvaluemapwithtype) + * [`obj options`](#obj-specialvaluemapoptions) + * [`fn withMatch(value)`](#fn-specialvaluemapoptionswithmatch) + * [`fn withPattern(value)`](#fn-specialvaluemapoptionswithpattern) + * [`fn withResult(value)`](#fn-specialvaluemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-specialvaluemapoptionswithresultmixin) + * [`obj result`](#obj-specialvaluemapoptionsresult) + * [`fn withColor(value)`](#fn-specialvaluemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-specialvaluemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-specialvaluemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-specialvaluemapoptionsresultwithtext) +* [`obj ValueMap`](#obj-valuemap) + * [`fn withOptions(value)`](#fn-valuemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-valuemapwithoptionsmixin) + * [`fn withType(value)`](#fn-valuemapwithtype) + +## Fields + +### obj RangeMap + + +#### fn RangeMap.withOptions + +```jsonnet +RangeMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withOptionsMixin + +```jsonnet +RangeMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withType + +```jsonnet +RangeMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RangeMap.options + + +##### fn RangeMap.options.withFrom + +```jsonnet +RangeMap.options.withFrom(value) +``` + +PARAMETERS: + +* **value** (`number`) + +to and from are `number | null` in current ts, really not sure what to do +##### fn RangeMap.options.withResult + +```jsonnet +RangeMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withResultMixin + +```jsonnet +RangeMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withTo + +```jsonnet +RangeMap.options.withTo(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +##### obj RangeMap.options.result + + +###### fn RangeMap.options.result.withColor + +```jsonnet +RangeMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIcon + +```jsonnet +RangeMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIndex + +```jsonnet +RangeMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RangeMap.options.result.withText + +```jsonnet +RangeMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj RegexMap + + +#### fn RegexMap.withOptions + +```jsonnet +RegexMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withOptionsMixin + +```jsonnet +RegexMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withType + +```jsonnet +RegexMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RegexMap.options + + +##### fn RegexMap.options.withPattern + +```jsonnet +RegexMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn RegexMap.options.withResult + +```jsonnet +RegexMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RegexMap.options.withResultMixin + +```jsonnet +RegexMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj RegexMap.options.result + + +###### fn RegexMap.options.result.withColor + +```jsonnet +RegexMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIcon + +```jsonnet +RegexMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIndex + +```jsonnet +RegexMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RegexMap.options.result.withText + +```jsonnet +RegexMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj SpecialValueMap + + +#### fn SpecialValueMap.withOptions + +```jsonnet +SpecialValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withOptionsMixin + +```jsonnet +SpecialValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withType + +```jsonnet +SpecialValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj SpecialValueMap.options + + +##### fn SpecialValueMap.options.withMatch + +```jsonnet +SpecialValueMap.options.withMatch(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"true"`, `"false"` + + +##### fn SpecialValueMap.options.withPattern + +```jsonnet +SpecialValueMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn SpecialValueMap.options.withResult + +```jsonnet +SpecialValueMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn SpecialValueMap.options.withResultMixin + +```jsonnet +SpecialValueMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj SpecialValueMap.options.result + + +###### fn SpecialValueMap.options.result.withColor + +```jsonnet +SpecialValueMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIcon + +```jsonnet +SpecialValueMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIndex + +```jsonnet +SpecialValueMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn SpecialValueMap.options.result.withText + +```jsonnet +SpecialValueMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj ValueMap + + +#### fn ValueMap.withOptions + +```jsonnet +ValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withOptionsMixin + +```jsonnet +ValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withType + +```jsonnet +ValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/pieChart/standardOptions/override.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/pieChart/standardOptions/override.md new file mode 100644 index 0000000000..154f3dbdac --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/pieChart/standardOptions/override.md @@ -0,0 +1,244 @@ +# override + +Overrides allow you to customize visualization settings for specific fields or +series. This is accomplished by adding an override rule that targets +a particular set of fields and that can each define multiple options. + +```jsonnet +override.byType.new('number') ++ override.byType.withPropertiesFromOptions( + panel.standardOptions.withDecimals(2) + + panel.standardOptions.withUnit('s') +) +``` + + +## Index + +* [`obj byName`](#obj-byname) + * [`fn new(value)`](#fn-bynamenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bynamewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bynamewithproperty) +* [`obj byQuery`](#obj-byquery) + * [`fn new(value)`](#fn-byquerynew) + * [`fn withPropertiesFromOptions(options)`](#fn-byquerywithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byquerywithproperty) +* [`obj byRegexp`](#obj-byregexp) + * [`fn new(value)`](#fn-byregexpnew) + * [`fn withPropertiesFromOptions(options)`](#fn-byregexpwithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byregexpwithproperty) +* [`obj byType`](#obj-bytype) + * [`fn new(value)`](#fn-bytypenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bytypewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bytypewithproperty) +* [`obj byValue`](#obj-byvalue) + * [`fn new(value)`](#fn-byvaluenew) + * [`fn withPropertiesFromOptions(options)`](#fn-byvaluewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byvaluewithproperty) + +## Fields + +### obj byName + + +#### fn byName.new + +```jsonnet +byName.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byName`. +#### fn byName.withPropertiesFromOptions + +```jsonnet +byName.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byName.withProperty + +```jsonnet +byName.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byQuery + + +#### fn byQuery.new + +```jsonnet +byQuery.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byQuery`. +#### fn byQuery.withPropertiesFromOptions + +```jsonnet +byQuery.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byQuery.withProperty + +```jsonnet +byQuery.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byRegexp + + +#### fn byRegexp.new + +```jsonnet +byRegexp.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byRegexp`. +#### fn byRegexp.withPropertiesFromOptions + +```jsonnet +byRegexp.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byRegexp.withProperty + +```jsonnet +byRegexp.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byType + + +#### fn byType.new + +```jsonnet +byType.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byType`. +#### fn byType.withPropertiesFromOptions + +```jsonnet +byType.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byType.withProperty + +```jsonnet +byType.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byValue + + +#### fn byValue.new + +```jsonnet +byValue.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byValue`. +#### fn byValue.withPropertiesFromOptions + +```jsonnet +byValue.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byValue.withProperty + +```jsonnet +byValue.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/pieChart/standardOptions/threshold/step.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/pieChart/standardOptions/threshold/step.md new file mode 100644 index 0000000000..dd2dd227ff --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/pieChart/standardOptions/threshold/step.md @@ -0,0 +1,60 @@ +# threshold.step + + + +## Index + +* [`fn withColor(value)`](#fn-withcolor) +* [`fn withIndex(value)`](#fn-withindex) +* [`fn withState(value)`](#fn-withstate) +* [`fn withValue(value)`](#fn-withvalue) + +## Fields + +### fn withColor + +```jsonnet +withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +### fn withIndex + +```jsonnet +withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Threshold index, an old property that is not needed an should only appear in older dashboards +### fn withState + +```jsonnet +withState(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO are the values here enumerable into a disjunction? +Some seem to be listed in typescript comment +### fn withValue + +```jsonnet +withValue(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +FIXME the corresponding typescript field is required/non-optional, but nulls currently appear here when serializing -Infinity to JSON \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/row.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/row.md new file mode 100644 index 0000000000..8ae5023936 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/row.md @@ -0,0 +1,248 @@ +# row + +grafonnet.panel.row + +## Index + +* [`fn new(title)`](#fn-new) +* [`fn withCollapsed(value=true)`](#fn-withcollapsed) +* [`fn withDatasource(value)`](#fn-withdatasource) +* [`fn withDatasourceMixin(value)`](#fn-withdatasourcemixin) +* [`fn withGridPos(value)`](#fn-withgridpos) +* [`fn withGridPosMixin(value)`](#fn-withgridposmixin) +* [`fn withId(value)`](#fn-withid) +* [`fn withPanels(value)`](#fn-withpanels) +* [`fn withPanelsMixin(value)`](#fn-withpanelsmixin) +* [`fn withRepeat(value)`](#fn-withrepeat) +* [`fn withTitle(value)`](#fn-withtitle) +* [`fn withType()`](#fn-withtype) +* [`obj datasource`](#obj-datasource) + * [`fn withType(value)`](#fn-datasourcewithtype) + * [`fn withUid(value)`](#fn-datasourcewithuid) +* [`obj gridPos`](#obj-gridpos) + * [`fn withH(value=9)`](#fn-gridposwithh) + * [`fn withStatic(value=true)`](#fn-gridposwithstatic) + * [`fn withW(value=12)`](#fn-gridposwithw) + * [`fn withX(value=0)`](#fn-gridposwithx) + * [`fn withY(value=0)`](#fn-gridposwithy) + +## Fields + +### fn new + +```jsonnet +new(title) +``` + +PARAMETERS: + +* **title** (`string`) + +Creates a new row panel with a title. +### fn withCollapsed + +```jsonnet +withCollapsed(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withDatasource + +```jsonnet +withDatasource(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Name of default datasource. +### fn withDatasourceMixin + +```jsonnet +withDatasourceMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Name of default datasource. +### fn withGridPos + +```jsonnet +withGridPos(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withGridPosMixin + +```jsonnet +withGridPosMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withId + +```jsonnet +withId(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +### fn withPanels + +```jsonnet +withPanels(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withPanelsMixin + +```jsonnet +withPanelsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withRepeat + +```jsonnet +withRepeat(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of template variable to repeat for. +### fn withTitle + +```jsonnet +withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withType + +```jsonnet +withType() +``` + + + +### obj datasource + + +#### fn datasource.withType + +```jsonnet +datasource.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn datasource.withUid + +```jsonnet +datasource.withUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj gridPos + + +#### fn gridPos.withH + +```jsonnet +gridPos.withH(value=9) +``` + +PARAMETERS: + +* **value** (`integer`) + - default value: `9` + +Panel +#### fn gridPos.withStatic + +```jsonnet +gridPos.withStatic(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +true if fixed +#### fn gridPos.withW + +```jsonnet +gridPos.withW(value=12) +``` + +PARAMETERS: + +* **value** (`integer`) + - default value: `12` + +Panel +#### fn gridPos.withX + +```jsonnet +gridPos.withX(value=0) +``` + +PARAMETERS: + +* **value** (`integer`) + - default value: `0` + +Panel x +#### fn gridPos.withY + +```jsonnet +gridPos.withY(value=0) +``` + +PARAMETERS: + +* **value** (`integer`) + - default value: `0` + +Panel y \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/stat/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/stat/index.md new file mode 100644 index 0000000000..a76b1af08c --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/stat/index.md @@ -0,0 +1,774 @@ +# stat + +grafonnet.panel.stat + +## Subpackages + +* [panelOptions.link](panelOptions/link.md) +* [queryOptions.transformation](queryOptions/transformation.md) +* [standardOptions.mapping](standardOptions/mapping.md) +* [standardOptions.override](standardOptions/override.md) +* [standardOptions.threshold.step](standardOptions/threshold/step.md) + +## Index + +* [`fn new(title)`](#fn-new) +* [`obj libraryPanel`](#obj-librarypanel) + * [`fn withName(value)`](#fn-librarypanelwithname) + * [`fn withUid(value)`](#fn-librarypanelwithuid) +* [`obj options`](#obj-options) + * [`fn withColorMode(value)`](#fn-optionswithcolormode) + * [`fn withGraphMode(value)`](#fn-optionswithgraphmode) + * [`fn withJustifyMode(value)`](#fn-optionswithjustifymode) + * [`fn withOrientation(value)`](#fn-optionswithorientation) + * [`fn withReduceOptions(value)`](#fn-optionswithreduceoptions) + * [`fn withReduceOptionsMixin(value)`](#fn-optionswithreduceoptionsmixin) + * [`fn withText(value)`](#fn-optionswithtext) + * [`fn withTextMixin(value)`](#fn-optionswithtextmixin) + * [`fn withTextMode(value)`](#fn-optionswithtextmode) + * [`obj reduceOptions`](#obj-optionsreduceoptions) + * [`fn withCalcs(value)`](#fn-optionsreduceoptionswithcalcs) + * [`fn withCalcsMixin(value)`](#fn-optionsreduceoptionswithcalcsmixin) + * [`fn withFields(value)`](#fn-optionsreduceoptionswithfields) + * [`fn withLimit(value)`](#fn-optionsreduceoptionswithlimit) + * [`fn withValues(value=true)`](#fn-optionsreduceoptionswithvalues) + * [`obj text`](#obj-optionstext) + * [`fn withTitleSize(value)`](#fn-optionstextwithtitlesize) + * [`fn withValueSize(value)`](#fn-optionstextwithvaluesize) +* [`obj panelOptions`](#obj-paneloptions) + * [`fn withDescription(value)`](#fn-paneloptionswithdescription) + * [`fn withGridPos(h="null", w="null", x="null", y="null")`](#fn-paneloptionswithgridpos) + * [`fn withLinks(value)`](#fn-paneloptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-paneloptionswithlinksmixin) + * [`fn withRepeat(value)`](#fn-paneloptionswithrepeat) + * [`fn withRepeatDirection(value="h")`](#fn-paneloptionswithrepeatdirection) + * [`fn withTitle(value)`](#fn-paneloptionswithtitle) + * [`fn withTransparent(value=true)`](#fn-paneloptionswithtransparent) +* [`obj queryOptions`](#obj-queryoptions) + * [`fn withDatasource(type, uid)`](#fn-queryoptionswithdatasource) + * [`fn withDatasourceMixin(value)`](#fn-queryoptionswithdatasourcemixin) + * [`fn withInterval(value)`](#fn-queryoptionswithinterval) + * [`fn withMaxDataPoints(value)`](#fn-queryoptionswithmaxdatapoints) + * [`fn withTargets(value)`](#fn-queryoptionswithtargets) + * [`fn withTargetsMixin(value)`](#fn-queryoptionswithtargetsmixin) + * [`fn withTimeFrom(value)`](#fn-queryoptionswithtimefrom) + * [`fn withTimeShift(value)`](#fn-queryoptionswithtimeshift) + * [`fn withTransformations(value)`](#fn-queryoptionswithtransformations) + * [`fn withTransformationsMixin(value)`](#fn-queryoptionswithtransformationsmixin) +* [`obj standardOptions`](#obj-standardoptions) + * [`fn withDecimals(value)`](#fn-standardoptionswithdecimals) + * [`fn withDisplayName(value)`](#fn-standardoptionswithdisplayname) + * [`fn withFilterable(value=true)`](#fn-standardoptionswithfilterable) + * [`fn withLinks(value)`](#fn-standardoptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-standardoptionswithlinksmixin) + * [`fn withMappings(value)`](#fn-standardoptionswithmappings) + * [`fn withMappingsMixin(value)`](#fn-standardoptionswithmappingsmixin) + * [`fn withMax(value)`](#fn-standardoptionswithmax) + * [`fn withMin(value)`](#fn-standardoptionswithmin) + * [`fn withNoValue(value)`](#fn-standardoptionswithnovalue) + * [`fn withOverrides(value)`](#fn-standardoptionswithoverrides) + * [`fn withOverridesMixin(value)`](#fn-standardoptionswithoverridesmixin) + * [`fn withPath(value)`](#fn-standardoptionswithpath) + * [`fn withUnit(value)`](#fn-standardoptionswithunit) + * [`obj color`](#obj-standardoptionscolor) + * [`fn withFixedColor(value)`](#fn-standardoptionscolorwithfixedcolor) + * [`fn withMode(value)`](#fn-standardoptionscolorwithmode) + * [`fn withSeriesBy(value)`](#fn-standardoptionscolorwithseriesby) + * [`obj thresholds`](#obj-standardoptionsthresholds) + * [`fn withMode(value)`](#fn-standardoptionsthresholdswithmode) + * [`fn withSteps(value)`](#fn-standardoptionsthresholdswithsteps) + * [`fn withStepsMixin(value)`](#fn-standardoptionsthresholdswithstepsmixin) + +## Fields + +### fn new + +```jsonnet +new(title) +``` + +PARAMETERS: + +* **title** (`string`) + +Creates a new stat panel with a title. +### obj libraryPanel + + +#### fn libraryPanel.withName + +```jsonnet +libraryPanel.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn libraryPanel.withUid + +```jsonnet +libraryPanel.withUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj options + + +#### fn options.withColorMode + +```jsonnet +options.withColorMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"value"`, `"background"`, `"background_solid"`, `"none"` + +TODO docs +#### fn options.withGraphMode + +```jsonnet +options.withGraphMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"none"`, `"line"`, `"area"` + +TODO docs +#### fn options.withJustifyMode + +```jsonnet +options.withJustifyMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"auto"`, `"center"` + +TODO docs +#### fn options.withOrientation + +```jsonnet +options.withOrientation(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"auto"`, `"vertical"`, `"horizontal"` + +TODO docs +#### fn options.withReduceOptions + +```jsonnet +options.withReduceOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withReduceOptionsMixin + +```jsonnet +options.withReduceOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withText + +```jsonnet +options.withText(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withTextMixin + +```jsonnet +options.withTextMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withTextMode + +```jsonnet +options.withTextMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"auto"`, `"value"`, `"value_and_name"`, `"name"`, `"none"` + +TODO docs +#### obj options.reduceOptions + + +##### fn options.reduceOptions.withCalcs + +```jsonnet +options.reduceOptions.withCalcs(value) +``` + +PARAMETERS: + +* **value** (`array`) + +When !values, pick one value for the whole field +##### fn options.reduceOptions.withCalcsMixin + +```jsonnet +options.reduceOptions.withCalcsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +When !values, pick one value for the whole field +##### fn options.reduceOptions.withFields + +```jsonnet +options.reduceOptions.withFields(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Which fields to show. By default this is only numeric fields +##### fn options.reduceOptions.withLimit + +```jsonnet +options.reduceOptions.withLimit(value) +``` + +PARAMETERS: + +* **value** (`number`) + +if showing all values limit +##### fn options.reduceOptions.withValues + +```jsonnet +options.reduceOptions.withValues(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +If true show each row value +#### obj options.text + + +##### fn options.text.withTitleSize + +```jsonnet +options.text.withTitleSize(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Explicit title text size +##### fn options.text.withValueSize + +```jsonnet +options.text.withValueSize(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Explicit value text size +### obj panelOptions + + +#### fn panelOptions.withDescription + +```jsonnet +panelOptions.withDescription(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Description. +#### fn panelOptions.withGridPos + +```jsonnet +panelOptions.withGridPos(h="null", w="null", x="null", y="null") +``` + +PARAMETERS: + +* **h** (`number`) + - default value: `"null"` +* **w** (`number`) + - default value: `"null"` +* **x** (`number`) + - default value: `"null"` +* **y** (`number`) + - default value: `"null"` + +`withGridPos` configures the height, width and xy coordinates of the panel. Also see `grafonnet.util.grid` for helper functions to calculate these fields. + +All arguments default to `null`, which means they will remain unchanged or unset. + +#### fn panelOptions.withLinks + +```jsonnet +panelOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withLinksMixin + +```jsonnet +panelOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withRepeat + +```jsonnet +panelOptions.withRepeat(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of template variable to repeat for. +#### fn panelOptions.withRepeatDirection + +```jsonnet +panelOptions.withRepeatDirection(value="h") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"h"` + - valid values: `"h"`, `"v"` + +Direction to repeat in if 'repeat' is set. +"h" for horizontal, "v" for vertical. +TODO this is probably optional +#### fn panelOptions.withTitle + +```jsonnet +panelOptions.withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Panel title. +#### fn panelOptions.withTransparent + +```jsonnet +panelOptions.withTransparent(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Whether to display the panel without a background. +### obj queryOptions + + +#### fn queryOptions.withDatasource + +```jsonnet +queryOptions.withDatasource(type, uid) +``` + +PARAMETERS: + +* **type** (`string`) +* **uid** (`string`) + +`withDatasource` sets the datasource for all queries in a panel. + +The default datasource for a panel is set to 'Mixed datasource' so panels can be datasource agnostic, which is a lot more interesting from a reusability standpoint. Note that this requires query targets to explicitly set datasource for the same reason. + +#### fn queryOptions.withDatasourceMixin + +```jsonnet +queryOptions.withDatasourceMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +The datasource used in all targets. +#### fn queryOptions.withInterval + +```jsonnet +queryOptions.withInterval(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withMaxDataPoints + +```jsonnet +queryOptions.withMaxDataPoints(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +#### fn queryOptions.withTargets + +```jsonnet +queryOptions.withTargets(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTargetsMixin + +```jsonnet +queryOptions.withTargetsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTimeFrom + +```jsonnet +queryOptions.withTimeFrom(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTimeShift + +```jsonnet +queryOptions.withTimeShift(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTransformations + +```jsonnet +queryOptions.withTransformations(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn queryOptions.withTransformationsMixin + +```jsonnet +queryOptions.withTransformationsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### obj standardOptions + + +#### fn standardOptions.withDecimals + +```jsonnet +standardOptions.withDecimals(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Significant digits (for display) +#### fn standardOptions.withDisplayName + +```jsonnet +standardOptions.withDisplayName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The display value for this field. This supports template variables blank is auto +#### fn standardOptions.withFilterable + +```jsonnet +standardOptions.withFilterable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +True if data source field supports ad-hoc filters +#### fn standardOptions.withLinks + +```jsonnet +standardOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withLinksMixin + +```jsonnet +standardOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withMappings + +```jsonnet +standardOptions.withMappings(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMappingsMixin + +```jsonnet +standardOptions.withMappingsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMax + +```jsonnet +standardOptions.withMax(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withMin + +```jsonnet +standardOptions.withMin(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withNoValue + +```jsonnet +standardOptions.withNoValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Alternative to empty string +#### fn standardOptions.withOverrides + +```jsonnet +standardOptions.withOverrides(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withOverridesMixin + +```jsonnet +standardOptions.withOverridesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withPath + +```jsonnet +standardOptions.withPath(value) +``` + +PARAMETERS: + +* **value** (`string`) + +An explicit path to the field in the datasource. When the frame meta includes a path, +This will default to `${frame.meta.path}/${field.name} + +When defined, this value can be used as an identifier within the datasource scope, and +may be used to update the results +#### fn standardOptions.withUnit + +```jsonnet +standardOptions.withUnit(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Numeric Options +#### obj standardOptions.color + + +##### fn standardOptions.color.withFixedColor + +```jsonnet +standardOptions.color.withFixedColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Stores the fixed color value if mode is fixed +##### fn standardOptions.color.withMode + +```jsonnet +standardOptions.color.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The main color scheme mode +##### fn standardOptions.color.withSeriesBy + +```jsonnet +standardOptions.color.withSeriesBy(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"min"`, `"max"`, `"last"` + +TODO docs +#### obj standardOptions.thresholds + + +##### fn standardOptions.thresholds.withMode + +```jsonnet +standardOptions.thresholds.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"absolute"`, `"percentage"` + + +##### fn standardOptions.thresholds.withSteps + +```jsonnet +standardOptions.thresholds.withSteps(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity +##### fn standardOptions.thresholds.withStepsMixin + +```jsonnet +standardOptions.thresholds.withStepsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/stat/panelOptions/link.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/stat/panelOptions/link.md new file mode 100644 index 0000000000..106f9d2edb --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/stat/panelOptions/link.md @@ -0,0 +1,145 @@ +# link + + + +## Index + +* [`fn withAsDropdown(value=true)`](#fn-withasdropdown) +* [`fn withIcon(value)`](#fn-withicon) +* [`fn withIncludeVars(value=true)`](#fn-withincludevars) +* [`fn withKeepTime(value=true)`](#fn-withkeeptime) +* [`fn withTags(value)`](#fn-withtags) +* [`fn withTagsMixin(value)`](#fn-withtagsmixin) +* [`fn withTargetBlank(value=true)`](#fn-withtargetblank) +* [`fn withTitle(value)`](#fn-withtitle) +* [`fn withTooltip(value)`](#fn-withtooltip) +* [`fn withType(value)`](#fn-withtype) +* [`fn withUrl(value)`](#fn-withurl) + +## Fields + +### fn withAsDropdown + +```jsonnet +withAsDropdown(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withIcon + +```jsonnet +withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withIncludeVars + +```jsonnet +withIncludeVars(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withKeepTime + +```jsonnet +withKeepTime(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTags + +```jsonnet +withTags(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTagsMixin + +```jsonnet +withTagsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTargetBlank + +```jsonnet +withTargetBlank(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTitle + +```jsonnet +withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withTooltip + +```jsonnet +withTooltip(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withType + +```jsonnet +withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"link"`, `"dashboards"` + +TODO docs +### fn withUrl + +```jsonnet +withUrl(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/stat/queryOptions/transformation.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/stat/queryOptions/transformation.md new file mode 100644 index 0000000000..dc832f653d --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/stat/queryOptions/transformation.md @@ -0,0 +1,99 @@ +# transformation + + + +## Index + +* [`fn withDisabled(value=true)`](#fn-withdisabled) +* [`fn withFilter(value)`](#fn-withfilter) +* [`fn withFilterMixin(value)`](#fn-withfiltermixin) +* [`fn withId(value)`](#fn-withid) +* [`fn withOptions(value)`](#fn-withoptions) +* [`obj filter`](#obj-filter) + * [`fn withId(value="")`](#fn-filterwithid) + * [`fn withOptions(value)`](#fn-filterwithoptions) + +## Fields + +### fn withDisabled + +```jsonnet +withDisabled(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Disabled transformations are skipped +### fn withFilter + +```jsonnet +withFilter(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withFilterMixin + +```jsonnet +withFilterMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withId + +```jsonnet +withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Unique identifier of transformer +### fn withOptions + +```jsonnet +withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Options to be passed to the transformer +Valid options depend on the transformer id +### obj filter + + +#### fn filter.withId + +```jsonnet +filter.withId(value="") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `""` + + +#### fn filter.withOptions + +```jsonnet +filter.withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/stat/standardOptions/mapping.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/stat/standardOptions/mapping.md new file mode 100644 index 0000000000..93296972e8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/stat/standardOptions/mapping.md @@ -0,0 +1,469 @@ +# mapping + + + +## Index + +* [`obj RangeMap`](#obj-rangemap) + * [`fn withOptions(value)`](#fn-rangemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-rangemapwithoptionsmixin) + * [`fn withType(value)`](#fn-rangemapwithtype) + * [`obj options`](#obj-rangemapoptions) + * [`fn withFrom(value)`](#fn-rangemapoptionswithfrom) + * [`fn withResult(value)`](#fn-rangemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-rangemapoptionswithresultmixin) + * [`fn withTo(value)`](#fn-rangemapoptionswithto) + * [`obj result`](#obj-rangemapoptionsresult) + * [`fn withColor(value)`](#fn-rangemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-rangemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-rangemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-rangemapoptionsresultwithtext) +* [`obj RegexMap`](#obj-regexmap) + * [`fn withOptions(value)`](#fn-regexmapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-regexmapwithoptionsmixin) + * [`fn withType(value)`](#fn-regexmapwithtype) + * [`obj options`](#obj-regexmapoptions) + * [`fn withPattern(value)`](#fn-regexmapoptionswithpattern) + * [`fn withResult(value)`](#fn-regexmapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-regexmapoptionswithresultmixin) + * [`obj result`](#obj-regexmapoptionsresult) + * [`fn withColor(value)`](#fn-regexmapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-regexmapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-regexmapoptionsresultwithindex) + * [`fn withText(value)`](#fn-regexmapoptionsresultwithtext) +* [`obj SpecialValueMap`](#obj-specialvaluemap) + * [`fn withOptions(value)`](#fn-specialvaluemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-specialvaluemapwithoptionsmixin) + * [`fn withType(value)`](#fn-specialvaluemapwithtype) + * [`obj options`](#obj-specialvaluemapoptions) + * [`fn withMatch(value)`](#fn-specialvaluemapoptionswithmatch) + * [`fn withPattern(value)`](#fn-specialvaluemapoptionswithpattern) + * [`fn withResult(value)`](#fn-specialvaluemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-specialvaluemapoptionswithresultmixin) + * [`obj result`](#obj-specialvaluemapoptionsresult) + * [`fn withColor(value)`](#fn-specialvaluemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-specialvaluemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-specialvaluemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-specialvaluemapoptionsresultwithtext) +* [`obj ValueMap`](#obj-valuemap) + * [`fn withOptions(value)`](#fn-valuemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-valuemapwithoptionsmixin) + * [`fn withType(value)`](#fn-valuemapwithtype) + +## Fields + +### obj RangeMap + + +#### fn RangeMap.withOptions + +```jsonnet +RangeMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withOptionsMixin + +```jsonnet +RangeMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withType + +```jsonnet +RangeMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RangeMap.options + + +##### fn RangeMap.options.withFrom + +```jsonnet +RangeMap.options.withFrom(value) +``` + +PARAMETERS: + +* **value** (`number`) + +to and from are `number | null` in current ts, really not sure what to do +##### fn RangeMap.options.withResult + +```jsonnet +RangeMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withResultMixin + +```jsonnet +RangeMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withTo + +```jsonnet +RangeMap.options.withTo(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +##### obj RangeMap.options.result + + +###### fn RangeMap.options.result.withColor + +```jsonnet +RangeMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIcon + +```jsonnet +RangeMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIndex + +```jsonnet +RangeMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RangeMap.options.result.withText + +```jsonnet +RangeMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj RegexMap + + +#### fn RegexMap.withOptions + +```jsonnet +RegexMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withOptionsMixin + +```jsonnet +RegexMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withType + +```jsonnet +RegexMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RegexMap.options + + +##### fn RegexMap.options.withPattern + +```jsonnet +RegexMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn RegexMap.options.withResult + +```jsonnet +RegexMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RegexMap.options.withResultMixin + +```jsonnet +RegexMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj RegexMap.options.result + + +###### fn RegexMap.options.result.withColor + +```jsonnet +RegexMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIcon + +```jsonnet +RegexMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIndex + +```jsonnet +RegexMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RegexMap.options.result.withText + +```jsonnet +RegexMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj SpecialValueMap + + +#### fn SpecialValueMap.withOptions + +```jsonnet +SpecialValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withOptionsMixin + +```jsonnet +SpecialValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withType + +```jsonnet +SpecialValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj SpecialValueMap.options + + +##### fn SpecialValueMap.options.withMatch + +```jsonnet +SpecialValueMap.options.withMatch(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"true"`, `"false"` + + +##### fn SpecialValueMap.options.withPattern + +```jsonnet +SpecialValueMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn SpecialValueMap.options.withResult + +```jsonnet +SpecialValueMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn SpecialValueMap.options.withResultMixin + +```jsonnet +SpecialValueMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj SpecialValueMap.options.result + + +###### fn SpecialValueMap.options.result.withColor + +```jsonnet +SpecialValueMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIcon + +```jsonnet +SpecialValueMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIndex + +```jsonnet +SpecialValueMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn SpecialValueMap.options.result.withText + +```jsonnet +SpecialValueMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj ValueMap + + +#### fn ValueMap.withOptions + +```jsonnet +ValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withOptionsMixin + +```jsonnet +ValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withType + +```jsonnet +ValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/stat/standardOptions/override.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/stat/standardOptions/override.md new file mode 100644 index 0000000000..154f3dbdac --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/stat/standardOptions/override.md @@ -0,0 +1,244 @@ +# override + +Overrides allow you to customize visualization settings for specific fields or +series. This is accomplished by adding an override rule that targets +a particular set of fields and that can each define multiple options. + +```jsonnet +override.byType.new('number') ++ override.byType.withPropertiesFromOptions( + panel.standardOptions.withDecimals(2) + + panel.standardOptions.withUnit('s') +) +``` + + +## Index + +* [`obj byName`](#obj-byname) + * [`fn new(value)`](#fn-bynamenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bynamewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bynamewithproperty) +* [`obj byQuery`](#obj-byquery) + * [`fn new(value)`](#fn-byquerynew) + * [`fn withPropertiesFromOptions(options)`](#fn-byquerywithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byquerywithproperty) +* [`obj byRegexp`](#obj-byregexp) + * [`fn new(value)`](#fn-byregexpnew) + * [`fn withPropertiesFromOptions(options)`](#fn-byregexpwithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byregexpwithproperty) +* [`obj byType`](#obj-bytype) + * [`fn new(value)`](#fn-bytypenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bytypewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bytypewithproperty) +* [`obj byValue`](#obj-byvalue) + * [`fn new(value)`](#fn-byvaluenew) + * [`fn withPropertiesFromOptions(options)`](#fn-byvaluewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byvaluewithproperty) + +## Fields + +### obj byName + + +#### fn byName.new + +```jsonnet +byName.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byName`. +#### fn byName.withPropertiesFromOptions + +```jsonnet +byName.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byName.withProperty + +```jsonnet +byName.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byQuery + + +#### fn byQuery.new + +```jsonnet +byQuery.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byQuery`. +#### fn byQuery.withPropertiesFromOptions + +```jsonnet +byQuery.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byQuery.withProperty + +```jsonnet +byQuery.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byRegexp + + +#### fn byRegexp.new + +```jsonnet +byRegexp.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byRegexp`. +#### fn byRegexp.withPropertiesFromOptions + +```jsonnet +byRegexp.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byRegexp.withProperty + +```jsonnet +byRegexp.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byType + + +#### fn byType.new + +```jsonnet +byType.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byType`. +#### fn byType.withPropertiesFromOptions + +```jsonnet +byType.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byType.withProperty + +```jsonnet +byType.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byValue + + +#### fn byValue.new + +```jsonnet +byValue.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byValue`. +#### fn byValue.withPropertiesFromOptions + +```jsonnet +byValue.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byValue.withProperty + +```jsonnet +byValue.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/stat/standardOptions/threshold/step.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/stat/standardOptions/threshold/step.md new file mode 100644 index 0000000000..dd2dd227ff --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/stat/standardOptions/threshold/step.md @@ -0,0 +1,60 @@ +# threshold.step + + + +## Index + +* [`fn withColor(value)`](#fn-withcolor) +* [`fn withIndex(value)`](#fn-withindex) +* [`fn withState(value)`](#fn-withstate) +* [`fn withValue(value)`](#fn-withvalue) + +## Fields + +### fn withColor + +```jsonnet +withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +### fn withIndex + +```jsonnet +withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Threshold index, an old property that is not needed an should only appear in older dashboards +### fn withState + +```jsonnet +withState(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO are the values here enumerable into a disjunction? +Some seem to be listed in typescript comment +### fn withValue + +```jsonnet +withValue(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +FIXME the corresponding typescript field is required/non-optional, but nulls currently appear here when serializing -Infinity to JSON \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/stateTimeline/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/stateTimeline/index.md new file mode 100644 index 0000000000..091ed33bd8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/stateTimeline/index.md @@ -0,0 +1,956 @@ +# stateTimeline + +grafonnet.panel.stateTimeline + +## Subpackages + +* [panelOptions.link](panelOptions/link.md) +* [queryOptions.transformation](queryOptions/transformation.md) +* [standardOptions.mapping](standardOptions/mapping.md) +* [standardOptions.override](standardOptions/override.md) +* [standardOptions.threshold.step](standardOptions/threshold/step.md) + +## Index + +* [`fn new(title)`](#fn-new) +* [`obj fieldConfig`](#obj-fieldconfig) + * [`obj defaults`](#obj-fieldconfigdefaults) + * [`obj custom`](#obj-fieldconfigdefaultscustom) + * [`fn withFillOpacity(value=70)`](#fn-fieldconfigdefaultscustomwithfillopacity) + * [`fn withHideFrom(value)`](#fn-fieldconfigdefaultscustomwithhidefrom) + * [`fn withHideFromMixin(value)`](#fn-fieldconfigdefaultscustomwithhidefrommixin) + * [`fn withLineWidth(value=0)`](#fn-fieldconfigdefaultscustomwithlinewidth) + * [`obj hideFrom`](#obj-fieldconfigdefaultscustomhidefrom) + * [`fn withLegend(value=true)`](#fn-fieldconfigdefaultscustomhidefromwithlegend) + * [`fn withTooltip(value=true)`](#fn-fieldconfigdefaultscustomhidefromwithtooltip) + * [`fn withViz(value=true)`](#fn-fieldconfigdefaultscustomhidefromwithviz) +* [`obj libraryPanel`](#obj-librarypanel) + * [`fn withName(value)`](#fn-librarypanelwithname) + * [`fn withUid(value)`](#fn-librarypanelwithuid) +* [`obj options`](#obj-options) + * [`fn withAlignValue(value)`](#fn-optionswithalignvalue) + * [`fn withLegend(value)`](#fn-optionswithlegend) + * [`fn withLegendMixin(value)`](#fn-optionswithlegendmixin) + * [`fn withMergeValues(value=true)`](#fn-optionswithmergevalues) + * [`fn withRowHeight(value=0.9)`](#fn-optionswithrowheight) + * [`fn withShowValue(value)`](#fn-optionswithshowvalue) + * [`fn withTimezone(value)`](#fn-optionswithtimezone) + * [`fn withTimezoneMixin(value)`](#fn-optionswithtimezonemixin) + * [`fn withTooltip(value)`](#fn-optionswithtooltip) + * [`fn withTooltipMixin(value)`](#fn-optionswithtooltipmixin) + * [`obj legend`](#obj-optionslegend) + * [`fn withAsTable(value=true)`](#fn-optionslegendwithastable) + * [`fn withCalcs(value)`](#fn-optionslegendwithcalcs) + * [`fn withCalcsMixin(value)`](#fn-optionslegendwithcalcsmixin) + * [`fn withDisplayMode(value)`](#fn-optionslegendwithdisplaymode) + * [`fn withIsVisible(value=true)`](#fn-optionslegendwithisvisible) + * [`fn withPlacement(value)`](#fn-optionslegendwithplacement) + * [`fn withShowLegend(value=true)`](#fn-optionslegendwithshowlegend) + * [`fn withSortBy(value)`](#fn-optionslegendwithsortby) + * [`fn withSortDesc(value=true)`](#fn-optionslegendwithsortdesc) + * [`fn withWidth(value)`](#fn-optionslegendwithwidth) + * [`obj tooltip`](#obj-optionstooltip) + * [`fn withMode(value)`](#fn-optionstooltipwithmode) + * [`fn withSort(value)`](#fn-optionstooltipwithsort) +* [`obj panelOptions`](#obj-paneloptions) + * [`fn withDescription(value)`](#fn-paneloptionswithdescription) + * [`fn withGridPos(h="null", w="null", x="null", y="null")`](#fn-paneloptionswithgridpos) + * [`fn withLinks(value)`](#fn-paneloptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-paneloptionswithlinksmixin) + * [`fn withRepeat(value)`](#fn-paneloptionswithrepeat) + * [`fn withRepeatDirection(value="h")`](#fn-paneloptionswithrepeatdirection) + * [`fn withTitle(value)`](#fn-paneloptionswithtitle) + * [`fn withTransparent(value=true)`](#fn-paneloptionswithtransparent) +* [`obj queryOptions`](#obj-queryoptions) + * [`fn withDatasource(type, uid)`](#fn-queryoptionswithdatasource) + * [`fn withDatasourceMixin(value)`](#fn-queryoptionswithdatasourcemixin) + * [`fn withInterval(value)`](#fn-queryoptionswithinterval) + * [`fn withMaxDataPoints(value)`](#fn-queryoptionswithmaxdatapoints) + * [`fn withTargets(value)`](#fn-queryoptionswithtargets) + * [`fn withTargetsMixin(value)`](#fn-queryoptionswithtargetsmixin) + * [`fn withTimeFrom(value)`](#fn-queryoptionswithtimefrom) + * [`fn withTimeShift(value)`](#fn-queryoptionswithtimeshift) + * [`fn withTransformations(value)`](#fn-queryoptionswithtransformations) + * [`fn withTransformationsMixin(value)`](#fn-queryoptionswithtransformationsmixin) +* [`obj standardOptions`](#obj-standardoptions) + * [`fn withDecimals(value)`](#fn-standardoptionswithdecimals) + * [`fn withDisplayName(value)`](#fn-standardoptionswithdisplayname) + * [`fn withFilterable(value=true)`](#fn-standardoptionswithfilterable) + * [`fn withLinks(value)`](#fn-standardoptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-standardoptionswithlinksmixin) + * [`fn withMappings(value)`](#fn-standardoptionswithmappings) + * [`fn withMappingsMixin(value)`](#fn-standardoptionswithmappingsmixin) + * [`fn withMax(value)`](#fn-standardoptionswithmax) + * [`fn withMin(value)`](#fn-standardoptionswithmin) + * [`fn withNoValue(value)`](#fn-standardoptionswithnovalue) + * [`fn withOverrides(value)`](#fn-standardoptionswithoverrides) + * [`fn withOverridesMixin(value)`](#fn-standardoptionswithoverridesmixin) + * [`fn withPath(value)`](#fn-standardoptionswithpath) + * [`fn withUnit(value)`](#fn-standardoptionswithunit) + * [`obj color`](#obj-standardoptionscolor) + * [`fn withFixedColor(value)`](#fn-standardoptionscolorwithfixedcolor) + * [`fn withMode(value)`](#fn-standardoptionscolorwithmode) + * [`fn withSeriesBy(value)`](#fn-standardoptionscolorwithseriesby) + * [`obj thresholds`](#obj-standardoptionsthresholds) + * [`fn withMode(value)`](#fn-standardoptionsthresholdswithmode) + * [`fn withSteps(value)`](#fn-standardoptionsthresholdswithsteps) + * [`fn withStepsMixin(value)`](#fn-standardoptionsthresholdswithstepsmixin) + +## Fields + +### fn new + +```jsonnet +new(title) +``` + +PARAMETERS: + +* **title** (`string`) + +Creates a new stateTimeline panel with a title. +### obj fieldConfig + + +#### obj fieldConfig.defaults + + +##### obj fieldConfig.defaults.custom + + +###### fn fieldConfig.defaults.custom.withFillOpacity + +```jsonnet +fieldConfig.defaults.custom.withFillOpacity(value=70) +``` + +PARAMETERS: + +* **value** (`integer`) + - default value: `70` + + +###### fn fieldConfig.defaults.custom.withHideFrom + +```jsonnet +fieldConfig.defaults.custom.withHideFrom(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn fieldConfig.defaults.custom.withHideFromMixin + +```jsonnet +fieldConfig.defaults.custom.withHideFromMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn fieldConfig.defaults.custom.withLineWidth + +```jsonnet +fieldConfig.defaults.custom.withLineWidth(value=0) +``` + +PARAMETERS: + +* **value** (`integer`) + - default value: `0` + + +###### obj fieldConfig.defaults.custom.hideFrom + + +####### fn fieldConfig.defaults.custom.hideFrom.withLegend + +```jsonnet +fieldConfig.defaults.custom.hideFrom.withLegend(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +####### fn fieldConfig.defaults.custom.hideFrom.withTooltip + +```jsonnet +fieldConfig.defaults.custom.hideFrom.withTooltip(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +####### fn fieldConfig.defaults.custom.hideFrom.withViz + +```jsonnet +fieldConfig.defaults.custom.hideFrom.withViz(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### obj libraryPanel + + +#### fn libraryPanel.withName + +```jsonnet +libraryPanel.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn libraryPanel.withUid + +```jsonnet +libraryPanel.withUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj options + + +#### fn options.withAlignValue + +```jsonnet +options.withAlignValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Controls value alignment on the timelines +#### fn options.withLegend + +```jsonnet +options.withLegend(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withLegendMixin + +```jsonnet +options.withLegendMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withMergeValues + +```jsonnet +options.withMergeValues(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Merge equal consecutive values +#### fn options.withRowHeight + +```jsonnet +options.withRowHeight(value=0.9) +``` + +PARAMETERS: + +* **value** (`number`) + - default value: `0.9` + +Controls the row height +#### fn options.withShowValue + +```jsonnet +options.withShowValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Show timeline values on chart +#### fn options.withTimezone + +```jsonnet +options.withTimezone(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn options.withTimezoneMixin + +```jsonnet +options.withTimezoneMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn options.withTooltip + +```jsonnet +options.withTooltip(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withTooltipMixin + +```jsonnet +options.withTooltipMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### obj options.legend + + +##### fn options.legend.withAsTable + +```jsonnet +options.legend.withAsTable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.legend.withCalcs + +```jsonnet +options.legend.withCalcs(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +##### fn options.legend.withCalcsMixin + +```jsonnet +options.legend.withCalcsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +##### fn options.legend.withDisplayMode + +```jsonnet +options.legend.withDisplayMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"list"`, `"table"`, `"hidden"` + +TODO docs +Note: "hidden" needs to remain as an option for plugins compatibility +##### fn options.legend.withIsVisible + +```jsonnet +options.legend.withIsVisible(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.legend.withPlacement + +```jsonnet +options.legend.withPlacement(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"bottom"`, `"right"` + +TODO docs +##### fn options.legend.withShowLegend + +```jsonnet +options.legend.withShowLegend(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.legend.withSortBy + +```jsonnet +options.legend.withSortBy(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn options.legend.withSortDesc + +```jsonnet +options.legend.withSortDesc(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.legend.withWidth + +```jsonnet +options.legend.withWidth(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### obj options.tooltip + + +##### fn options.tooltip.withMode + +```jsonnet +options.tooltip.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"single"`, `"multi"`, `"none"` + +TODO docs +##### fn options.tooltip.withSort + +```jsonnet +options.tooltip.withSort(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"asc"`, `"desc"`, `"none"` + +TODO docs +### obj panelOptions + + +#### fn panelOptions.withDescription + +```jsonnet +panelOptions.withDescription(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Description. +#### fn panelOptions.withGridPos + +```jsonnet +panelOptions.withGridPos(h="null", w="null", x="null", y="null") +``` + +PARAMETERS: + +* **h** (`number`) + - default value: `"null"` +* **w** (`number`) + - default value: `"null"` +* **x** (`number`) + - default value: `"null"` +* **y** (`number`) + - default value: `"null"` + +`withGridPos` configures the height, width and xy coordinates of the panel. Also see `grafonnet.util.grid` for helper functions to calculate these fields. + +All arguments default to `null`, which means they will remain unchanged or unset. + +#### fn panelOptions.withLinks + +```jsonnet +panelOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withLinksMixin + +```jsonnet +panelOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withRepeat + +```jsonnet +panelOptions.withRepeat(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of template variable to repeat for. +#### fn panelOptions.withRepeatDirection + +```jsonnet +panelOptions.withRepeatDirection(value="h") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"h"` + - valid values: `"h"`, `"v"` + +Direction to repeat in if 'repeat' is set. +"h" for horizontal, "v" for vertical. +TODO this is probably optional +#### fn panelOptions.withTitle + +```jsonnet +panelOptions.withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Panel title. +#### fn panelOptions.withTransparent + +```jsonnet +panelOptions.withTransparent(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Whether to display the panel without a background. +### obj queryOptions + + +#### fn queryOptions.withDatasource + +```jsonnet +queryOptions.withDatasource(type, uid) +``` + +PARAMETERS: + +* **type** (`string`) +* **uid** (`string`) + +`withDatasource` sets the datasource for all queries in a panel. + +The default datasource for a panel is set to 'Mixed datasource' so panels can be datasource agnostic, which is a lot more interesting from a reusability standpoint. Note that this requires query targets to explicitly set datasource for the same reason. + +#### fn queryOptions.withDatasourceMixin + +```jsonnet +queryOptions.withDatasourceMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +The datasource used in all targets. +#### fn queryOptions.withInterval + +```jsonnet +queryOptions.withInterval(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withMaxDataPoints + +```jsonnet +queryOptions.withMaxDataPoints(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +#### fn queryOptions.withTargets + +```jsonnet +queryOptions.withTargets(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTargetsMixin + +```jsonnet +queryOptions.withTargetsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTimeFrom + +```jsonnet +queryOptions.withTimeFrom(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTimeShift + +```jsonnet +queryOptions.withTimeShift(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTransformations + +```jsonnet +queryOptions.withTransformations(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn queryOptions.withTransformationsMixin + +```jsonnet +queryOptions.withTransformationsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### obj standardOptions + + +#### fn standardOptions.withDecimals + +```jsonnet +standardOptions.withDecimals(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Significant digits (for display) +#### fn standardOptions.withDisplayName + +```jsonnet +standardOptions.withDisplayName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The display value for this field. This supports template variables blank is auto +#### fn standardOptions.withFilterable + +```jsonnet +standardOptions.withFilterable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +True if data source field supports ad-hoc filters +#### fn standardOptions.withLinks + +```jsonnet +standardOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withLinksMixin + +```jsonnet +standardOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withMappings + +```jsonnet +standardOptions.withMappings(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMappingsMixin + +```jsonnet +standardOptions.withMappingsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMax + +```jsonnet +standardOptions.withMax(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withMin + +```jsonnet +standardOptions.withMin(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withNoValue + +```jsonnet +standardOptions.withNoValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Alternative to empty string +#### fn standardOptions.withOverrides + +```jsonnet +standardOptions.withOverrides(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withOverridesMixin + +```jsonnet +standardOptions.withOverridesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withPath + +```jsonnet +standardOptions.withPath(value) +``` + +PARAMETERS: + +* **value** (`string`) + +An explicit path to the field in the datasource. When the frame meta includes a path, +This will default to `${frame.meta.path}/${field.name} + +When defined, this value can be used as an identifier within the datasource scope, and +may be used to update the results +#### fn standardOptions.withUnit + +```jsonnet +standardOptions.withUnit(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Numeric Options +#### obj standardOptions.color + + +##### fn standardOptions.color.withFixedColor + +```jsonnet +standardOptions.color.withFixedColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Stores the fixed color value if mode is fixed +##### fn standardOptions.color.withMode + +```jsonnet +standardOptions.color.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The main color scheme mode +##### fn standardOptions.color.withSeriesBy + +```jsonnet +standardOptions.color.withSeriesBy(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"min"`, `"max"`, `"last"` + +TODO docs +#### obj standardOptions.thresholds + + +##### fn standardOptions.thresholds.withMode + +```jsonnet +standardOptions.thresholds.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"absolute"`, `"percentage"` + + +##### fn standardOptions.thresholds.withSteps + +```jsonnet +standardOptions.thresholds.withSteps(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity +##### fn standardOptions.thresholds.withStepsMixin + +```jsonnet +standardOptions.thresholds.withStepsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/stateTimeline/panelOptions/link.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/stateTimeline/panelOptions/link.md new file mode 100644 index 0000000000..106f9d2edb --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/stateTimeline/panelOptions/link.md @@ -0,0 +1,145 @@ +# link + + + +## Index + +* [`fn withAsDropdown(value=true)`](#fn-withasdropdown) +* [`fn withIcon(value)`](#fn-withicon) +* [`fn withIncludeVars(value=true)`](#fn-withincludevars) +* [`fn withKeepTime(value=true)`](#fn-withkeeptime) +* [`fn withTags(value)`](#fn-withtags) +* [`fn withTagsMixin(value)`](#fn-withtagsmixin) +* [`fn withTargetBlank(value=true)`](#fn-withtargetblank) +* [`fn withTitle(value)`](#fn-withtitle) +* [`fn withTooltip(value)`](#fn-withtooltip) +* [`fn withType(value)`](#fn-withtype) +* [`fn withUrl(value)`](#fn-withurl) + +## Fields + +### fn withAsDropdown + +```jsonnet +withAsDropdown(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withIcon + +```jsonnet +withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withIncludeVars + +```jsonnet +withIncludeVars(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withKeepTime + +```jsonnet +withKeepTime(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTags + +```jsonnet +withTags(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTagsMixin + +```jsonnet +withTagsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTargetBlank + +```jsonnet +withTargetBlank(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTitle + +```jsonnet +withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withTooltip + +```jsonnet +withTooltip(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withType + +```jsonnet +withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"link"`, `"dashboards"` + +TODO docs +### fn withUrl + +```jsonnet +withUrl(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/stateTimeline/queryOptions/transformation.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/stateTimeline/queryOptions/transformation.md new file mode 100644 index 0000000000..dc832f653d --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/stateTimeline/queryOptions/transformation.md @@ -0,0 +1,99 @@ +# transformation + + + +## Index + +* [`fn withDisabled(value=true)`](#fn-withdisabled) +* [`fn withFilter(value)`](#fn-withfilter) +* [`fn withFilterMixin(value)`](#fn-withfiltermixin) +* [`fn withId(value)`](#fn-withid) +* [`fn withOptions(value)`](#fn-withoptions) +* [`obj filter`](#obj-filter) + * [`fn withId(value="")`](#fn-filterwithid) + * [`fn withOptions(value)`](#fn-filterwithoptions) + +## Fields + +### fn withDisabled + +```jsonnet +withDisabled(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Disabled transformations are skipped +### fn withFilter + +```jsonnet +withFilter(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withFilterMixin + +```jsonnet +withFilterMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withId + +```jsonnet +withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Unique identifier of transformer +### fn withOptions + +```jsonnet +withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Options to be passed to the transformer +Valid options depend on the transformer id +### obj filter + + +#### fn filter.withId + +```jsonnet +filter.withId(value="") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `""` + + +#### fn filter.withOptions + +```jsonnet +filter.withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/stateTimeline/standardOptions/mapping.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/stateTimeline/standardOptions/mapping.md new file mode 100644 index 0000000000..93296972e8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/stateTimeline/standardOptions/mapping.md @@ -0,0 +1,469 @@ +# mapping + + + +## Index + +* [`obj RangeMap`](#obj-rangemap) + * [`fn withOptions(value)`](#fn-rangemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-rangemapwithoptionsmixin) + * [`fn withType(value)`](#fn-rangemapwithtype) + * [`obj options`](#obj-rangemapoptions) + * [`fn withFrom(value)`](#fn-rangemapoptionswithfrom) + * [`fn withResult(value)`](#fn-rangemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-rangemapoptionswithresultmixin) + * [`fn withTo(value)`](#fn-rangemapoptionswithto) + * [`obj result`](#obj-rangemapoptionsresult) + * [`fn withColor(value)`](#fn-rangemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-rangemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-rangemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-rangemapoptionsresultwithtext) +* [`obj RegexMap`](#obj-regexmap) + * [`fn withOptions(value)`](#fn-regexmapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-regexmapwithoptionsmixin) + * [`fn withType(value)`](#fn-regexmapwithtype) + * [`obj options`](#obj-regexmapoptions) + * [`fn withPattern(value)`](#fn-regexmapoptionswithpattern) + * [`fn withResult(value)`](#fn-regexmapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-regexmapoptionswithresultmixin) + * [`obj result`](#obj-regexmapoptionsresult) + * [`fn withColor(value)`](#fn-regexmapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-regexmapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-regexmapoptionsresultwithindex) + * [`fn withText(value)`](#fn-regexmapoptionsresultwithtext) +* [`obj SpecialValueMap`](#obj-specialvaluemap) + * [`fn withOptions(value)`](#fn-specialvaluemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-specialvaluemapwithoptionsmixin) + * [`fn withType(value)`](#fn-specialvaluemapwithtype) + * [`obj options`](#obj-specialvaluemapoptions) + * [`fn withMatch(value)`](#fn-specialvaluemapoptionswithmatch) + * [`fn withPattern(value)`](#fn-specialvaluemapoptionswithpattern) + * [`fn withResult(value)`](#fn-specialvaluemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-specialvaluemapoptionswithresultmixin) + * [`obj result`](#obj-specialvaluemapoptionsresult) + * [`fn withColor(value)`](#fn-specialvaluemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-specialvaluemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-specialvaluemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-specialvaluemapoptionsresultwithtext) +* [`obj ValueMap`](#obj-valuemap) + * [`fn withOptions(value)`](#fn-valuemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-valuemapwithoptionsmixin) + * [`fn withType(value)`](#fn-valuemapwithtype) + +## Fields + +### obj RangeMap + + +#### fn RangeMap.withOptions + +```jsonnet +RangeMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withOptionsMixin + +```jsonnet +RangeMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withType + +```jsonnet +RangeMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RangeMap.options + + +##### fn RangeMap.options.withFrom + +```jsonnet +RangeMap.options.withFrom(value) +``` + +PARAMETERS: + +* **value** (`number`) + +to and from are `number | null` in current ts, really not sure what to do +##### fn RangeMap.options.withResult + +```jsonnet +RangeMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withResultMixin + +```jsonnet +RangeMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withTo + +```jsonnet +RangeMap.options.withTo(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +##### obj RangeMap.options.result + + +###### fn RangeMap.options.result.withColor + +```jsonnet +RangeMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIcon + +```jsonnet +RangeMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIndex + +```jsonnet +RangeMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RangeMap.options.result.withText + +```jsonnet +RangeMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj RegexMap + + +#### fn RegexMap.withOptions + +```jsonnet +RegexMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withOptionsMixin + +```jsonnet +RegexMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withType + +```jsonnet +RegexMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RegexMap.options + + +##### fn RegexMap.options.withPattern + +```jsonnet +RegexMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn RegexMap.options.withResult + +```jsonnet +RegexMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RegexMap.options.withResultMixin + +```jsonnet +RegexMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj RegexMap.options.result + + +###### fn RegexMap.options.result.withColor + +```jsonnet +RegexMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIcon + +```jsonnet +RegexMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIndex + +```jsonnet +RegexMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RegexMap.options.result.withText + +```jsonnet +RegexMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj SpecialValueMap + + +#### fn SpecialValueMap.withOptions + +```jsonnet +SpecialValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withOptionsMixin + +```jsonnet +SpecialValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withType + +```jsonnet +SpecialValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj SpecialValueMap.options + + +##### fn SpecialValueMap.options.withMatch + +```jsonnet +SpecialValueMap.options.withMatch(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"true"`, `"false"` + + +##### fn SpecialValueMap.options.withPattern + +```jsonnet +SpecialValueMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn SpecialValueMap.options.withResult + +```jsonnet +SpecialValueMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn SpecialValueMap.options.withResultMixin + +```jsonnet +SpecialValueMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj SpecialValueMap.options.result + + +###### fn SpecialValueMap.options.result.withColor + +```jsonnet +SpecialValueMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIcon + +```jsonnet +SpecialValueMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIndex + +```jsonnet +SpecialValueMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn SpecialValueMap.options.result.withText + +```jsonnet +SpecialValueMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj ValueMap + + +#### fn ValueMap.withOptions + +```jsonnet +ValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withOptionsMixin + +```jsonnet +ValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withType + +```jsonnet +ValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/stateTimeline/standardOptions/override.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/stateTimeline/standardOptions/override.md new file mode 100644 index 0000000000..154f3dbdac --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/stateTimeline/standardOptions/override.md @@ -0,0 +1,244 @@ +# override + +Overrides allow you to customize visualization settings for specific fields or +series. This is accomplished by adding an override rule that targets +a particular set of fields and that can each define multiple options. + +```jsonnet +override.byType.new('number') ++ override.byType.withPropertiesFromOptions( + panel.standardOptions.withDecimals(2) + + panel.standardOptions.withUnit('s') +) +``` + + +## Index + +* [`obj byName`](#obj-byname) + * [`fn new(value)`](#fn-bynamenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bynamewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bynamewithproperty) +* [`obj byQuery`](#obj-byquery) + * [`fn new(value)`](#fn-byquerynew) + * [`fn withPropertiesFromOptions(options)`](#fn-byquerywithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byquerywithproperty) +* [`obj byRegexp`](#obj-byregexp) + * [`fn new(value)`](#fn-byregexpnew) + * [`fn withPropertiesFromOptions(options)`](#fn-byregexpwithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byregexpwithproperty) +* [`obj byType`](#obj-bytype) + * [`fn new(value)`](#fn-bytypenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bytypewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bytypewithproperty) +* [`obj byValue`](#obj-byvalue) + * [`fn new(value)`](#fn-byvaluenew) + * [`fn withPropertiesFromOptions(options)`](#fn-byvaluewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byvaluewithproperty) + +## Fields + +### obj byName + + +#### fn byName.new + +```jsonnet +byName.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byName`. +#### fn byName.withPropertiesFromOptions + +```jsonnet +byName.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byName.withProperty + +```jsonnet +byName.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byQuery + + +#### fn byQuery.new + +```jsonnet +byQuery.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byQuery`. +#### fn byQuery.withPropertiesFromOptions + +```jsonnet +byQuery.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byQuery.withProperty + +```jsonnet +byQuery.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byRegexp + + +#### fn byRegexp.new + +```jsonnet +byRegexp.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byRegexp`. +#### fn byRegexp.withPropertiesFromOptions + +```jsonnet +byRegexp.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byRegexp.withProperty + +```jsonnet +byRegexp.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byType + + +#### fn byType.new + +```jsonnet +byType.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byType`. +#### fn byType.withPropertiesFromOptions + +```jsonnet +byType.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byType.withProperty + +```jsonnet +byType.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byValue + + +#### fn byValue.new + +```jsonnet +byValue.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byValue`. +#### fn byValue.withPropertiesFromOptions + +```jsonnet +byValue.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byValue.withProperty + +```jsonnet +byValue.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/stateTimeline/standardOptions/threshold/step.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/stateTimeline/standardOptions/threshold/step.md new file mode 100644 index 0000000000..dd2dd227ff --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/stateTimeline/standardOptions/threshold/step.md @@ -0,0 +1,60 @@ +# threshold.step + + + +## Index + +* [`fn withColor(value)`](#fn-withcolor) +* [`fn withIndex(value)`](#fn-withindex) +* [`fn withState(value)`](#fn-withstate) +* [`fn withValue(value)`](#fn-withvalue) + +## Fields + +### fn withColor + +```jsonnet +withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +### fn withIndex + +```jsonnet +withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Threshold index, an old property that is not needed an should only appear in older dashboards +### fn withState + +```jsonnet +withState(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO are the values here enumerable into a disjunction? +Some seem to be listed in typescript comment +### fn withValue + +```jsonnet +withValue(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +FIXME the corresponding typescript field is required/non-optional, but nulls currently appear here when serializing -Infinity to JSON \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/statusHistory/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/statusHistory/index.md new file mode 100644 index 0000000000..c0b81780d2 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/statusHistory/index.md @@ -0,0 +1,944 @@ +# statusHistory + +grafonnet.panel.statusHistory + +## Subpackages + +* [panelOptions.link](panelOptions/link.md) +* [queryOptions.transformation](queryOptions/transformation.md) +* [standardOptions.mapping](standardOptions/mapping.md) +* [standardOptions.override](standardOptions/override.md) +* [standardOptions.threshold.step](standardOptions/threshold/step.md) + +## Index + +* [`fn new(title)`](#fn-new) +* [`obj fieldConfig`](#obj-fieldconfig) + * [`obj defaults`](#obj-fieldconfigdefaults) + * [`obj custom`](#obj-fieldconfigdefaultscustom) + * [`fn withFillOpacity(value=70)`](#fn-fieldconfigdefaultscustomwithfillopacity) + * [`fn withHideFrom(value)`](#fn-fieldconfigdefaultscustomwithhidefrom) + * [`fn withHideFromMixin(value)`](#fn-fieldconfigdefaultscustomwithhidefrommixin) + * [`fn withLineWidth(value=1)`](#fn-fieldconfigdefaultscustomwithlinewidth) + * [`obj hideFrom`](#obj-fieldconfigdefaultscustomhidefrom) + * [`fn withLegend(value=true)`](#fn-fieldconfigdefaultscustomhidefromwithlegend) + * [`fn withTooltip(value=true)`](#fn-fieldconfigdefaultscustomhidefromwithtooltip) + * [`fn withViz(value=true)`](#fn-fieldconfigdefaultscustomhidefromwithviz) +* [`obj libraryPanel`](#obj-librarypanel) + * [`fn withName(value)`](#fn-librarypanelwithname) + * [`fn withUid(value)`](#fn-librarypanelwithuid) +* [`obj options`](#obj-options) + * [`fn withColWidth(value=0.9)`](#fn-optionswithcolwidth) + * [`fn withLegend(value)`](#fn-optionswithlegend) + * [`fn withLegendMixin(value)`](#fn-optionswithlegendmixin) + * [`fn withRowHeight(value=0.9)`](#fn-optionswithrowheight) + * [`fn withShowValue(value)`](#fn-optionswithshowvalue) + * [`fn withTimezone(value)`](#fn-optionswithtimezone) + * [`fn withTimezoneMixin(value)`](#fn-optionswithtimezonemixin) + * [`fn withTooltip(value)`](#fn-optionswithtooltip) + * [`fn withTooltipMixin(value)`](#fn-optionswithtooltipmixin) + * [`obj legend`](#obj-optionslegend) + * [`fn withAsTable(value=true)`](#fn-optionslegendwithastable) + * [`fn withCalcs(value)`](#fn-optionslegendwithcalcs) + * [`fn withCalcsMixin(value)`](#fn-optionslegendwithcalcsmixin) + * [`fn withDisplayMode(value)`](#fn-optionslegendwithdisplaymode) + * [`fn withIsVisible(value=true)`](#fn-optionslegendwithisvisible) + * [`fn withPlacement(value)`](#fn-optionslegendwithplacement) + * [`fn withShowLegend(value=true)`](#fn-optionslegendwithshowlegend) + * [`fn withSortBy(value)`](#fn-optionslegendwithsortby) + * [`fn withSortDesc(value=true)`](#fn-optionslegendwithsortdesc) + * [`fn withWidth(value)`](#fn-optionslegendwithwidth) + * [`obj tooltip`](#obj-optionstooltip) + * [`fn withMode(value)`](#fn-optionstooltipwithmode) + * [`fn withSort(value)`](#fn-optionstooltipwithsort) +* [`obj panelOptions`](#obj-paneloptions) + * [`fn withDescription(value)`](#fn-paneloptionswithdescription) + * [`fn withGridPos(h="null", w="null", x="null", y="null")`](#fn-paneloptionswithgridpos) + * [`fn withLinks(value)`](#fn-paneloptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-paneloptionswithlinksmixin) + * [`fn withRepeat(value)`](#fn-paneloptionswithrepeat) + * [`fn withRepeatDirection(value="h")`](#fn-paneloptionswithrepeatdirection) + * [`fn withTitle(value)`](#fn-paneloptionswithtitle) + * [`fn withTransparent(value=true)`](#fn-paneloptionswithtransparent) +* [`obj queryOptions`](#obj-queryoptions) + * [`fn withDatasource(type, uid)`](#fn-queryoptionswithdatasource) + * [`fn withDatasourceMixin(value)`](#fn-queryoptionswithdatasourcemixin) + * [`fn withInterval(value)`](#fn-queryoptionswithinterval) + * [`fn withMaxDataPoints(value)`](#fn-queryoptionswithmaxdatapoints) + * [`fn withTargets(value)`](#fn-queryoptionswithtargets) + * [`fn withTargetsMixin(value)`](#fn-queryoptionswithtargetsmixin) + * [`fn withTimeFrom(value)`](#fn-queryoptionswithtimefrom) + * [`fn withTimeShift(value)`](#fn-queryoptionswithtimeshift) + * [`fn withTransformations(value)`](#fn-queryoptionswithtransformations) + * [`fn withTransformationsMixin(value)`](#fn-queryoptionswithtransformationsmixin) +* [`obj standardOptions`](#obj-standardoptions) + * [`fn withDecimals(value)`](#fn-standardoptionswithdecimals) + * [`fn withDisplayName(value)`](#fn-standardoptionswithdisplayname) + * [`fn withFilterable(value=true)`](#fn-standardoptionswithfilterable) + * [`fn withLinks(value)`](#fn-standardoptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-standardoptionswithlinksmixin) + * [`fn withMappings(value)`](#fn-standardoptionswithmappings) + * [`fn withMappingsMixin(value)`](#fn-standardoptionswithmappingsmixin) + * [`fn withMax(value)`](#fn-standardoptionswithmax) + * [`fn withMin(value)`](#fn-standardoptionswithmin) + * [`fn withNoValue(value)`](#fn-standardoptionswithnovalue) + * [`fn withOverrides(value)`](#fn-standardoptionswithoverrides) + * [`fn withOverridesMixin(value)`](#fn-standardoptionswithoverridesmixin) + * [`fn withPath(value)`](#fn-standardoptionswithpath) + * [`fn withUnit(value)`](#fn-standardoptionswithunit) + * [`obj color`](#obj-standardoptionscolor) + * [`fn withFixedColor(value)`](#fn-standardoptionscolorwithfixedcolor) + * [`fn withMode(value)`](#fn-standardoptionscolorwithmode) + * [`fn withSeriesBy(value)`](#fn-standardoptionscolorwithseriesby) + * [`obj thresholds`](#obj-standardoptionsthresholds) + * [`fn withMode(value)`](#fn-standardoptionsthresholdswithmode) + * [`fn withSteps(value)`](#fn-standardoptionsthresholdswithsteps) + * [`fn withStepsMixin(value)`](#fn-standardoptionsthresholdswithstepsmixin) + +## Fields + +### fn new + +```jsonnet +new(title) +``` + +PARAMETERS: + +* **title** (`string`) + +Creates a new statusHistory panel with a title. +### obj fieldConfig + + +#### obj fieldConfig.defaults + + +##### obj fieldConfig.defaults.custom + + +###### fn fieldConfig.defaults.custom.withFillOpacity + +```jsonnet +fieldConfig.defaults.custom.withFillOpacity(value=70) +``` + +PARAMETERS: + +* **value** (`integer`) + - default value: `70` + + +###### fn fieldConfig.defaults.custom.withHideFrom + +```jsonnet +fieldConfig.defaults.custom.withHideFrom(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn fieldConfig.defaults.custom.withHideFromMixin + +```jsonnet +fieldConfig.defaults.custom.withHideFromMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn fieldConfig.defaults.custom.withLineWidth + +```jsonnet +fieldConfig.defaults.custom.withLineWidth(value=1) +``` + +PARAMETERS: + +* **value** (`integer`) + - default value: `1` + + +###### obj fieldConfig.defaults.custom.hideFrom + + +####### fn fieldConfig.defaults.custom.hideFrom.withLegend + +```jsonnet +fieldConfig.defaults.custom.hideFrom.withLegend(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +####### fn fieldConfig.defaults.custom.hideFrom.withTooltip + +```jsonnet +fieldConfig.defaults.custom.hideFrom.withTooltip(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +####### fn fieldConfig.defaults.custom.hideFrom.withViz + +```jsonnet +fieldConfig.defaults.custom.hideFrom.withViz(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### obj libraryPanel + + +#### fn libraryPanel.withName + +```jsonnet +libraryPanel.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn libraryPanel.withUid + +```jsonnet +libraryPanel.withUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj options + + +#### fn options.withColWidth + +```jsonnet +options.withColWidth(value=0.9) +``` + +PARAMETERS: + +* **value** (`number`) + - default value: `0.9` + +Controls the column width +#### fn options.withLegend + +```jsonnet +options.withLegend(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withLegendMixin + +```jsonnet +options.withLegendMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withRowHeight + +```jsonnet +options.withRowHeight(value=0.9) +``` + +PARAMETERS: + +* **value** (`number`) + - default value: `0.9` + +Set the height of the rows +#### fn options.withShowValue + +```jsonnet +options.withShowValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Show values on the columns +#### fn options.withTimezone + +```jsonnet +options.withTimezone(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn options.withTimezoneMixin + +```jsonnet +options.withTimezoneMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn options.withTooltip + +```jsonnet +options.withTooltip(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withTooltipMixin + +```jsonnet +options.withTooltipMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### obj options.legend + + +##### fn options.legend.withAsTable + +```jsonnet +options.legend.withAsTable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.legend.withCalcs + +```jsonnet +options.legend.withCalcs(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +##### fn options.legend.withCalcsMixin + +```jsonnet +options.legend.withCalcsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +##### fn options.legend.withDisplayMode + +```jsonnet +options.legend.withDisplayMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"list"`, `"table"`, `"hidden"` + +TODO docs +Note: "hidden" needs to remain as an option for plugins compatibility +##### fn options.legend.withIsVisible + +```jsonnet +options.legend.withIsVisible(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.legend.withPlacement + +```jsonnet +options.legend.withPlacement(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"bottom"`, `"right"` + +TODO docs +##### fn options.legend.withShowLegend + +```jsonnet +options.legend.withShowLegend(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.legend.withSortBy + +```jsonnet +options.legend.withSortBy(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn options.legend.withSortDesc + +```jsonnet +options.legend.withSortDesc(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.legend.withWidth + +```jsonnet +options.legend.withWidth(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### obj options.tooltip + + +##### fn options.tooltip.withMode + +```jsonnet +options.tooltip.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"single"`, `"multi"`, `"none"` + +TODO docs +##### fn options.tooltip.withSort + +```jsonnet +options.tooltip.withSort(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"asc"`, `"desc"`, `"none"` + +TODO docs +### obj panelOptions + + +#### fn panelOptions.withDescription + +```jsonnet +panelOptions.withDescription(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Description. +#### fn panelOptions.withGridPos + +```jsonnet +panelOptions.withGridPos(h="null", w="null", x="null", y="null") +``` + +PARAMETERS: + +* **h** (`number`) + - default value: `"null"` +* **w** (`number`) + - default value: `"null"` +* **x** (`number`) + - default value: `"null"` +* **y** (`number`) + - default value: `"null"` + +`withGridPos` configures the height, width and xy coordinates of the panel. Also see `grafonnet.util.grid` for helper functions to calculate these fields. + +All arguments default to `null`, which means they will remain unchanged or unset. + +#### fn panelOptions.withLinks + +```jsonnet +panelOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withLinksMixin + +```jsonnet +panelOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withRepeat + +```jsonnet +panelOptions.withRepeat(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of template variable to repeat for. +#### fn panelOptions.withRepeatDirection + +```jsonnet +panelOptions.withRepeatDirection(value="h") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"h"` + - valid values: `"h"`, `"v"` + +Direction to repeat in if 'repeat' is set. +"h" for horizontal, "v" for vertical. +TODO this is probably optional +#### fn panelOptions.withTitle + +```jsonnet +panelOptions.withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Panel title. +#### fn panelOptions.withTransparent + +```jsonnet +panelOptions.withTransparent(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Whether to display the panel without a background. +### obj queryOptions + + +#### fn queryOptions.withDatasource + +```jsonnet +queryOptions.withDatasource(type, uid) +``` + +PARAMETERS: + +* **type** (`string`) +* **uid** (`string`) + +`withDatasource` sets the datasource for all queries in a panel. + +The default datasource for a panel is set to 'Mixed datasource' so panels can be datasource agnostic, which is a lot more interesting from a reusability standpoint. Note that this requires query targets to explicitly set datasource for the same reason. + +#### fn queryOptions.withDatasourceMixin + +```jsonnet +queryOptions.withDatasourceMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +The datasource used in all targets. +#### fn queryOptions.withInterval + +```jsonnet +queryOptions.withInterval(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withMaxDataPoints + +```jsonnet +queryOptions.withMaxDataPoints(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +#### fn queryOptions.withTargets + +```jsonnet +queryOptions.withTargets(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTargetsMixin + +```jsonnet +queryOptions.withTargetsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTimeFrom + +```jsonnet +queryOptions.withTimeFrom(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTimeShift + +```jsonnet +queryOptions.withTimeShift(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTransformations + +```jsonnet +queryOptions.withTransformations(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn queryOptions.withTransformationsMixin + +```jsonnet +queryOptions.withTransformationsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### obj standardOptions + + +#### fn standardOptions.withDecimals + +```jsonnet +standardOptions.withDecimals(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Significant digits (for display) +#### fn standardOptions.withDisplayName + +```jsonnet +standardOptions.withDisplayName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The display value for this field. This supports template variables blank is auto +#### fn standardOptions.withFilterable + +```jsonnet +standardOptions.withFilterable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +True if data source field supports ad-hoc filters +#### fn standardOptions.withLinks + +```jsonnet +standardOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withLinksMixin + +```jsonnet +standardOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withMappings + +```jsonnet +standardOptions.withMappings(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMappingsMixin + +```jsonnet +standardOptions.withMappingsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMax + +```jsonnet +standardOptions.withMax(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withMin + +```jsonnet +standardOptions.withMin(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withNoValue + +```jsonnet +standardOptions.withNoValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Alternative to empty string +#### fn standardOptions.withOverrides + +```jsonnet +standardOptions.withOverrides(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withOverridesMixin + +```jsonnet +standardOptions.withOverridesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withPath + +```jsonnet +standardOptions.withPath(value) +``` + +PARAMETERS: + +* **value** (`string`) + +An explicit path to the field in the datasource. When the frame meta includes a path, +This will default to `${frame.meta.path}/${field.name} + +When defined, this value can be used as an identifier within the datasource scope, and +may be used to update the results +#### fn standardOptions.withUnit + +```jsonnet +standardOptions.withUnit(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Numeric Options +#### obj standardOptions.color + + +##### fn standardOptions.color.withFixedColor + +```jsonnet +standardOptions.color.withFixedColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Stores the fixed color value if mode is fixed +##### fn standardOptions.color.withMode + +```jsonnet +standardOptions.color.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The main color scheme mode +##### fn standardOptions.color.withSeriesBy + +```jsonnet +standardOptions.color.withSeriesBy(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"min"`, `"max"`, `"last"` + +TODO docs +#### obj standardOptions.thresholds + + +##### fn standardOptions.thresholds.withMode + +```jsonnet +standardOptions.thresholds.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"absolute"`, `"percentage"` + + +##### fn standardOptions.thresholds.withSteps + +```jsonnet +standardOptions.thresholds.withSteps(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity +##### fn standardOptions.thresholds.withStepsMixin + +```jsonnet +standardOptions.thresholds.withStepsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/statusHistory/panelOptions/link.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/statusHistory/panelOptions/link.md new file mode 100644 index 0000000000..106f9d2edb --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/statusHistory/panelOptions/link.md @@ -0,0 +1,145 @@ +# link + + + +## Index + +* [`fn withAsDropdown(value=true)`](#fn-withasdropdown) +* [`fn withIcon(value)`](#fn-withicon) +* [`fn withIncludeVars(value=true)`](#fn-withincludevars) +* [`fn withKeepTime(value=true)`](#fn-withkeeptime) +* [`fn withTags(value)`](#fn-withtags) +* [`fn withTagsMixin(value)`](#fn-withtagsmixin) +* [`fn withTargetBlank(value=true)`](#fn-withtargetblank) +* [`fn withTitle(value)`](#fn-withtitle) +* [`fn withTooltip(value)`](#fn-withtooltip) +* [`fn withType(value)`](#fn-withtype) +* [`fn withUrl(value)`](#fn-withurl) + +## Fields + +### fn withAsDropdown + +```jsonnet +withAsDropdown(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withIcon + +```jsonnet +withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withIncludeVars + +```jsonnet +withIncludeVars(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withKeepTime + +```jsonnet +withKeepTime(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTags + +```jsonnet +withTags(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTagsMixin + +```jsonnet +withTagsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTargetBlank + +```jsonnet +withTargetBlank(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTitle + +```jsonnet +withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withTooltip + +```jsonnet +withTooltip(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withType + +```jsonnet +withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"link"`, `"dashboards"` + +TODO docs +### fn withUrl + +```jsonnet +withUrl(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/statusHistory/queryOptions/transformation.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/statusHistory/queryOptions/transformation.md new file mode 100644 index 0000000000..dc832f653d --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/statusHistory/queryOptions/transformation.md @@ -0,0 +1,99 @@ +# transformation + + + +## Index + +* [`fn withDisabled(value=true)`](#fn-withdisabled) +* [`fn withFilter(value)`](#fn-withfilter) +* [`fn withFilterMixin(value)`](#fn-withfiltermixin) +* [`fn withId(value)`](#fn-withid) +* [`fn withOptions(value)`](#fn-withoptions) +* [`obj filter`](#obj-filter) + * [`fn withId(value="")`](#fn-filterwithid) + * [`fn withOptions(value)`](#fn-filterwithoptions) + +## Fields + +### fn withDisabled + +```jsonnet +withDisabled(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Disabled transformations are skipped +### fn withFilter + +```jsonnet +withFilter(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withFilterMixin + +```jsonnet +withFilterMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withId + +```jsonnet +withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Unique identifier of transformer +### fn withOptions + +```jsonnet +withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Options to be passed to the transformer +Valid options depend on the transformer id +### obj filter + + +#### fn filter.withId + +```jsonnet +filter.withId(value="") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `""` + + +#### fn filter.withOptions + +```jsonnet +filter.withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/statusHistory/standardOptions/mapping.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/statusHistory/standardOptions/mapping.md new file mode 100644 index 0000000000..93296972e8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/statusHistory/standardOptions/mapping.md @@ -0,0 +1,469 @@ +# mapping + + + +## Index + +* [`obj RangeMap`](#obj-rangemap) + * [`fn withOptions(value)`](#fn-rangemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-rangemapwithoptionsmixin) + * [`fn withType(value)`](#fn-rangemapwithtype) + * [`obj options`](#obj-rangemapoptions) + * [`fn withFrom(value)`](#fn-rangemapoptionswithfrom) + * [`fn withResult(value)`](#fn-rangemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-rangemapoptionswithresultmixin) + * [`fn withTo(value)`](#fn-rangemapoptionswithto) + * [`obj result`](#obj-rangemapoptionsresult) + * [`fn withColor(value)`](#fn-rangemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-rangemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-rangemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-rangemapoptionsresultwithtext) +* [`obj RegexMap`](#obj-regexmap) + * [`fn withOptions(value)`](#fn-regexmapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-regexmapwithoptionsmixin) + * [`fn withType(value)`](#fn-regexmapwithtype) + * [`obj options`](#obj-regexmapoptions) + * [`fn withPattern(value)`](#fn-regexmapoptionswithpattern) + * [`fn withResult(value)`](#fn-regexmapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-regexmapoptionswithresultmixin) + * [`obj result`](#obj-regexmapoptionsresult) + * [`fn withColor(value)`](#fn-regexmapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-regexmapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-regexmapoptionsresultwithindex) + * [`fn withText(value)`](#fn-regexmapoptionsresultwithtext) +* [`obj SpecialValueMap`](#obj-specialvaluemap) + * [`fn withOptions(value)`](#fn-specialvaluemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-specialvaluemapwithoptionsmixin) + * [`fn withType(value)`](#fn-specialvaluemapwithtype) + * [`obj options`](#obj-specialvaluemapoptions) + * [`fn withMatch(value)`](#fn-specialvaluemapoptionswithmatch) + * [`fn withPattern(value)`](#fn-specialvaluemapoptionswithpattern) + * [`fn withResult(value)`](#fn-specialvaluemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-specialvaluemapoptionswithresultmixin) + * [`obj result`](#obj-specialvaluemapoptionsresult) + * [`fn withColor(value)`](#fn-specialvaluemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-specialvaluemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-specialvaluemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-specialvaluemapoptionsresultwithtext) +* [`obj ValueMap`](#obj-valuemap) + * [`fn withOptions(value)`](#fn-valuemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-valuemapwithoptionsmixin) + * [`fn withType(value)`](#fn-valuemapwithtype) + +## Fields + +### obj RangeMap + + +#### fn RangeMap.withOptions + +```jsonnet +RangeMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withOptionsMixin + +```jsonnet +RangeMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withType + +```jsonnet +RangeMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RangeMap.options + + +##### fn RangeMap.options.withFrom + +```jsonnet +RangeMap.options.withFrom(value) +``` + +PARAMETERS: + +* **value** (`number`) + +to and from are `number | null` in current ts, really not sure what to do +##### fn RangeMap.options.withResult + +```jsonnet +RangeMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withResultMixin + +```jsonnet +RangeMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withTo + +```jsonnet +RangeMap.options.withTo(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +##### obj RangeMap.options.result + + +###### fn RangeMap.options.result.withColor + +```jsonnet +RangeMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIcon + +```jsonnet +RangeMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIndex + +```jsonnet +RangeMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RangeMap.options.result.withText + +```jsonnet +RangeMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj RegexMap + + +#### fn RegexMap.withOptions + +```jsonnet +RegexMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withOptionsMixin + +```jsonnet +RegexMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withType + +```jsonnet +RegexMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RegexMap.options + + +##### fn RegexMap.options.withPattern + +```jsonnet +RegexMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn RegexMap.options.withResult + +```jsonnet +RegexMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RegexMap.options.withResultMixin + +```jsonnet +RegexMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj RegexMap.options.result + + +###### fn RegexMap.options.result.withColor + +```jsonnet +RegexMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIcon + +```jsonnet +RegexMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIndex + +```jsonnet +RegexMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RegexMap.options.result.withText + +```jsonnet +RegexMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj SpecialValueMap + + +#### fn SpecialValueMap.withOptions + +```jsonnet +SpecialValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withOptionsMixin + +```jsonnet +SpecialValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withType + +```jsonnet +SpecialValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj SpecialValueMap.options + + +##### fn SpecialValueMap.options.withMatch + +```jsonnet +SpecialValueMap.options.withMatch(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"true"`, `"false"` + + +##### fn SpecialValueMap.options.withPattern + +```jsonnet +SpecialValueMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn SpecialValueMap.options.withResult + +```jsonnet +SpecialValueMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn SpecialValueMap.options.withResultMixin + +```jsonnet +SpecialValueMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj SpecialValueMap.options.result + + +###### fn SpecialValueMap.options.result.withColor + +```jsonnet +SpecialValueMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIcon + +```jsonnet +SpecialValueMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIndex + +```jsonnet +SpecialValueMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn SpecialValueMap.options.result.withText + +```jsonnet +SpecialValueMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj ValueMap + + +#### fn ValueMap.withOptions + +```jsonnet +ValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withOptionsMixin + +```jsonnet +ValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withType + +```jsonnet +ValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/statusHistory/standardOptions/override.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/statusHistory/standardOptions/override.md new file mode 100644 index 0000000000..154f3dbdac --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/statusHistory/standardOptions/override.md @@ -0,0 +1,244 @@ +# override + +Overrides allow you to customize visualization settings for specific fields or +series. This is accomplished by adding an override rule that targets +a particular set of fields and that can each define multiple options. + +```jsonnet +override.byType.new('number') ++ override.byType.withPropertiesFromOptions( + panel.standardOptions.withDecimals(2) + + panel.standardOptions.withUnit('s') +) +``` + + +## Index + +* [`obj byName`](#obj-byname) + * [`fn new(value)`](#fn-bynamenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bynamewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bynamewithproperty) +* [`obj byQuery`](#obj-byquery) + * [`fn new(value)`](#fn-byquerynew) + * [`fn withPropertiesFromOptions(options)`](#fn-byquerywithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byquerywithproperty) +* [`obj byRegexp`](#obj-byregexp) + * [`fn new(value)`](#fn-byregexpnew) + * [`fn withPropertiesFromOptions(options)`](#fn-byregexpwithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byregexpwithproperty) +* [`obj byType`](#obj-bytype) + * [`fn new(value)`](#fn-bytypenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bytypewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bytypewithproperty) +* [`obj byValue`](#obj-byvalue) + * [`fn new(value)`](#fn-byvaluenew) + * [`fn withPropertiesFromOptions(options)`](#fn-byvaluewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byvaluewithproperty) + +## Fields + +### obj byName + + +#### fn byName.new + +```jsonnet +byName.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byName`. +#### fn byName.withPropertiesFromOptions + +```jsonnet +byName.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byName.withProperty + +```jsonnet +byName.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byQuery + + +#### fn byQuery.new + +```jsonnet +byQuery.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byQuery`. +#### fn byQuery.withPropertiesFromOptions + +```jsonnet +byQuery.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byQuery.withProperty + +```jsonnet +byQuery.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byRegexp + + +#### fn byRegexp.new + +```jsonnet +byRegexp.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byRegexp`. +#### fn byRegexp.withPropertiesFromOptions + +```jsonnet +byRegexp.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byRegexp.withProperty + +```jsonnet +byRegexp.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byType + + +#### fn byType.new + +```jsonnet +byType.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byType`. +#### fn byType.withPropertiesFromOptions + +```jsonnet +byType.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byType.withProperty + +```jsonnet +byType.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byValue + + +#### fn byValue.new + +```jsonnet +byValue.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byValue`. +#### fn byValue.withPropertiesFromOptions + +```jsonnet +byValue.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byValue.withProperty + +```jsonnet +byValue.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/statusHistory/standardOptions/threshold/step.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/statusHistory/standardOptions/threshold/step.md new file mode 100644 index 0000000000..dd2dd227ff --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/statusHistory/standardOptions/threshold/step.md @@ -0,0 +1,60 @@ +# threshold.step + + + +## Index + +* [`fn withColor(value)`](#fn-withcolor) +* [`fn withIndex(value)`](#fn-withindex) +* [`fn withState(value)`](#fn-withstate) +* [`fn withValue(value)`](#fn-withvalue) + +## Fields + +### fn withColor + +```jsonnet +withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +### fn withIndex + +```jsonnet +withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Threshold index, an old property that is not needed an should only appear in older dashboards +### fn withState + +```jsonnet +withState(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO are the values here enumerable into a disjunction? +Some seem to be listed in typescript comment +### fn withValue + +```jsonnet +withValue(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +FIXME the corresponding typescript field is required/non-optional, but nulls currently appear here when serializing -Infinity to JSON \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/table/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/table/index.md new file mode 100644 index 0000000000..3704ddf312 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/table/index.md @@ -0,0 +1,1830 @@ +# table + +grafonnet.panel.table + +## Subpackages + +* [options.sortBy](options/sortBy.md) +* [panelOptions.link](panelOptions/link.md) +* [queryOptions.transformation](queryOptions/transformation.md) +* [standardOptions.mapping](standardOptions/mapping.md) +* [standardOptions.override](standardOptions/override.md) +* [standardOptions.threshold.step](standardOptions/threshold/step.md) + +## Index + +* [`fn new(title)`](#fn-new) +* [`obj fieldConfig`](#obj-fieldconfig) + * [`obj defaults`](#obj-fieldconfigdefaults) + * [`obj custom`](#obj-fieldconfigdefaultscustom) + * [`fn withAlign(value)`](#fn-fieldconfigdefaultscustomwithalign) + * [`fn withCellOptions(value)`](#fn-fieldconfigdefaultscustomwithcelloptions) + * [`fn withCellOptionsMixin(value)`](#fn-fieldconfigdefaultscustomwithcelloptionsmixin) + * [`fn withDisplayMode(value)`](#fn-fieldconfigdefaultscustomwithdisplaymode) + * [`fn withFilterable(value=true)`](#fn-fieldconfigdefaultscustomwithfilterable) + * [`fn withHidden(value=true)`](#fn-fieldconfigdefaultscustomwithhidden) + * [`fn withHideHeader(value=true)`](#fn-fieldconfigdefaultscustomwithhideheader) + * [`fn withInspect(value=true)`](#fn-fieldconfigdefaultscustomwithinspect) + * [`fn withMinWidth(value)`](#fn-fieldconfigdefaultscustomwithminwidth) + * [`fn withWidth(value)`](#fn-fieldconfigdefaultscustomwithwidth) + * [`obj cellOptions`](#obj-fieldconfigdefaultscustomcelloptions) + * [`fn withTableAutoCellOptions(value)`](#fn-fieldconfigdefaultscustomcelloptionswithtableautocelloptions) + * [`fn withTableAutoCellOptionsMixin(value)`](#fn-fieldconfigdefaultscustomcelloptionswithtableautocelloptionsmixin) + * [`fn withTableBarGaugeCellOptions(value)`](#fn-fieldconfigdefaultscustomcelloptionswithtablebargaugecelloptions) + * [`fn withTableBarGaugeCellOptionsMixin(value)`](#fn-fieldconfigdefaultscustomcelloptionswithtablebargaugecelloptionsmixin) + * [`fn withTableColorTextCellOptions(value)`](#fn-fieldconfigdefaultscustomcelloptionswithtablecolortextcelloptions) + * [`fn withTableColorTextCellOptionsMixin(value)`](#fn-fieldconfigdefaultscustomcelloptionswithtablecolortextcelloptionsmixin) + * [`fn withTableColoredBackgroundCellOptions(value)`](#fn-fieldconfigdefaultscustomcelloptionswithtablecoloredbackgroundcelloptions) + * [`fn withTableColoredBackgroundCellOptionsMixin(value)`](#fn-fieldconfigdefaultscustomcelloptionswithtablecoloredbackgroundcelloptionsmixin) + * [`fn withTableImageCellOptions(value)`](#fn-fieldconfigdefaultscustomcelloptionswithtableimagecelloptions) + * [`fn withTableImageCellOptionsMixin(value)`](#fn-fieldconfigdefaultscustomcelloptionswithtableimagecelloptionsmixin) + * [`fn withTableJsonViewCellOptions(value)`](#fn-fieldconfigdefaultscustomcelloptionswithtablejsonviewcelloptions) + * [`fn withTableJsonViewCellOptionsMixin(value)`](#fn-fieldconfigdefaultscustomcelloptionswithtablejsonviewcelloptionsmixin) + * [`fn withTableSparklineCellOptions(value)`](#fn-fieldconfigdefaultscustomcelloptionswithtablesparklinecelloptions) + * [`fn withTableSparklineCellOptionsMixin(value)`](#fn-fieldconfigdefaultscustomcelloptionswithtablesparklinecelloptionsmixin) + * [`obj TableAutoCellOptions`](#obj-fieldconfigdefaultscustomcelloptionstableautocelloptions) + * [`fn withType()`](#fn-fieldconfigdefaultscustomcelloptionstableautocelloptionswithtype) + * [`obj TableBarGaugeCellOptions`](#obj-fieldconfigdefaultscustomcelloptionstablebargaugecelloptions) + * [`fn withMode(value)`](#fn-fieldconfigdefaultscustomcelloptionstablebargaugecelloptionswithmode) + * [`fn withType()`](#fn-fieldconfigdefaultscustomcelloptionstablebargaugecelloptionswithtype) + * [`fn withValueDisplayMode(value)`](#fn-fieldconfigdefaultscustomcelloptionstablebargaugecelloptionswithvaluedisplaymode) + * [`obj TableColorTextCellOptions`](#obj-fieldconfigdefaultscustomcelloptionstablecolortextcelloptions) + * [`fn withType()`](#fn-fieldconfigdefaultscustomcelloptionstablecolortextcelloptionswithtype) + * [`obj TableColoredBackgroundCellOptions`](#obj-fieldconfigdefaultscustomcelloptionstablecoloredbackgroundcelloptions) + * [`fn withMode(value)`](#fn-fieldconfigdefaultscustomcelloptionstablecoloredbackgroundcelloptionswithmode) + * [`fn withType()`](#fn-fieldconfigdefaultscustomcelloptionstablecoloredbackgroundcelloptionswithtype) + * [`obj TableImageCellOptions`](#obj-fieldconfigdefaultscustomcelloptionstableimagecelloptions) + * [`fn withType()`](#fn-fieldconfigdefaultscustomcelloptionstableimagecelloptionswithtype) + * [`obj TableJsonViewCellOptions`](#obj-fieldconfigdefaultscustomcelloptionstablejsonviewcelloptions) + * [`fn withType()`](#fn-fieldconfigdefaultscustomcelloptionstablejsonviewcelloptionswithtype) + * [`obj TableSparklineCellOptions`](#obj-fieldconfigdefaultscustomcelloptionstablesparklinecelloptions) + * [`fn withAxisCenteredZero(value=true)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionswithaxiscenteredzero) + * [`fn withAxisColorMode(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionswithaxiscolormode) + * [`fn withAxisGridShow(value=true)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionswithaxisgridshow) + * [`fn withAxisLabel(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionswithaxislabel) + * [`fn withAxisPlacement(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionswithaxisplacement) + * [`fn withAxisSoftMax(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionswithaxissoftmax) + * [`fn withAxisSoftMin(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionswithaxissoftmin) + * [`fn withAxisWidth(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionswithaxiswidth) + * [`fn withBarAlignment(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionswithbaralignment) + * [`fn withBarMaxWidth(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionswithbarmaxwidth) + * [`fn withBarWidthFactor(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionswithbarwidthfactor) + * [`fn withDrawStyle(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionswithdrawstyle) + * [`fn withFillBelowTo(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionswithfillbelowto) + * [`fn withFillColor(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionswithfillcolor) + * [`fn withFillOpacity(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionswithfillopacity) + * [`fn withGradientMode(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionswithgradientmode) + * [`fn withHideFrom(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionswithhidefrom) + * [`fn withHideFromMixin(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionswithhidefrommixin) + * [`fn withLineColor(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionswithlinecolor) + * [`fn withLineInterpolation(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionswithlineinterpolation) + * [`fn withLineStyle(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionswithlinestyle) + * [`fn withLineStyleMixin(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionswithlinestylemixin) + * [`fn withLineWidth(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionswithlinewidth) + * [`fn withPointColor(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionswithpointcolor) + * [`fn withPointSize(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionswithpointsize) + * [`fn withPointSymbol(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionswithpointsymbol) + * [`fn withScaleDistribution(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionswithscaledistribution) + * [`fn withScaleDistributionMixin(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionswithscaledistributionmixin) + * [`fn withShowPoints(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionswithshowpoints) + * [`fn withSpanNulls(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionswithspannulls) + * [`fn withStacking(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionswithstacking) + * [`fn withStackingMixin(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionswithstackingmixin) + * [`fn withThresholdsStyle(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionswiththresholdsstyle) + * [`fn withThresholdsStyleMixin(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionswiththresholdsstylemixin) + * [`fn withTransform(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionswithtransform) + * [`fn withType()`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionswithtype) + * [`obj hideFrom`](#obj-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionshidefrom) + * [`fn withLegend(value=true)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionshidefromwithlegend) + * [`fn withTooltip(value=true)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionshidefromwithtooltip) + * [`fn withViz(value=true)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionshidefromwithviz) + * [`obj lineStyle`](#obj-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionslinestyle) + * [`fn withDash(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionslinestylewithdash) + * [`fn withDashMixin(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionslinestylewithdashmixin) + * [`fn withFill(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionslinestylewithfill) + * [`obj scaleDistribution`](#obj-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionsscaledistribution) + * [`fn withLinearThreshold(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionsscaledistributionwithlinearthreshold) + * [`fn withLog(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionsscaledistributionwithlog) + * [`fn withType(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionsscaledistributionwithtype) + * [`obj stacking`](#obj-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionsstacking) + * [`fn withGroup(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionsstackingwithgroup) + * [`fn withMode(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionsstackingwithmode) + * [`obj thresholdsStyle`](#obj-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionsthresholdsstyle) + * [`fn withMode(value)`](#fn-fieldconfigdefaultscustomcelloptionstablesparklinecelloptionsthresholdsstylewithmode) +* [`obj libraryPanel`](#obj-librarypanel) + * [`fn withName(value)`](#fn-librarypanelwithname) + * [`fn withUid(value)`](#fn-librarypanelwithuid) +* [`obj options`](#obj-options) + * [`fn withCellHeight(value)`](#fn-optionswithcellheight) + * [`fn withFooter(value={"countRows": false,"reducer": [],"show": false})`](#fn-optionswithfooter) + * [`fn withFooterMixin(value={"countRows": false,"reducer": [],"show": false})`](#fn-optionswithfootermixin) + * [`fn withFrameIndex(value=0)`](#fn-optionswithframeindex) + * [`fn withShowHeader(value=true)`](#fn-optionswithshowheader) + * [`fn withShowTypeIcons(value=true)`](#fn-optionswithshowtypeicons) + * [`fn withSortBy(value)`](#fn-optionswithsortby) + * [`fn withSortByMixin(value)`](#fn-optionswithsortbymixin) + * [`obj footer`](#obj-optionsfooter) + * [`fn withTableFooterOptions(value)`](#fn-optionsfooterwithtablefooteroptions) + * [`fn withTableFooterOptionsMixin(value)`](#fn-optionsfooterwithtablefooteroptionsmixin) + * [`obj TableFooterOptions`](#obj-optionsfootertablefooteroptions) + * [`fn withCountRows(value=true)`](#fn-optionsfootertablefooteroptionswithcountrows) + * [`fn withEnablePagination(value=true)`](#fn-optionsfootertablefooteroptionswithenablepagination) + * [`fn withFields(value)`](#fn-optionsfootertablefooteroptionswithfields) + * [`fn withFieldsMixin(value)`](#fn-optionsfootertablefooteroptionswithfieldsmixin) + * [`fn withReducer(value)`](#fn-optionsfootertablefooteroptionswithreducer) + * [`fn withReducerMixin(value)`](#fn-optionsfootertablefooteroptionswithreducermixin) + * [`fn withShow(value=true)`](#fn-optionsfootertablefooteroptionswithshow) +* [`obj panelOptions`](#obj-paneloptions) + * [`fn withDescription(value)`](#fn-paneloptionswithdescription) + * [`fn withGridPos(h="null", w="null", x="null", y="null")`](#fn-paneloptionswithgridpos) + * [`fn withLinks(value)`](#fn-paneloptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-paneloptionswithlinksmixin) + * [`fn withRepeat(value)`](#fn-paneloptionswithrepeat) + * [`fn withRepeatDirection(value="h")`](#fn-paneloptionswithrepeatdirection) + * [`fn withTitle(value)`](#fn-paneloptionswithtitle) + * [`fn withTransparent(value=true)`](#fn-paneloptionswithtransparent) +* [`obj queryOptions`](#obj-queryoptions) + * [`fn withDatasource(type, uid)`](#fn-queryoptionswithdatasource) + * [`fn withDatasourceMixin(value)`](#fn-queryoptionswithdatasourcemixin) + * [`fn withInterval(value)`](#fn-queryoptionswithinterval) + * [`fn withMaxDataPoints(value)`](#fn-queryoptionswithmaxdatapoints) + * [`fn withTargets(value)`](#fn-queryoptionswithtargets) + * [`fn withTargetsMixin(value)`](#fn-queryoptionswithtargetsmixin) + * [`fn withTimeFrom(value)`](#fn-queryoptionswithtimefrom) + * [`fn withTimeShift(value)`](#fn-queryoptionswithtimeshift) + * [`fn withTransformations(value)`](#fn-queryoptionswithtransformations) + * [`fn withTransformationsMixin(value)`](#fn-queryoptionswithtransformationsmixin) +* [`obj standardOptions`](#obj-standardoptions) + * [`fn withDecimals(value)`](#fn-standardoptionswithdecimals) + * [`fn withDisplayName(value)`](#fn-standardoptionswithdisplayname) + * [`fn withFilterable(value=true)`](#fn-standardoptionswithfilterable) + * [`fn withLinks(value)`](#fn-standardoptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-standardoptionswithlinksmixin) + * [`fn withMappings(value)`](#fn-standardoptionswithmappings) + * [`fn withMappingsMixin(value)`](#fn-standardoptionswithmappingsmixin) + * [`fn withMax(value)`](#fn-standardoptionswithmax) + * [`fn withMin(value)`](#fn-standardoptionswithmin) + * [`fn withNoValue(value)`](#fn-standardoptionswithnovalue) + * [`fn withOverrides(value)`](#fn-standardoptionswithoverrides) + * [`fn withOverridesMixin(value)`](#fn-standardoptionswithoverridesmixin) + * [`fn withPath(value)`](#fn-standardoptionswithpath) + * [`fn withUnit(value)`](#fn-standardoptionswithunit) + * [`obj color`](#obj-standardoptionscolor) + * [`fn withFixedColor(value)`](#fn-standardoptionscolorwithfixedcolor) + * [`fn withMode(value)`](#fn-standardoptionscolorwithmode) + * [`fn withSeriesBy(value)`](#fn-standardoptionscolorwithseriesby) + * [`obj thresholds`](#obj-standardoptionsthresholds) + * [`fn withMode(value)`](#fn-standardoptionsthresholdswithmode) + * [`fn withSteps(value)`](#fn-standardoptionsthresholdswithsteps) + * [`fn withStepsMixin(value)`](#fn-standardoptionsthresholdswithstepsmixin) + +## Fields + +### fn new + +```jsonnet +new(title) +``` + +PARAMETERS: + +* **title** (`string`) + +Creates a new table panel with a title. +### obj fieldConfig + + +#### obj fieldConfig.defaults + + +##### obj fieldConfig.defaults.custom + + +###### fn fieldConfig.defaults.custom.withAlign + +```jsonnet +fieldConfig.defaults.custom.withAlign(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"auto"`, `"left"`, `"right"`, `"center"` + +TODO -- should not be table specific! TODO docs +###### fn fieldConfig.defaults.custom.withCellOptions + +```jsonnet +fieldConfig.defaults.custom.withCellOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Table cell options. Each cell has a display mode and other potential options for that display. +###### fn fieldConfig.defaults.custom.withCellOptionsMixin + +```jsonnet +fieldConfig.defaults.custom.withCellOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Table cell options. Each cell has a display mode and other potential options for that display. +###### fn fieldConfig.defaults.custom.withDisplayMode + +```jsonnet +fieldConfig.defaults.custom.withDisplayMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"auto"`, `"basic"`, `"color-background"`, `"color-background-solid"`, `"color-text"`, `"custom"`, `"gauge"`, `"gradient-gauge"`, `"image"`, `"json-view"`, `"lcd-gauge"`, `"sparkline"` + +Internally, this is the "type" of cell that's being displayed in the table such as colored text, JSON, gauge, etc. The color-background-solid, gradient-gauge, and lcd-gauge modes are deprecated in favor of new cell subOptions +###### fn fieldConfig.defaults.custom.withFilterable + +```jsonnet +fieldConfig.defaults.custom.withFilterable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +###### fn fieldConfig.defaults.custom.withHidden + +```jsonnet +fieldConfig.defaults.custom.withHidden(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +###### fn fieldConfig.defaults.custom.withHideHeader + +```jsonnet +fieldConfig.defaults.custom.withHideHeader(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Hides any header for a column, usefull for columns that show some static content or buttons. +###### fn fieldConfig.defaults.custom.withInspect + +```jsonnet +fieldConfig.defaults.custom.withInspect(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +###### fn fieldConfig.defaults.custom.withMinWidth + +```jsonnet +fieldConfig.defaults.custom.withMinWidth(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +###### fn fieldConfig.defaults.custom.withWidth + +```jsonnet +fieldConfig.defaults.custom.withWidth(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +###### obj fieldConfig.defaults.custom.cellOptions + + +####### fn fieldConfig.defaults.custom.cellOptions.withTableAutoCellOptions + +```jsonnet +fieldConfig.defaults.custom.cellOptions.withTableAutoCellOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Auto mode table cell options +####### fn fieldConfig.defaults.custom.cellOptions.withTableAutoCellOptionsMixin + +```jsonnet +fieldConfig.defaults.custom.cellOptions.withTableAutoCellOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Auto mode table cell options +####### fn fieldConfig.defaults.custom.cellOptions.withTableBarGaugeCellOptions + +```jsonnet +fieldConfig.defaults.custom.cellOptions.withTableBarGaugeCellOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Gauge cell options +####### fn fieldConfig.defaults.custom.cellOptions.withTableBarGaugeCellOptionsMixin + +```jsonnet +fieldConfig.defaults.custom.cellOptions.withTableBarGaugeCellOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Gauge cell options +####### fn fieldConfig.defaults.custom.cellOptions.withTableColorTextCellOptions + +```jsonnet +fieldConfig.defaults.custom.cellOptions.withTableColorTextCellOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Colored text cell options +####### fn fieldConfig.defaults.custom.cellOptions.withTableColorTextCellOptionsMixin + +```jsonnet +fieldConfig.defaults.custom.cellOptions.withTableColorTextCellOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Colored text cell options +####### fn fieldConfig.defaults.custom.cellOptions.withTableColoredBackgroundCellOptions + +```jsonnet +fieldConfig.defaults.custom.cellOptions.withTableColoredBackgroundCellOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Colored background cell options +####### fn fieldConfig.defaults.custom.cellOptions.withTableColoredBackgroundCellOptionsMixin + +```jsonnet +fieldConfig.defaults.custom.cellOptions.withTableColoredBackgroundCellOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Colored background cell options +####### fn fieldConfig.defaults.custom.cellOptions.withTableImageCellOptions + +```jsonnet +fieldConfig.defaults.custom.cellOptions.withTableImageCellOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Json view cell options +####### fn fieldConfig.defaults.custom.cellOptions.withTableImageCellOptionsMixin + +```jsonnet +fieldConfig.defaults.custom.cellOptions.withTableImageCellOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Json view cell options +####### fn fieldConfig.defaults.custom.cellOptions.withTableJsonViewCellOptions + +```jsonnet +fieldConfig.defaults.custom.cellOptions.withTableJsonViewCellOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Json view cell options +####### fn fieldConfig.defaults.custom.cellOptions.withTableJsonViewCellOptionsMixin + +```jsonnet +fieldConfig.defaults.custom.cellOptions.withTableJsonViewCellOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Json view cell options +####### fn fieldConfig.defaults.custom.cellOptions.withTableSparklineCellOptions + +```jsonnet +fieldConfig.defaults.custom.cellOptions.withTableSparklineCellOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Sparkline cell options +####### fn fieldConfig.defaults.custom.cellOptions.withTableSparklineCellOptionsMixin + +```jsonnet +fieldConfig.defaults.custom.cellOptions.withTableSparklineCellOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Sparkline cell options +####### obj fieldConfig.defaults.custom.cellOptions.TableAutoCellOptions + + +######## fn fieldConfig.defaults.custom.cellOptions.TableAutoCellOptions.withType + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableAutoCellOptions.withType() +``` + + + +####### obj fieldConfig.defaults.custom.cellOptions.TableBarGaugeCellOptions + + +######## fn fieldConfig.defaults.custom.cellOptions.TableBarGaugeCellOptions.withMode + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableBarGaugeCellOptions.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"basic"`, `"gradient"`, `"lcd"` + +Enum expressing the possible display modes for the bar gauge component of Grafana UI +######## fn fieldConfig.defaults.custom.cellOptions.TableBarGaugeCellOptions.withType + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableBarGaugeCellOptions.withType() +``` + + + +######## fn fieldConfig.defaults.custom.cellOptions.TableBarGaugeCellOptions.withValueDisplayMode + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableBarGaugeCellOptions.withValueDisplayMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"color"`, `"hidden"`, `"text"` + +Allows for the table cell gauge display type to set the gauge mode. +####### obj fieldConfig.defaults.custom.cellOptions.TableColorTextCellOptions + + +######## fn fieldConfig.defaults.custom.cellOptions.TableColorTextCellOptions.withType + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableColorTextCellOptions.withType() +``` + + + +####### obj fieldConfig.defaults.custom.cellOptions.TableColoredBackgroundCellOptions + + +######## fn fieldConfig.defaults.custom.cellOptions.TableColoredBackgroundCellOptions.withMode + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableColoredBackgroundCellOptions.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"basic"`, `"gradient"` + +Display mode to the "Colored Background" display mode for table cells. Either displays a solid color (basic mode) or a gradient. +######## fn fieldConfig.defaults.custom.cellOptions.TableColoredBackgroundCellOptions.withType + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableColoredBackgroundCellOptions.withType() +``` + + + +####### obj fieldConfig.defaults.custom.cellOptions.TableImageCellOptions + + +######## fn fieldConfig.defaults.custom.cellOptions.TableImageCellOptions.withType + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableImageCellOptions.withType() +``` + + + +####### obj fieldConfig.defaults.custom.cellOptions.TableJsonViewCellOptions + + +######## fn fieldConfig.defaults.custom.cellOptions.TableJsonViewCellOptions.withType + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableJsonViewCellOptions.withType() +``` + + + +####### obj fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions + + +######## fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withAxisCenteredZero + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withAxisCenteredZero(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +######## fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withAxisColorMode + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withAxisColorMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"series"`, `"text"` + +TODO docs +######## fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withAxisGridShow + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withAxisGridShow(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +######## fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withAxisLabel + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withAxisLabel(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +######## fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withAxisPlacement + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withAxisPlacement(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"auto"`, `"bottom"`, `"hidden"`, `"left"`, `"right"`, `"top"` + +TODO docs +######## fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withAxisSoftMax + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withAxisSoftMax(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +######## fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withAxisSoftMin + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withAxisSoftMin(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +######## fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withAxisWidth + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withAxisWidth(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +######## fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withBarAlignment + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withBarAlignment(value) +``` + +PARAMETERS: + +* **value** (`number`) + - valid values: `1`, `-1`, `0` + +TODO docs +######## fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withBarMaxWidth + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withBarMaxWidth(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +######## fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withBarWidthFactor + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withBarWidthFactor(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +######## fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withDrawStyle + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withDrawStyle(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"bars"`, `"line"`, `"points"` + +TODO docs +######## fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withFillBelowTo + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withFillBelowTo(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +######## fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withFillColor + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withFillColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +######## fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withFillOpacity + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withFillOpacity(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +######## fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withGradientMode + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withGradientMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"hue"`, `"none"`, `"opacity"`, `"scheme"` + +TODO docs +######## fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withHideFrom + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withHideFrom(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +######## fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withHideFromMixin + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withHideFromMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +######## fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withLineColor + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withLineColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +######## fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withLineInterpolation + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withLineInterpolation(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"linear"`, `"smooth"`, `"stepAfter"`, `"stepBefore"` + +TODO docs +######## fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withLineStyle + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withLineStyle(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +######## fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withLineStyleMixin + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withLineStyleMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +######## fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withLineWidth + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withLineWidth(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +######## fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withPointColor + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withPointColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +######## fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withPointSize + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withPointSize(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +######## fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withPointSymbol + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withPointSymbol(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +######## fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withScaleDistribution + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withScaleDistribution(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +######## fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withScaleDistributionMixin + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withScaleDistributionMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +######## fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withShowPoints + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withShowPoints(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"always"`, `"auto"`, `"never"` + +TODO docs +######## fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withSpanNulls + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withSpanNulls(value) +``` + +PARAMETERS: + +* **value** (`["boolean", "number"]`) + +Indicate if null values should be treated as gaps or connected. When the value is a number, it represents the maximum delta in the X axis that should be considered connected. For timeseries, this is milliseconds +######## fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withStacking + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withStacking(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +######## fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withStackingMixin + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withStackingMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +######## fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withThresholdsStyle + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withThresholdsStyle(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +######## fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withThresholdsStyleMixin + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withThresholdsStyleMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +######## fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withTransform + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withTransform(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"constant"`, `"negative-Y"` + +TODO docs +######## fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withType + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.withType() +``` + + + +######## obj fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.hideFrom + + +######### fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.hideFrom.withLegend + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.hideFrom.withLegend(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +######### fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.hideFrom.withTooltip + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.hideFrom.withTooltip(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +######### fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.hideFrom.withViz + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.hideFrom.withViz(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +######## obj fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.lineStyle + + +######### fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.lineStyle.withDash + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.lineStyle.withDash(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +######### fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.lineStyle.withDashMixin + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.lineStyle.withDashMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +######### fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.lineStyle.withFill + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.lineStyle.withFill(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"solid"`, `"dash"`, `"dot"`, `"square"` + + +######## obj fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.scaleDistribution + + +######### fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.scaleDistribution.withLinearThreshold + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.scaleDistribution.withLinearThreshold(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +######### fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.scaleDistribution.withLog + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.scaleDistribution.withLog(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +######### fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.scaleDistribution.withType + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.scaleDistribution.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"linear"`, `"log"`, `"ordinal"`, `"symlog"` + +TODO docs +######## obj fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.stacking + + +######### fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.stacking.withGroup + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.stacking.withGroup(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +######### fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.stacking.withMode + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.stacking.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"none"`, `"normal"`, `"percent"` + +TODO docs +######## obj fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.thresholdsStyle + + +######### fn fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.thresholdsStyle.withMode + +```jsonnet +fieldConfig.defaults.custom.cellOptions.TableSparklineCellOptions.thresholdsStyle.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"area"`, `"dashed"`, `"dashed+area"`, `"line"`, `"line+area"`, `"off"`, `"series"` + +TODO docs +### obj libraryPanel + + +#### fn libraryPanel.withName + +```jsonnet +libraryPanel.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn libraryPanel.withUid + +```jsonnet +libraryPanel.withUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj options + + +#### fn options.withCellHeight + +```jsonnet +options.withCellHeight(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Controls the height of the rows +#### fn options.withFooter + +```jsonnet +options.withFooter(value={"countRows": false,"reducer": [],"show": false}) +``` + +PARAMETERS: + +* **value** (`object`) + - default value: `{"countRows": false,"reducer": [],"show": false}` + +Controls footer options +#### fn options.withFooterMixin + +```jsonnet +options.withFooterMixin(value={"countRows": false,"reducer": [],"show": false}) +``` + +PARAMETERS: + +* **value** (`object`) + - default value: `{"countRows": false,"reducer": [],"show": false}` + +Controls footer options +#### fn options.withFrameIndex + +```jsonnet +options.withFrameIndex(value=0) +``` + +PARAMETERS: + +* **value** (`number`) + - default value: `0` + +Represents the index of the selected frame +#### fn options.withShowHeader + +```jsonnet +options.withShowHeader(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Controls whether the panel should show the header +#### fn options.withShowTypeIcons + +```jsonnet +options.withShowTypeIcons(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Controls whether the header should show icons for the column types +#### fn options.withSortBy + +```jsonnet +options.withSortBy(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Used to control row sorting +#### fn options.withSortByMixin + +```jsonnet +options.withSortByMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Used to control row sorting +#### obj options.footer + + +##### fn options.footer.withTableFooterOptions + +```jsonnet +options.footer.withTableFooterOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Footer options +##### fn options.footer.withTableFooterOptionsMixin + +```jsonnet +options.footer.withTableFooterOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Footer options +##### obj options.footer.TableFooterOptions + + +###### fn options.footer.TableFooterOptions.withCountRows + +```jsonnet +options.footer.TableFooterOptions.withCountRows(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +###### fn options.footer.TableFooterOptions.withEnablePagination + +```jsonnet +options.footer.TableFooterOptions.withEnablePagination(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +###### fn options.footer.TableFooterOptions.withFields + +```jsonnet +options.footer.TableFooterOptions.withFields(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +###### fn options.footer.TableFooterOptions.withFieldsMixin + +```jsonnet +options.footer.TableFooterOptions.withFieldsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +###### fn options.footer.TableFooterOptions.withReducer + +```jsonnet +options.footer.TableFooterOptions.withReducer(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +###### fn options.footer.TableFooterOptions.withReducerMixin + +```jsonnet +options.footer.TableFooterOptions.withReducerMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +###### fn options.footer.TableFooterOptions.withShow + +```jsonnet +options.footer.TableFooterOptions.withShow(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### obj panelOptions + + +#### fn panelOptions.withDescription + +```jsonnet +panelOptions.withDescription(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Description. +#### fn panelOptions.withGridPos + +```jsonnet +panelOptions.withGridPos(h="null", w="null", x="null", y="null") +``` + +PARAMETERS: + +* **h** (`number`) + - default value: `"null"` +* **w** (`number`) + - default value: `"null"` +* **x** (`number`) + - default value: `"null"` +* **y** (`number`) + - default value: `"null"` + +`withGridPos` configures the height, width and xy coordinates of the panel. Also see `grafonnet.util.grid` for helper functions to calculate these fields. + +All arguments default to `null`, which means they will remain unchanged or unset. + +#### fn panelOptions.withLinks + +```jsonnet +panelOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withLinksMixin + +```jsonnet +panelOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withRepeat + +```jsonnet +panelOptions.withRepeat(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of template variable to repeat for. +#### fn panelOptions.withRepeatDirection + +```jsonnet +panelOptions.withRepeatDirection(value="h") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"h"` + - valid values: `"h"`, `"v"` + +Direction to repeat in if 'repeat' is set. +"h" for horizontal, "v" for vertical. +TODO this is probably optional +#### fn panelOptions.withTitle + +```jsonnet +panelOptions.withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Panel title. +#### fn panelOptions.withTransparent + +```jsonnet +panelOptions.withTransparent(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Whether to display the panel without a background. +### obj queryOptions + + +#### fn queryOptions.withDatasource + +```jsonnet +queryOptions.withDatasource(type, uid) +``` + +PARAMETERS: + +* **type** (`string`) +* **uid** (`string`) + +`withDatasource` sets the datasource for all queries in a panel. + +The default datasource for a panel is set to 'Mixed datasource' so panels can be datasource agnostic, which is a lot more interesting from a reusability standpoint. Note that this requires query targets to explicitly set datasource for the same reason. + +#### fn queryOptions.withDatasourceMixin + +```jsonnet +queryOptions.withDatasourceMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +The datasource used in all targets. +#### fn queryOptions.withInterval + +```jsonnet +queryOptions.withInterval(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withMaxDataPoints + +```jsonnet +queryOptions.withMaxDataPoints(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +#### fn queryOptions.withTargets + +```jsonnet +queryOptions.withTargets(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTargetsMixin + +```jsonnet +queryOptions.withTargetsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTimeFrom + +```jsonnet +queryOptions.withTimeFrom(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTimeShift + +```jsonnet +queryOptions.withTimeShift(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTransformations + +```jsonnet +queryOptions.withTransformations(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn queryOptions.withTransformationsMixin + +```jsonnet +queryOptions.withTransformationsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### obj standardOptions + + +#### fn standardOptions.withDecimals + +```jsonnet +standardOptions.withDecimals(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Significant digits (for display) +#### fn standardOptions.withDisplayName + +```jsonnet +standardOptions.withDisplayName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The display value for this field. This supports template variables blank is auto +#### fn standardOptions.withFilterable + +```jsonnet +standardOptions.withFilterable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +True if data source field supports ad-hoc filters +#### fn standardOptions.withLinks + +```jsonnet +standardOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withLinksMixin + +```jsonnet +standardOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withMappings + +```jsonnet +standardOptions.withMappings(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMappingsMixin + +```jsonnet +standardOptions.withMappingsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMax + +```jsonnet +standardOptions.withMax(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withMin + +```jsonnet +standardOptions.withMin(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withNoValue + +```jsonnet +standardOptions.withNoValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Alternative to empty string +#### fn standardOptions.withOverrides + +```jsonnet +standardOptions.withOverrides(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withOverridesMixin + +```jsonnet +standardOptions.withOverridesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withPath + +```jsonnet +standardOptions.withPath(value) +``` + +PARAMETERS: + +* **value** (`string`) + +An explicit path to the field in the datasource. When the frame meta includes a path, +This will default to `${frame.meta.path}/${field.name} + +When defined, this value can be used as an identifier within the datasource scope, and +may be used to update the results +#### fn standardOptions.withUnit + +```jsonnet +standardOptions.withUnit(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Numeric Options +#### obj standardOptions.color + + +##### fn standardOptions.color.withFixedColor + +```jsonnet +standardOptions.color.withFixedColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Stores the fixed color value if mode is fixed +##### fn standardOptions.color.withMode + +```jsonnet +standardOptions.color.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The main color scheme mode +##### fn standardOptions.color.withSeriesBy + +```jsonnet +standardOptions.color.withSeriesBy(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"min"`, `"max"`, `"last"` + +TODO docs +#### obj standardOptions.thresholds + + +##### fn standardOptions.thresholds.withMode + +```jsonnet +standardOptions.thresholds.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"absolute"`, `"percentage"` + + +##### fn standardOptions.thresholds.withSteps + +```jsonnet +standardOptions.thresholds.withSteps(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity +##### fn standardOptions.thresholds.withStepsMixin + +```jsonnet +standardOptions.thresholds.withStepsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/table/options/sortBy.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/table/options/sortBy.md new file mode 100644 index 0000000000..20748dc807 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/table/options/sortBy.md @@ -0,0 +1,34 @@ +# sortBy + + + +## Index + +* [`fn withDesc(value=true)`](#fn-withdesc) +* [`fn withDisplayName(value)`](#fn-withdisplayname) + +## Fields + +### fn withDesc + +```jsonnet +withDesc(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Flag used to indicate descending sort order +### fn withDisplayName + +```jsonnet +withDisplayName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Sets the display name of the field to sort by \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/table/panelOptions/link.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/table/panelOptions/link.md new file mode 100644 index 0000000000..106f9d2edb --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/table/panelOptions/link.md @@ -0,0 +1,145 @@ +# link + + + +## Index + +* [`fn withAsDropdown(value=true)`](#fn-withasdropdown) +* [`fn withIcon(value)`](#fn-withicon) +* [`fn withIncludeVars(value=true)`](#fn-withincludevars) +* [`fn withKeepTime(value=true)`](#fn-withkeeptime) +* [`fn withTags(value)`](#fn-withtags) +* [`fn withTagsMixin(value)`](#fn-withtagsmixin) +* [`fn withTargetBlank(value=true)`](#fn-withtargetblank) +* [`fn withTitle(value)`](#fn-withtitle) +* [`fn withTooltip(value)`](#fn-withtooltip) +* [`fn withType(value)`](#fn-withtype) +* [`fn withUrl(value)`](#fn-withurl) + +## Fields + +### fn withAsDropdown + +```jsonnet +withAsDropdown(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withIcon + +```jsonnet +withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withIncludeVars + +```jsonnet +withIncludeVars(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withKeepTime + +```jsonnet +withKeepTime(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTags + +```jsonnet +withTags(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTagsMixin + +```jsonnet +withTagsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTargetBlank + +```jsonnet +withTargetBlank(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTitle + +```jsonnet +withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withTooltip + +```jsonnet +withTooltip(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withType + +```jsonnet +withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"link"`, `"dashboards"` + +TODO docs +### fn withUrl + +```jsonnet +withUrl(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/table/queryOptions/transformation.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/table/queryOptions/transformation.md new file mode 100644 index 0000000000..dc832f653d --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/table/queryOptions/transformation.md @@ -0,0 +1,99 @@ +# transformation + + + +## Index + +* [`fn withDisabled(value=true)`](#fn-withdisabled) +* [`fn withFilter(value)`](#fn-withfilter) +* [`fn withFilterMixin(value)`](#fn-withfiltermixin) +* [`fn withId(value)`](#fn-withid) +* [`fn withOptions(value)`](#fn-withoptions) +* [`obj filter`](#obj-filter) + * [`fn withId(value="")`](#fn-filterwithid) + * [`fn withOptions(value)`](#fn-filterwithoptions) + +## Fields + +### fn withDisabled + +```jsonnet +withDisabled(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Disabled transformations are skipped +### fn withFilter + +```jsonnet +withFilter(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withFilterMixin + +```jsonnet +withFilterMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withId + +```jsonnet +withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Unique identifier of transformer +### fn withOptions + +```jsonnet +withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Options to be passed to the transformer +Valid options depend on the transformer id +### obj filter + + +#### fn filter.withId + +```jsonnet +filter.withId(value="") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `""` + + +#### fn filter.withOptions + +```jsonnet +filter.withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/table/standardOptions/mapping.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/table/standardOptions/mapping.md new file mode 100644 index 0000000000..93296972e8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/table/standardOptions/mapping.md @@ -0,0 +1,469 @@ +# mapping + + + +## Index + +* [`obj RangeMap`](#obj-rangemap) + * [`fn withOptions(value)`](#fn-rangemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-rangemapwithoptionsmixin) + * [`fn withType(value)`](#fn-rangemapwithtype) + * [`obj options`](#obj-rangemapoptions) + * [`fn withFrom(value)`](#fn-rangemapoptionswithfrom) + * [`fn withResult(value)`](#fn-rangemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-rangemapoptionswithresultmixin) + * [`fn withTo(value)`](#fn-rangemapoptionswithto) + * [`obj result`](#obj-rangemapoptionsresult) + * [`fn withColor(value)`](#fn-rangemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-rangemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-rangemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-rangemapoptionsresultwithtext) +* [`obj RegexMap`](#obj-regexmap) + * [`fn withOptions(value)`](#fn-regexmapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-regexmapwithoptionsmixin) + * [`fn withType(value)`](#fn-regexmapwithtype) + * [`obj options`](#obj-regexmapoptions) + * [`fn withPattern(value)`](#fn-regexmapoptionswithpattern) + * [`fn withResult(value)`](#fn-regexmapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-regexmapoptionswithresultmixin) + * [`obj result`](#obj-regexmapoptionsresult) + * [`fn withColor(value)`](#fn-regexmapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-regexmapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-regexmapoptionsresultwithindex) + * [`fn withText(value)`](#fn-regexmapoptionsresultwithtext) +* [`obj SpecialValueMap`](#obj-specialvaluemap) + * [`fn withOptions(value)`](#fn-specialvaluemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-specialvaluemapwithoptionsmixin) + * [`fn withType(value)`](#fn-specialvaluemapwithtype) + * [`obj options`](#obj-specialvaluemapoptions) + * [`fn withMatch(value)`](#fn-specialvaluemapoptionswithmatch) + * [`fn withPattern(value)`](#fn-specialvaluemapoptionswithpattern) + * [`fn withResult(value)`](#fn-specialvaluemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-specialvaluemapoptionswithresultmixin) + * [`obj result`](#obj-specialvaluemapoptionsresult) + * [`fn withColor(value)`](#fn-specialvaluemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-specialvaluemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-specialvaluemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-specialvaluemapoptionsresultwithtext) +* [`obj ValueMap`](#obj-valuemap) + * [`fn withOptions(value)`](#fn-valuemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-valuemapwithoptionsmixin) + * [`fn withType(value)`](#fn-valuemapwithtype) + +## Fields + +### obj RangeMap + + +#### fn RangeMap.withOptions + +```jsonnet +RangeMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withOptionsMixin + +```jsonnet +RangeMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withType + +```jsonnet +RangeMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RangeMap.options + + +##### fn RangeMap.options.withFrom + +```jsonnet +RangeMap.options.withFrom(value) +``` + +PARAMETERS: + +* **value** (`number`) + +to and from are `number | null` in current ts, really not sure what to do +##### fn RangeMap.options.withResult + +```jsonnet +RangeMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withResultMixin + +```jsonnet +RangeMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withTo + +```jsonnet +RangeMap.options.withTo(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +##### obj RangeMap.options.result + + +###### fn RangeMap.options.result.withColor + +```jsonnet +RangeMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIcon + +```jsonnet +RangeMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIndex + +```jsonnet +RangeMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RangeMap.options.result.withText + +```jsonnet +RangeMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj RegexMap + + +#### fn RegexMap.withOptions + +```jsonnet +RegexMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withOptionsMixin + +```jsonnet +RegexMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withType + +```jsonnet +RegexMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RegexMap.options + + +##### fn RegexMap.options.withPattern + +```jsonnet +RegexMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn RegexMap.options.withResult + +```jsonnet +RegexMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RegexMap.options.withResultMixin + +```jsonnet +RegexMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj RegexMap.options.result + + +###### fn RegexMap.options.result.withColor + +```jsonnet +RegexMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIcon + +```jsonnet +RegexMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIndex + +```jsonnet +RegexMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RegexMap.options.result.withText + +```jsonnet +RegexMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj SpecialValueMap + + +#### fn SpecialValueMap.withOptions + +```jsonnet +SpecialValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withOptionsMixin + +```jsonnet +SpecialValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withType + +```jsonnet +SpecialValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj SpecialValueMap.options + + +##### fn SpecialValueMap.options.withMatch + +```jsonnet +SpecialValueMap.options.withMatch(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"true"`, `"false"` + + +##### fn SpecialValueMap.options.withPattern + +```jsonnet +SpecialValueMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn SpecialValueMap.options.withResult + +```jsonnet +SpecialValueMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn SpecialValueMap.options.withResultMixin + +```jsonnet +SpecialValueMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj SpecialValueMap.options.result + + +###### fn SpecialValueMap.options.result.withColor + +```jsonnet +SpecialValueMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIcon + +```jsonnet +SpecialValueMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIndex + +```jsonnet +SpecialValueMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn SpecialValueMap.options.result.withText + +```jsonnet +SpecialValueMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj ValueMap + + +#### fn ValueMap.withOptions + +```jsonnet +ValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withOptionsMixin + +```jsonnet +ValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withType + +```jsonnet +ValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/table/standardOptions/override.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/table/standardOptions/override.md new file mode 100644 index 0000000000..154f3dbdac --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/table/standardOptions/override.md @@ -0,0 +1,244 @@ +# override + +Overrides allow you to customize visualization settings for specific fields or +series. This is accomplished by adding an override rule that targets +a particular set of fields and that can each define multiple options. + +```jsonnet +override.byType.new('number') ++ override.byType.withPropertiesFromOptions( + panel.standardOptions.withDecimals(2) + + panel.standardOptions.withUnit('s') +) +``` + + +## Index + +* [`obj byName`](#obj-byname) + * [`fn new(value)`](#fn-bynamenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bynamewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bynamewithproperty) +* [`obj byQuery`](#obj-byquery) + * [`fn new(value)`](#fn-byquerynew) + * [`fn withPropertiesFromOptions(options)`](#fn-byquerywithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byquerywithproperty) +* [`obj byRegexp`](#obj-byregexp) + * [`fn new(value)`](#fn-byregexpnew) + * [`fn withPropertiesFromOptions(options)`](#fn-byregexpwithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byregexpwithproperty) +* [`obj byType`](#obj-bytype) + * [`fn new(value)`](#fn-bytypenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bytypewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bytypewithproperty) +* [`obj byValue`](#obj-byvalue) + * [`fn new(value)`](#fn-byvaluenew) + * [`fn withPropertiesFromOptions(options)`](#fn-byvaluewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byvaluewithproperty) + +## Fields + +### obj byName + + +#### fn byName.new + +```jsonnet +byName.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byName`. +#### fn byName.withPropertiesFromOptions + +```jsonnet +byName.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byName.withProperty + +```jsonnet +byName.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byQuery + + +#### fn byQuery.new + +```jsonnet +byQuery.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byQuery`. +#### fn byQuery.withPropertiesFromOptions + +```jsonnet +byQuery.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byQuery.withProperty + +```jsonnet +byQuery.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byRegexp + + +#### fn byRegexp.new + +```jsonnet +byRegexp.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byRegexp`. +#### fn byRegexp.withPropertiesFromOptions + +```jsonnet +byRegexp.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byRegexp.withProperty + +```jsonnet +byRegexp.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byType + + +#### fn byType.new + +```jsonnet +byType.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byType`. +#### fn byType.withPropertiesFromOptions + +```jsonnet +byType.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byType.withProperty + +```jsonnet +byType.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byValue + + +#### fn byValue.new + +```jsonnet +byValue.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byValue`. +#### fn byValue.withPropertiesFromOptions + +```jsonnet +byValue.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byValue.withProperty + +```jsonnet +byValue.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/table/standardOptions/threshold/step.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/table/standardOptions/threshold/step.md new file mode 100644 index 0000000000..dd2dd227ff --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/table/standardOptions/threshold/step.md @@ -0,0 +1,60 @@ +# threshold.step + + + +## Index + +* [`fn withColor(value)`](#fn-withcolor) +* [`fn withIndex(value)`](#fn-withindex) +* [`fn withState(value)`](#fn-withstate) +* [`fn withValue(value)`](#fn-withvalue) + +## Fields + +### fn withColor + +```jsonnet +withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +### fn withIndex + +```jsonnet +withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Threshold index, an old property that is not needed an should only appear in older dashboards +### fn withState + +```jsonnet +withState(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO are the values here enumerable into a disjunction? +Some seem to be listed in typescript comment +### fn withValue + +```jsonnet +withValue(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +FIXME the corresponding typescript field is required/non-optional, but nulls currently appear here when serializing -Infinity to JSON \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/text/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/text/index.md new file mode 100644 index 0000000000..b70ade3ed4 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/text/index.md @@ -0,0 +1,662 @@ +# text + +grafonnet.panel.text + +## Subpackages + +* [panelOptions.link](panelOptions/link.md) +* [queryOptions.transformation](queryOptions/transformation.md) +* [standardOptions.mapping](standardOptions/mapping.md) +* [standardOptions.override](standardOptions/override.md) +* [standardOptions.threshold.step](standardOptions/threshold/step.md) + +## Index + +* [`fn new(title)`](#fn-new) +* [`obj libraryPanel`](#obj-librarypanel) + * [`fn withName(value)`](#fn-librarypanelwithname) + * [`fn withUid(value)`](#fn-librarypanelwithuid) +* [`obj options`](#obj-options) + * [`fn withCode(value)`](#fn-optionswithcode) + * [`fn withCodeMixin(value)`](#fn-optionswithcodemixin) + * [`fn withContent(value="# Title\n\nFor markdown syntax help: [commonmark.org/help](https://commonmark.org/help/)")`](#fn-optionswithcontent) + * [`fn withMode(value)`](#fn-optionswithmode) + * [`obj code`](#obj-optionscode) + * [`fn withLanguage(value="plaintext")`](#fn-optionscodewithlanguage) + * [`fn withShowLineNumbers(value=true)`](#fn-optionscodewithshowlinenumbers) + * [`fn withShowMiniMap(value=true)`](#fn-optionscodewithshowminimap) +* [`obj panelOptions`](#obj-paneloptions) + * [`fn withDescription(value)`](#fn-paneloptionswithdescription) + * [`fn withGridPos(h="null", w="null", x="null", y="null")`](#fn-paneloptionswithgridpos) + * [`fn withLinks(value)`](#fn-paneloptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-paneloptionswithlinksmixin) + * [`fn withRepeat(value)`](#fn-paneloptionswithrepeat) + * [`fn withRepeatDirection(value="h")`](#fn-paneloptionswithrepeatdirection) + * [`fn withTitle(value)`](#fn-paneloptionswithtitle) + * [`fn withTransparent(value=true)`](#fn-paneloptionswithtransparent) +* [`obj queryOptions`](#obj-queryoptions) + * [`fn withDatasource(type, uid)`](#fn-queryoptionswithdatasource) + * [`fn withDatasourceMixin(value)`](#fn-queryoptionswithdatasourcemixin) + * [`fn withInterval(value)`](#fn-queryoptionswithinterval) + * [`fn withMaxDataPoints(value)`](#fn-queryoptionswithmaxdatapoints) + * [`fn withTargets(value)`](#fn-queryoptionswithtargets) + * [`fn withTargetsMixin(value)`](#fn-queryoptionswithtargetsmixin) + * [`fn withTimeFrom(value)`](#fn-queryoptionswithtimefrom) + * [`fn withTimeShift(value)`](#fn-queryoptionswithtimeshift) + * [`fn withTransformations(value)`](#fn-queryoptionswithtransformations) + * [`fn withTransformationsMixin(value)`](#fn-queryoptionswithtransformationsmixin) +* [`obj standardOptions`](#obj-standardoptions) + * [`fn withDecimals(value)`](#fn-standardoptionswithdecimals) + * [`fn withDisplayName(value)`](#fn-standardoptionswithdisplayname) + * [`fn withFilterable(value=true)`](#fn-standardoptionswithfilterable) + * [`fn withLinks(value)`](#fn-standardoptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-standardoptionswithlinksmixin) + * [`fn withMappings(value)`](#fn-standardoptionswithmappings) + * [`fn withMappingsMixin(value)`](#fn-standardoptionswithmappingsmixin) + * [`fn withMax(value)`](#fn-standardoptionswithmax) + * [`fn withMin(value)`](#fn-standardoptionswithmin) + * [`fn withNoValue(value)`](#fn-standardoptionswithnovalue) + * [`fn withOverrides(value)`](#fn-standardoptionswithoverrides) + * [`fn withOverridesMixin(value)`](#fn-standardoptionswithoverridesmixin) + * [`fn withPath(value)`](#fn-standardoptionswithpath) + * [`fn withUnit(value)`](#fn-standardoptionswithunit) + * [`obj color`](#obj-standardoptionscolor) + * [`fn withFixedColor(value)`](#fn-standardoptionscolorwithfixedcolor) + * [`fn withMode(value)`](#fn-standardoptionscolorwithmode) + * [`fn withSeriesBy(value)`](#fn-standardoptionscolorwithseriesby) + * [`obj thresholds`](#obj-standardoptionsthresholds) + * [`fn withMode(value)`](#fn-standardoptionsthresholdswithmode) + * [`fn withSteps(value)`](#fn-standardoptionsthresholdswithsteps) + * [`fn withStepsMixin(value)`](#fn-standardoptionsthresholdswithstepsmixin) + +## Fields + +### fn new + +```jsonnet +new(title) +``` + +PARAMETERS: + +* **title** (`string`) + +Creates a new text panel with a title. +### obj libraryPanel + + +#### fn libraryPanel.withName + +```jsonnet +libraryPanel.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn libraryPanel.withUid + +```jsonnet +libraryPanel.withUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj options + + +#### fn options.withCode + +```jsonnet +options.withCode(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn options.withCodeMixin + +```jsonnet +options.withCodeMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn options.withContent + +```jsonnet +options.withContent(value="# Title\n\nFor markdown syntax help: [commonmark.org/help](https://commonmark.org/help/)") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"# Title\n\nFor markdown syntax help: [commonmark.org/help](https://commonmark.org/help/)"` + + +#### fn options.withMode + +```jsonnet +options.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"html"`, `"markdown"`, `"code"` + + +#### obj options.code + + +##### fn options.code.withLanguage + +```jsonnet +options.code.withLanguage(value="plaintext") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"plaintext"` + - valid values: `"plaintext"`, `"yaml"`, `"xml"`, `"typescript"`, `"sql"`, `"go"`, `"markdown"`, `"html"`, `"json"` + + +##### fn options.code.withShowLineNumbers + +```jsonnet +options.code.withShowLineNumbers(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.code.withShowMiniMap + +```jsonnet +options.code.withShowMiniMap(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### obj panelOptions + + +#### fn panelOptions.withDescription + +```jsonnet +panelOptions.withDescription(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Description. +#### fn panelOptions.withGridPos + +```jsonnet +panelOptions.withGridPos(h="null", w="null", x="null", y="null") +``` + +PARAMETERS: + +* **h** (`number`) + - default value: `"null"` +* **w** (`number`) + - default value: `"null"` +* **x** (`number`) + - default value: `"null"` +* **y** (`number`) + - default value: `"null"` + +`withGridPos` configures the height, width and xy coordinates of the panel. Also see `grafonnet.util.grid` for helper functions to calculate these fields. + +All arguments default to `null`, which means they will remain unchanged or unset. + +#### fn panelOptions.withLinks + +```jsonnet +panelOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withLinksMixin + +```jsonnet +panelOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withRepeat + +```jsonnet +panelOptions.withRepeat(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of template variable to repeat for. +#### fn panelOptions.withRepeatDirection + +```jsonnet +panelOptions.withRepeatDirection(value="h") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"h"` + - valid values: `"h"`, `"v"` + +Direction to repeat in if 'repeat' is set. +"h" for horizontal, "v" for vertical. +TODO this is probably optional +#### fn panelOptions.withTitle + +```jsonnet +panelOptions.withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Panel title. +#### fn panelOptions.withTransparent + +```jsonnet +panelOptions.withTransparent(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Whether to display the panel without a background. +### obj queryOptions + + +#### fn queryOptions.withDatasource + +```jsonnet +queryOptions.withDatasource(type, uid) +``` + +PARAMETERS: + +* **type** (`string`) +* **uid** (`string`) + +`withDatasource` sets the datasource for all queries in a panel. + +The default datasource for a panel is set to 'Mixed datasource' so panels can be datasource agnostic, which is a lot more interesting from a reusability standpoint. Note that this requires query targets to explicitly set datasource for the same reason. + +#### fn queryOptions.withDatasourceMixin + +```jsonnet +queryOptions.withDatasourceMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +The datasource used in all targets. +#### fn queryOptions.withInterval + +```jsonnet +queryOptions.withInterval(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withMaxDataPoints + +```jsonnet +queryOptions.withMaxDataPoints(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +#### fn queryOptions.withTargets + +```jsonnet +queryOptions.withTargets(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTargetsMixin + +```jsonnet +queryOptions.withTargetsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTimeFrom + +```jsonnet +queryOptions.withTimeFrom(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTimeShift + +```jsonnet +queryOptions.withTimeShift(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTransformations + +```jsonnet +queryOptions.withTransformations(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn queryOptions.withTransformationsMixin + +```jsonnet +queryOptions.withTransformationsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### obj standardOptions + + +#### fn standardOptions.withDecimals + +```jsonnet +standardOptions.withDecimals(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Significant digits (for display) +#### fn standardOptions.withDisplayName + +```jsonnet +standardOptions.withDisplayName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The display value for this field. This supports template variables blank is auto +#### fn standardOptions.withFilterable + +```jsonnet +standardOptions.withFilterable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +True if data source field supports ad-hoc filters +#### fn standardOptions.withLinks + +```jsonnet +standardOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withLinksMixin + +```jsonnet +standardOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withMappings + +```jsonnet +standardOptions.withMappings(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMappingsMixin + +```jsonnet +standardOptions.withMappingsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMax + +```jsonnet +standardOptions.withMax(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withMin + +```jsonnet +standardOptions.withMin(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withNoValue + +```jsonnet +standardOptions.withNoValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Alternative to empty string +#### fn standardOptions.withOverrides + +```jsonnet +standardOptions.withOverrides(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withOverridesMixin + +```jsonnet +standardOptions.withOverridesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withPath + +```jsonnet +standardOptions.withPath(value) +``` + +PARAMETERS: + +* **value** (`string`) + +An explicit path to the field in the datasource. When the frame meta includes a path, +This will default to `${frame.meta.path}/${field.name} + +When defined, this value can be used as an identifier within the datasource scope, and +may be used to update the results +#### fn standardOptions.withUnit + +```jsonnet +standardOptions.withUnit(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Numeric Options +#### obj standardOptions.color + + +##### fn standardOptions.color.withFixedColor + +```jsonnet +standardOptions.color.withFixedColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Stores the fixed color value if mode is fixed +##### fn standardOptions.color.withMode + +```jsonnet +standardOptions.color.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The main color scheme mode +##### fn standardOptions.color.withSeriesBy + +```jsonnet +standardOptions.color.withSeriesBy(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"min"`, `"max"`, `"last"` + +TODO docs +#### obj standardOptions.thresholds + + +##### fn standardOptions.thresholds.withMode + +```jsonnet +standardOptions.thresholds.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"absolute"`, `"percentage"` + + +##### fn standardOptions.thresholds.withSteps + +```jsonnet +standardOptions.thresholds.withSteps(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity +##### fn standardOptions.thresholds.withStepsMixin + +```jsonnet +standardOptions.thresholds.withStepsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/text/panelOptions/link.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/text/panelOptions/link.md new file mode 100644 index 0000000000..106f9d2edb --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/text/panelOptions/link.md @@ -0,0 +1,145 @@ +# link + + + +## Index + +* [`fn withAsDropdown(value=true)`](#fn-withasdropdown) +* [`fn withIcon(value)`](#fn-withicon) +* [`fn withIncludeVars(value=true)`](#fn-withincludevars) +* [`fn withKeepTime(value=true)`](#fn-withkeeptime) +* [`fn withTags(value)`](#fn-withtags) +* [`fn withTagsMixin(value)`](#fn-withtagsmixin) +* [`fn withTargetBlank(value=true)`](#fn-withtargetblank) +* [`fn withTitle(value)`](#fn-withtitle) +* [`fn withTooltip(value)`](#fn-withtooltip) +* [`fn withType(value)`](#fn-withtype) +* [`fn withUrl(value)`](#fn-withurl) + +## Fields + +### fn withAsDropdown + +```jsonnet +withAsDropdown(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withIcon + +```jsonnet +withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withIncludeVars + +```jsonnet +withIncludeVars(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withKeepTime + +```jsonnet +withKeepTime(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTags + +```jsonnet +withTags(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTagsMixin + +```jsonnet +withTagsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTargetBlank + +```jsonnet +withTargetBlank(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTitle + +```jsonnet +withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withTooltip + +```jsonnet +withTooltip(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withType + +```jsonnet +withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"link"`, `"dashboards"` + +TODO docs +### fn withUrl + +```jsonnet +withUrl(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/text/queryOptions/transformation.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/text/queryOptions/transformation.md new file mode 100644 index 0000000000..dc832f653d --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/text/queryOptions/transformation.md @@ -0,0 +1,99 @@ +# transformation + + + +## Index + +* [`fn withDisabled(value=true)`](#fn-withdisabled) +* [`fn withFilter(value)`](#fn-withfilter) +* [`fn withFilterMixin(value)`](#fn-withfiltermixin) +* [`fn withId(value)`](#fn-withid) +* [`fn withOptions(value)`](#fn-withoptions) +* [`obj filter`](#obj-filter) + * [`fn withId(value="")`](#fn-filterwithid) + * [`fn withOptions(value)`](#fn-filterwithoptions) + +## Fields + +### fn withDisabled + +```jsonnet +withDisabled(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Disabled transformations are skipped +### fn withFilter + +```jsonnet +withFilter(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withFilterMixin + +```jsonnet +withFilterMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withId + +```jsonnet +withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Unique identifier of transformer +### fn withOptions + +```jsonnet +withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Options to be passed to the transformer +Valid options depend on the transformer id +### obj filter + + +#### fn filter.withId + +```jsonnet +filter.withId(value="") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `""` + + +#### fn filter.withOptions + +```jsonnet +filter.withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/text/standardOptions/mapping.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/text/standardOptions/mapping.md new file mode 100644 index 0000000000..93296972e8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/text/standardOptions/mapping.md @@ -0,0 +1,469 @@ +# mapping + + + +## Index + +* [`obj RangeMap`](#obj-rangemap) + * [`fn withOptions(value)`](#fn-rangemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-rangemapwithoptionsmixin) + * [`fn withType(value)`](#fn-rangemapwithtype) + * [`obj options`](#obj-rangemapoptions) + * [`fn withFrom(value)`](#fn-rangemapoptionswithfrom) + * [`fn withResult(value)`](#fn-rangemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-rangemapoptionswithresultmixin) + * [`fn withTo(value)`](#fn-rangemapoptionswithto) + * [`obj result`](#obj-rangemapoptionsresult) + * [`fn withColor(value)`](#fn-rangemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-rangemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-rangemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-rangemapoptionsresultwithtext) +* [`obj RegexMap`](#obj-regexmap) + * [`fn withOptions(value)`](#fn-regexmapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-regexmapwithoptionsmixin) + * [`fn withType(value)`](#fn-regexmapwithtype) + * [`obj options`](#obj-regexmapoptions) + * [`fn withPattern(value)`](#fn-regexmapoptionswithpattern) + * [`fn withResult(value)`](#fn-regexmapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-regexmapoptionswithresultmixin) + * [`obj result`](#obj-regexmapoptionsresult) + * [`fn withColor(value)`](#fn-regexmapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-regexmapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-regexmapoptionsresultwithindex) + * [`fn withText(value)`](#fn-regexmapoptionsresultwithtext) +* [`obj SpecialValueMap`](#obj-specialvaluemap) + * [`fn withOptions(value)`](#fn-specialvaluemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-specialvaluemapwithoptionsmixin) + * [`fn withType(value)`](#fn-specialvaluemapwithtype) + * [`obj options`](#obj-specialvaluemapoptions) + * [`fn withMatch(value)`](#fn-specialvaluemapoptionswithmatch) + * [`fn withPattern(value)`](#fn-specialvaluemapoptionswithpattern) + * [`fn withResult(value)`](#fn-specialvaluemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-specialvaluemapoptionswithresultmixin) + * [`obj result`](#obj-specialvaluemapoptionsresult) + * [`fn withColor(value)`](#fn-specialvaluemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-specialvaluemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-specialvaluemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-specialvaluemapoptionsresultwithtext) +* [`obj ValueMap`](#obj-valuemap) + * [`fn withOptions(value)`](#fn-valuemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-valuemapwithoptionsmixin) + * [`fn withType(value)`](#fn-valuemapwithtype) + +## Fields + +### obj RangeMap + + +#### fn RangeMap.withOptions + +```jsonnet +RangeMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withOptionsMixin + +```jsonnet +RangeMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withType + +```jsonnet +RangeMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RangeMap.options + + +##### fn RangeMap.options.withFrom + +```jsonnet +RangeMap.options.withFrom(value) +``` + +PARAMETERS: + +* **value** (`number`) + +to and from are `number | null` in current ts, really not sure what to do +##### fn RangeMap.options.withResult + +```jsonnet +RangeMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withResultMixin + +```jsonnet +RangeMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withTo + +```jsonnet +RangeMap.options.withTo(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +##### obj RangeMap.options.result + + +###### fn RangeMap.options.result.withColor + +```jsonnet +RangeMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIcon + +```jsonnet +RangeMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIndex + +```jsonnet +RangeMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RangeMap.options.result.withText + +```jsonnet +RangeMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj RegexMap + + +#### fn RegexMap.withOptions + +```jsonnet +RegexMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withOptionsMixin + +```jsonnet +RegexMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withType + +```jsonnet +RegexMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RegexMap.options + + +##### fn RegexMap.options.withPattern + +```jsonnet +RegexMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn RegexMap.options.withResult + +```jsonnet +RegexMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RegexMap.options.withResultMixin + +```jsonnet +RegexMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj RegexMap.options.result + + +###### fn RegexMap.options.result.withColor + +```jsonnet +RegexMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIcon + +```jsonnet +RegexMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIndex + +```jsonnet +RegexMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RegexMap.options.result.withText + +```jsonnet +RegexMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj SpecialValueMap + + +#### fn SpecialValueMap.withOptions + +```jsonnet +SpecialValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withOptionsMixin + +```jsonnet +SpecialValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withType + +```jsonnet +SpecialValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj SpecialValueMap.options + + +##### fn SpecialValueMap.options.withMatch + +```jsonnet +SpecialValueMap.options.withMatch(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"true"`, `"false"` + + +##### fn SpecialValueMap.options.withPattern + +```jsonnet +SpecialValueMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn SpecialValueMap.options.withResult + +```jsonnet +SpecialValueMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn SpecialValueMap.options.withResultMixin + +```jsonnet +SpecialValueMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj SpecialValueMap.options.result + + +###### fn SpecialValueMap.options.result.withColor + +```jsonnet +SpecialValueMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIcon + +```jsonnet +SpecialValueMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIndex + +```jsonnet +SpecialValueMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn SpecialValueMap.options.result.withText + +```jsonnet +SpecialValueMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj ValueMap + + +#### fn ValueMap.withOptions + +```jsonnet +ValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withOptionsMixin + +```jsonnet +ValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withType + +```jsonnet +ValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/text/standardOptions/override.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/text/standardOptions/override.md new file mode 100644 index 0000000000..154f3dbdac --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/text/standardOptions/override.md @@ -0,0 +1,244 @@ +# override + +Overrides allow you to customize visualization settings for specific fields or +series. This is accomplished by adding an override rule that targets +a particular set of fields and that can each define multiple options. + +```jsonnet +override.byType.new('number') ++ override.byType.withPropertiesFromOptions( + panel.standardOptions.withDecimals(2) + + panel.standardOptions.withUnit('s') +) +``` + + +## Index + +* [`obj byName`](#obj-byname) + * [`fn new(value)`](#fn-bynamenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bynamewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bynamewithproperty) +* [`obj byQuery`](#obj-byquery) + * [`fn new(value)`](#fn-byquerynew) + * [`fn withPropertiesFromOptions(options)`](#fn-byquerywithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byquerywithproperty) +* [`obj byRegexp`](#obj-byregexp) + * [`fn new(value)`](#fn-byregexpnew) + * [`fn withPropertiesFromOptions(options)`](#fn-byregexpwithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byregexpwithproperty) +* [`obj byType`](#obj-bytype) + * [`fn new(value)`](#fn-bytypenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bytypewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bytypewithproperty) +* [`obj byValue`](#obj-byvalue) + * [`fn new(value)`](#fn-byvaluenew) + * [`fn withPropertiesFromOptions(options)`](#fn-byvaluewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byvaluewithproperty) + +## Fields + +### obj byName + + +#### fn byName.new + +```jsonnet +byName.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byName`. +#### fn byName.withPropertiesFromOptions + +```jsonnet +byName.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byName.withProperty + +```jsonnet +byName.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byQuery + + +#### fn byQuery.new + +```jsonnet +byQuery.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byQuery`. +#### fn byQuery.withPropertiesFromOptions + +```jsonnet +byQuery.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byQuery.withProperty + +```jsonnet +byQuery.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byRegexp + + +#### fn byRegexp.new + +```jsonnet +byRegexp.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byRegexp`. +#### fn byRegexp.withPropertiesFromOptions + +```jsonnet +byRegexp.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byRegexp.withProperty + +```jsonnet +byRegexp.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byType + + +#### fn byType.new + +```jsonnet +byType.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byType`. +#### fn byType.withPropertiesFromOptions + +```jsonnet +byType.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byType.withProperty + +```jsonnet +byType.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byValue + + +#### fn byValue.new + +```jsonnet +byValue.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byValue`. +#### fn byValue.withPropertiesFromOptions + +```jsonnet +byValue.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byValue.withProperty + +```jsonnet +byValue.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/text/standardOptions/threshold/step.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/text/standardOptions/threshold/step.md new file mode 100644 index 0000000000..dd2dd227ff --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/text/standardOptions/threshold/step.md @@ -0,0 +1,60 @@ +# threshold.step + + + +## Index + +* [`fn withColor(value)`](#fn-withcolor) +* [`fn withIndex(value)`](#fn-withindex) +* [`fn withState(value)`](#fn-withstate) +* [`fn withValue(value)`](#fn-withvalue) + +## Fields + +### fn withColor + +```jsonnet +withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +### fn withIndex + +```jsonnet +withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Threshold index, an old property that is not needed an should only appear in older dashboards +### fn withState + +```jsonnet +withState(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO are the values here enumerable into a disjunction? +Some seem to be listed in typescript comment +### fn withValue + +```jsonnet +withValue(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +FIXME the corresponding typescript field is required/non-optional, but nulls currently appear here when serializing -Infinity to JSON \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/timeSeries/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/timeSeries/index.md new file mode 100644 index 0000000000..fa1d2e7e4c --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/timeSeries/index.md @@ -0,0 +1,1430 @@ +# timeSeries + +grafonnet.panel.timeSeries + +## Subpackages + +* [panelOptions.link](panelOptions/link.md) +* [queryOptions.transformation](queryOptions/transformation.md) +* [standardOptions.mapping](standardOptions/mapping.md) +* [standardOptions.override](standardOptions/override.md) +* [standardOptions.threshold.step](standardOptions/threshold/step.md) + +## Index + +* [`fn new(title)`](#fn-new) +* [`obj fieldConfig`](#obj-fieldconfig) + * [`obj defaults`](#obj-fieldconfigdefaults) + * [`obj custom`](#obj-fieldconfigdefaultscustom) + * [`fn withAxisCenteredZero(value=true)`](#fn-fieldconfigdefaultscustomwithaxiscenteredzero) + * [`fn withAxisColorMode(value)`](#fn-fieldconfigdefaultscustomwithaxiscolormode) + * [`fn withAxisGridShow(value=true)`](#fn-fieldconfigdefaultscustomwithaxisgridshow) + * [`fn withAxisLabel(value)`](#fn-fieldconfigdefaultscustomwithaxislabel) + * [`fn withAxisPlacement(value)`](#fn-fieldconfigdefaultscustomwithaxisplacement) + * [`fn withAxisSoftMax(value)`](#fn-fieldconfigdefaultscustomwithaxissoftmax) + * [`fn withAxisSoftMin(value)`](#fn-fieldconfigdefaultscustomwithaxissoftmin) + * [`fn withAxisWidth(value)`](#fn-fieldconfigdefaultscustomwithaxiswidth) + * [`fn withBarAlignment(value)`](#fn-fieldconfigdefaultscustomwithbaralignment) + * [`fn withBarMaxWidth(value)`](#fn-fieldconfigdefaultscustomwithbarmaxwidth) + * [`fn withBarWidthFactor(value)`](#fn-fieldconfigdefaultscustomwithbarwidthfactor) + * [`fn withDrawStyle(value)`](#fn-fieldconfigdefaultscustomwithdrawstyle) + * [`fn withFillBelowTo(value)`](#fn-fieldconfigdefaultscustomwithfillbelowto) + * [`fn withFillColor(value)`](#fn-fieldconfigdefaultscustomwithfillcolor) + * [`fn withFillOpacity(value)`](#fn-fieldconfigdefaultscustomwithfillopacity) + * [`fn withGradientMode(value)`](#fn-fieldconfigdefaultscustomwithgradientmode) + * [`fn withHideFrom(value)`](#fn-fieldconfigdefaultscustomwithhidefrom) + * [`fn withHideFromMixin(value)`](#fn-fieldconfigdefaultscustomwithhidefrommixin) + * [`fn withLineColor(value)`](#fn-fieldconfigdefaultscustomwithlinecolor) + * [`fn withLineInterpolation(value)`](#fn-fieldconfigdefaultscustomwithlineinterpolation) + * [`fn withLineStyle(value)`](#fn-fieldconfigdefaultscustomwithlinestyle) + * [`fn withLineStyleMixin(value)`](#fn-fieldconfigdefaultscustomwithlinestylemixin) + * [`fn withLineWidth(value)`](#fn-fieldconfigdefaultscustomwithlinewidth) + * [`fn withPointColor(value)`](#fn-fieldconfigdefaultscustomwithpointcolor) + * [`fn withPointSize(value)`](#fn-fieldconfigdefaultscustomwithpointsize) + * [`fn withPointSymbol(value)`](#fn-fieldconfigdefaultscustomwithpointsymbol) + * [`fn withScaleDistribution(value)`](#fn-fieldconfigdefaultscustomwithscaledistribution) + * [`fn withScaleDistributionMixin(value)`](#fn-fieldconfigdefaultscustomwithscaledistributionmixin) + * [`fn withShowPoints(value)`](#fn-fieldconfigdefaultscustomwithshowpoints) + * [`fn withSpanNulls(value)`](#fn-fieldconfigdefaultscustomwithspannulls) + * [`fn withSpanNullsMixin(value)`](#fn-fieldconfigdefaultscustomwithspannullsmixin) + * [`fn withStacking(value)`](#fn-fieldconfigdefaultscustomwithstacking) + * [`fn withStackingMixin(value)`](#fn-fieldconfigdefaultscustomwithstackingmixin) + * [`fn withThresholdsStyle(value)`](#fn-fieldconfigdefaultscustomwiththresholdsstyle) + * [`fn withThresholdsStyleMixin(value)`](#fn-fieldconfigdefaultscustomwiththresholdsstylemixin) + * [`fn withTransform(value)`](#fn-fieldconfigdefaultscustomwithtransform) + * [`obj hideFrom`](#obj-fieldconfigdefaultscustomhidefrom) + * [`fn withLegend(value=true)`](#fn-fieldconfigdefaultscustomhidefromwithlegend) + * [`fn withTooltip(value=true)`](#fn-fieldconfigdefaultscustomhidefromwithtooltip) + * [`fn withViz(value=true)`](#fn-fieldconfigdefaultscustomhidefromwithviz) + * [`obj lineStyle`](#obj-fieldconfigdefaultscustomlinestyle) + * [`fn withDash(value)`](#fn-fieldconfigdefaultscustomlinestylewithdash) + * [`fn withDashMixin(value)`](#fn-fieldconfigdefaultscustomlinestylewithdashmixin) + * [`fn withFill(value)`](#fn-fieldconfigdefaultscustomlinestylewithfill) + * [`obj scaleDistribution`](#obj-fieldconfigdefaultscustomscaledistribution) + * [`fn withLinearThreshold(value)`](#fn-fieldconfigdefaultscustomscaledistributionwithlinearthreshold) + * [`fn withLog(value)`](#fn-fieldconfigdefaultscustomscaledistributionwithlog) + * [`fn withType(value)`](#fn-fieldconfigdefaultscustomscaledistributionwithtype) + * [`obj stacking`](#obj-fieldconfigdefaultscustomstacking) + * [`fn withGroup(value)`](#fn-fieldconfigdefaultscustomstackingwithgroup) + * [`fn withMode(value)`](#fn-fieldconfigdefaultscustomstackingwithmode) + * [`obj thresholdsStyle`](#obj-fieldconfigdefaultscustomthresholdsstyle) + * [`fn withMode(value)`](#fn-fieldconfigdefaultscustomthresholdsstylewithmode) +* [`obj libraryPanel`](#obj-librarypanel) + * [`fn withName(value)`](#fn-librarypanelwithname) + * [`fn withUid(value)`](#fn-librarypanelwithuid) +* [`obj options`](#obj-options) + * [`fn withLegend(value)`](#fn-optionswithlegend) + * [`fn withLegendMixin(value)`](#fn-optionswithlegendmixin) + * [`fn withTimezone(value)`](#fn-optionswithtimezone) + * [`fn withTimezoneMixin(value)`](#fn-optionswithtimezonemixin) + * [`fn withTooltip(value)`](#fn-optionswithtooltip) + * [`fn withTooltipMixin(value)`](#fn-optionswithtooltipmixin) + * [`obj legend`](#obj-optionslegend) + * [`fn withAsTable(value=true)`](#fn-optionslegendwithastable) + * [`fn withCalcs(value)`](#fn-optionslegendwithcalcs) + * [`fn withCalcsMixin(value)`](#fn-optionslegendwithcalcsmixin) + * [`fn withDisplayMode(value)`](#fn-optionslegendwithdisplaymode) + * [`fn withIsVisible(value=true)`](#fn-optionslegendwithisvisible) + * [`fn withPlacement(value)`](#fn-optionslegendwithplacement) + * [`fn withShowLegend(value=true)`](#fn-optionslegendwithshowlegend) + * [`fn withSortBy(value)`](#fn-optionslegendwithsortby) + * [`fn withSortDesc(value=true)`](#fn-optionslegendwithsortdesc) + * [`fn withWidth(value)`](#fn-optionslegendwithwidth) + * [`obj tooltip`](#obj-optionstooltip) + * [`fn withMode(value)`](#fn-optionstooltipwithmode) + * [`fn withSort(value)`](#fn-optionstooltipwithsort) +* [`obj panelOptions`](#obj-paneloptions) + * [`fn withDescription(value)`](#fn-paneloptionswithdescription) + * [`fn withGridPos(h="null", w="null", x="null", y="null")`](#fn-paneloptionswithgridpos) + * [`fn withLinks(value)`](#fn-paneloptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-paneloptionswithlinksmixin) + * [`fn withRepeat(value)`](#fn-paneloptionswithrepeat) + * [`fn withRepeatDirection(value="h")`](#fn-paneloptionswithrepeatdirection) + * [`fn withTitle(value)`](#fn-paneloptionswithtitle) + * [`fn withTransparent(value=true)`](#fn-paneloptionswithtransparent) +* [`obj queryOptions`](#obj-queryoptions) + * [`fn withDatasource(type, uid)`](#fn-queryoptionswithdatasource) + * [`fn withDatasourceMixin(value)`](#fn-queryoptionswithdatasourcemixin) + * [`fn withInterval(value)`](#fn-queryoptionswithinterval) + * [`fn withMaxDataPoints(value)`](#fn-queryoptionswithmaxdatapoints) + * [`fn withTargets(value)`](#fn-queryoptionswithtargets) + * [`fn withTargetsMixin(value)`](#fn-queryoptionswithtargetsmixin) + * [`fn withTimeFrom(value)`](#fn-queryoptionswithtimefrom) + * [`fn withTimeShift(value)`](#fn-queryoptionswithtimeshift) + * [`fn withTransformations(value)`](#fn-queryoptionswithtransformations) + * [`fn withTransformationsMixin(value)`](#fn-queryoptionswithtransformationsmixin) +* [`obj standardOptions`](#obj-standardoptions) + * [`fn withDecimals(value)`](#fn-standardoptionswithdecimals) + * [`fn withDisplayName(value)`](#fn-standardoptionswithdisplayname) + * [`fn withFilterable(value=true)`](#fn-standardoptionswithfilterable) + * [`fn withLinks(value)`](#fn-standardoptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-standardoptionswithlinksmixin) + * [`fn withMappings(value)`](#fn-standardoptionswithmappings) + * [`fn withMappingsMixin(value)`](#fn-standardoptionswithmappingsmixin) + * [`fn withMax(value)`](#fn-standardoptionswithmax) + * [`fn withMin(value)`](#fn-standardoptionswithmin) + * [`fn withNoValue(value)`](#fn-standardoptionswithnovalue) + * [`fn withOverrides(value)`](#fn-standardoptionswithoverrides) + * [`fn withOverridesMixin(value)`](#fn-standardoptionswithoverridesmixin) + * [`fn withPath(value)`](#fn-standardoptionswithpath) + * [`fn withUnit(value)`](#fn-standardoptionswithunit) + * [`obj color`](#obj-standardoptionscolor) + * [`fn withFixedColor(value)`](#fn-standardoptionscolorwithfixedcolor) + * [`fn withMode(value)`](#fn-standardoptionscolorwithmode) + * [`fn withSeriesBy(value)`](#fn-standardoptionscolorwithseriesby) + * [`obj thresholds`](#obj-standardoptionsthresholds) + * [`fn withMode(value)`](#fn-standardoptionsthresholdswithmode) + * [`fn withSteps(value)`](#fn-standardoptionsthresholdswithsteps) + * [`fn withStepsMixin(value)`](#fn-standardoptionsthresholdswithstepsmixin) + +## Fields + +### fn new + +```jsonnet +new(title) +``` + +PARAMETERS: + +* **title** (`string`) + +Creates a new timeSeries panel with a title. +### obj fieldConfig + + +#### obj fieldConfig.defaults + + +##### obj fieldConfig.defaults.custom + + +###### fn fieldConfig.defaults.custom.withAxisCenteredZero + +```jsonnet +fieldConfig.defaults.custom.withAxisCenteredZero(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +###### fn fieldConfig.defaults.custom.withAxisColorMode + +```jsonnet +fieldConfig.defaults.custom.withAxisColorMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"text"`, `"series"` + +TODO docs +###### fn fieldConfig.defaults.custom.withAxisGridShow + +```jsonnet +fieldConfig.defaults.custom.withAxisGridShow(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +###### fn fieldConfig.defaults.custom.withAxisLabel + +```jsonnet +fieldConfig.defaults.custom.withAxisLabel(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn fieldConfig.defaults.custom.withAxisPlacement + +```jsonnet +fieldConfig.defaults.custom.withAxisPlacement(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"auto"`, `"top"`, `"right"`, `"bottom"`, `"left"`, `"hidden"` + +TODO docs +###### fn fieldConfig.defaults.custom.withAxisSoftMax + +```jsonnet +fieldConfig.defaults.custom.withAxisSoftMax(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +###### fn fieldConfig.defaults.custom.withAxisSoftMin + +```jsonnet +fieldConfig.defaults.custom.withAxisSoftMin(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +###### fn fieldConfig.defaults.custom.withAxisWidth + +```jsonnet +fieldConfig.defaults.custom.withAxisWidth(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +###### fn fieldConfig.defaults.custom.withBarAlignment + +```jsonnet +fieldConfig.defaults.custom.withBarAlignment(value) +``` + +PARAMETERS: + +* **value** (`integer`) + - valid values: `-1`, `0`, `1` + +TODO docs +###### fn fieldConfig.defaults.custom.withBarMaxWidth + +```jsonnet +fieldConfig.defaults.custom.withBarMaxWidth(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +###### fn fieldConfig.defaults.custom.withBarWidthFactor + +```jsonnet +fieldConfig.defaults.custom.withBarWidthFactor(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +###### fn fieldConfig.defaults.custom.withDrawStyle + +```jsonnet +fieldConfig.defaults.custom.withDrawStyle(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"line"`, `"bars"`, `"points"` + +TODO docs +###### fn fieldConfig.defaults.custom.withFillBelowTo + +```jsonnet +fieldConfig.defaults.custom.withFillBelowTo(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn fieldConfig.defaults.custom.withFillColor + +```jsonnet +fieldConfig.defaults.custom.withFillColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn fieldConfig.defaults.custom.withFillOpacity + +```jsonnet +fieldConfig.defaults.custom.withFillOpacity(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +###### fn fieldConfig.defaults.custom.withGradientMode + +```jsonnet +fieldConfig.defaults.custom.withGradientMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"none"`, `"opacity"`, `"hue"`, `"scheme"` + +TODO docs +###### fn fieldConfig.defaults.custom.withHideFrom + +```jsonnet +fieldConfig.defaults.custom.withHideFrom(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn fieldConfig.defaults.custom.withHideFromMixin + +```jsonnet +fieldConfig.defaults.custom.withHideFromMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn fieldConfig.defaults.custom.withLineColor + +```jsonnet +fieldConfig.defaults.custom.withLineColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn fieldConfig.defaults.custom.withLineInterpolation + +```jsonnet +fieldConfig.defaults.custom.withLineInterpolation(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"linear"`, `"smooth"`, `"stepBefore"`, `"stepAfter"` + +TODO docs +###### fn fieldConfig.defaults.custom.withLineStyle + +```jsonnet +fieldConfig.defaults.custom.withLineStyle(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn fieldConfig.defaults.custom.withLineStyleMixin + +```jsonnet +fieldConfig.defaults.custom.withLineStyleMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn fieldConfig.defaults.custom.withLineWidth + +```jsonnet +fieldConfig.defaults.custom.withLineWidth(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +###### fn fieldConfig.defaults.custom.withPointColor + +```jsonnet +fieldConfig.defaults.custom.withPointColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn fieldConfig.defaults.custom.withPointSize + +```jsonnet +fieldConfig.defaults.custom.withPointSize(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +###### fn fieldConfig.defaults.custom.withPointSymbol + +```jsonnet +fieldConfig.defaults.custom.withPointSymbol(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn fieldConfig.defaults.custom.withScaleDistribution + +```jsonnet +fieldConfig.defaults.custom.withScaleDistribution(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn fieldConfig.defaults.custom.withScaleDistributionMixin + +```jsonnet +fieldConfig.defaults.custom.withScaleDistributionMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn fieldConfig.defaults.custom.withShowPoints + +```jsonnet +fieldConfig.defaults.custom.withShowPoints(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"auto"`, `"never"`, `"always"` + +TODO docs +###### fn fieldConfig.defaults.custom.withSpanNulls + +```jsonnet +fieldConfig.defaults.custom.withSpanNulls(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Indicate if null values should be treated as gaps or connected. +When the value is a number, it represents the maximum delta in the +X axis that should be considered connected. For timeseries, this is milliseconds +###### fn fieldConfig.defaults.custom.withSpanNullsMixin + +```jsonnet +fieldConfig.defaults.custom.withSpanNullsMixin(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Indicate if null values should be treated as gaps or connected. +When the value is a number, it represents the maximum delta in the +X axis that should be considered connected. For timeseries, this is milliseconds +###### fn fieldConfig.defaults.custom.withStacking + +```jsonnet +fieldConfig.defaults.custom.withStacking(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn fieldConfig.defaults.custom.withStackingMixin + +```jsonnet +fieldConfig.defaults.custom.withStackingMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn fieldConfig.defaults.custom.withThresholdsStyle + +```jsonnet +fieldConfig.defaults.custom.withThresholdsStyle(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn fieldConfig.defaults.custom.withThresholdsStyleMixin + +```jsonnet +fieldConfig.defaults.custom.withThresholdsStyleMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn fieldConfig.defaults.custom.withTransform + +```jsonnet +fieldConfig.defaults.custom.withTransform(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"constant"`, `"negative-Y"` + +TODO docs +###### obj fieldConfig.defaults.custom.hideFrom + + +####### fn fieldConfig.defaults.custom.hideFrom.withLegend + +```jsonnet +fieldConfig.defaults.custom.hideFrom.withLegend(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +####### fn fieldConfig.defaults.custom.hideFrom.withTooltip + +```jsonnet +fieldConfig.defaults.custom.hideFrom.withTooltip(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +####### fn fieldConfig.defaults.custom.hideFrom.withViz + +```jsonnet +fieldConfig.defaults.custom.hideFrom.withViz(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +###### obj fieldConfig.defaults.custom.lineStyle + + +####### fn fieldConfig.defaults.custom.lineStyle.withDash + +```jsonnet +fieldConfig.defaults.custom.lineStyle.withDash(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +####### fn fieldConfig.defaults.custom.lineStyle.withDashMixin + +```jsonnet +fieldConfig.defaults.custom.lineStyle.withDashMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +####### fn fieldConfig.defaults.custom.lineStyle.withFill + +```jsonnet +fieldConfig.defaults.custom.lineStyle.withFill(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"solid"`, `"dash"`, `"dot"`, `"square"` + + +###### obj fieldConfig.defaults.custom.scaleDistribution + + +####### fn fieldConfig.defaults.custom.scaleDistribution.withLinearThreshold + +```jsonnet +fieldConfig.defaults.custom.scaleDistribution.withLinearThreshold(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +####### fn fieldConfig.defaults.custom.scaleDistribution.withLog + +```jsonnet +fieldConfig.defaults.custom.scaleDistribution.withLog(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +####### fn fieldConfig.defaults.custom.scaleDistribution.withType + +```jsonnet +fieldConfig.defaults.custom.scaleDistribution.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"linear"`, `"log"`, `"ordinal"`, `"symlog"` + +TODO docs +###### obj fieldConfig.defaults.custom.stacking + + +####### fn fieldConfig.defaults.custom.stacking.withGroup + +```jsonnet +fieldConfig.defaults.custom.stacking.withGroup(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +####### fn fieldConfig.defaults.custom.stacking.withMode + +```jsonnet +fieldConfig.defaults.custom.stacking.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"none"`, `"normal"`, `"percent"` + +TODO docs +###### obj fieldConfig.defaults.custom.thresholdsStyle + + +####### fn fieldConfig.defaults.custom.thresholdsStyle.withMode + +```jsonnet +fieldConfig.defaults.custom.thresholdsStyle.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"off"`, `"line"`, `"dashed"`, `"area"`, `"line+area"`, `"dashed+area"`, `"series"` + +TODO docs +### obj libraryPanel + + +#### fn libraryPanel.withName + +```jsonnet +libraryPanel.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn libraryPanel.withUid + +```jsonnet +libraryPanel.withUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj options + + +#### fn options.withLegend + +```jsonnet +options.withLegend(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withLegendMixin + +```jsonnet +options.withLegendMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withTimezone + +```jsonnet +options.withTimezone(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn options.withTimezoneMixin + +```jsonnet +options.withTimezoneMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn options.withTooltip + +```jsonnet +options.withTooltip(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withTooltipMixin + +```jsonnet +options.withTooltipMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### obj options.legend + + +##### fn options.legend.withAsTable + +```jsonnet +options.legend.withAsTable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.legend.withCalcs + +```jsonnet +options.legend.withCalcs(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +##### fn options.legend.withCalcsMixin + +```jsonnet +options.legend.withCalcsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +##### fn options.legend.withDisplayMode + +```jsonnet +options.legend.withDisplayMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"list"`, `"table"`, `"hidden"` + +TODO docs +Note: "hidden" needs to remain as an option for plugins compatibility +##### fn options.legend.withIsVisible + +```jsonnet +options.legend.withIsVisible(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.legend.withPlacement + +```jsonnet +options.legend.withPlacement(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"bottom"`, `"right"` + +TODO docs +##### fn options.legend.withShowLegend + +```jsonnet +options.legend.withShowLegend(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.legend.withSortBy + +```jsonnet +options.legend.withSortBy(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn options.legend.withSortDesc + +```jsonnet +options.legend.withSortDesc(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.legend.withWidth + +```jsonnet +options.legend.withWidth(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### obj options.tooltip + + +##### fn options.tooltip.withMode + +```jsonnet +options.tooltip.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"single"`, `"multi"`, `"none"` + +TODO docs +##### fn options.tooltip.withSort + +```jsonnet +options.tooltip.withSort(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"asc"`, `"desc"`, `"none"` + +TODO docs +### obj panelOptions + + +#### fn panelOptions.withDescription + +```jsonnet +panelOptions.withDescription(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Description. +#### fn panelOptions.withGridPos + +```jsonnet +panelOptions.withGridPos(h="null", w="null", x="null", y="null") +``` + +PARAMETERS: + +* **h** (`number`) + - default value: `"null"` +* **w** (`number`) + - default value: `"null"` +* **x** (`number`) + - default value: `"null"` +* **y** (`number`) + - default value: `"null"` + +`withGridPos` configures the height, width and xy coordinates of the panel. Also see `grafonnet.util.grid` for helper functions to calculate these fields. + +All arguments default to `null`, which means they will remain unchanged or unset. + +#### fn panelOptions.withLinks + +```jsonnet +panelOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withLinksMixin + +```jsonnet +panelOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withRepeat + +```jsonnet +panelOptions.withRepeat(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of template variable to repeat for. +#### fn panelOptions.withRepeatDirection + +```jsonnet +panelOptions.withRepeatDirection(value="h") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"h"` + - valid values: `"h"`, `"v"` + +Direction to repeat in if 'repeat' is set. +"h" for horizontal, "v" for vertical. +TODO this is probably optional +#### fn panelOptions.withTitle + +```jsonnet +panelOptions.withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Panel title. +#### fn panelOptions.withTransparent + +```jsonnet +panelOptions.withTransparent(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Whether to display the panel without a background. +### obj queryOptions + + +#### fn queryOptions.withDatasource + +```jsonnet +queryOptions.withDatasource(type, uid) +``` + +PARAMETERS: + +* **type** (`string`) +* **uid** (`string`) + +`withDatasource` sets the datasource for all queries in a panel. + +The default datasource for a panel is set to 'Mixed datasource' so panels can be datasource agnostic, which is a lot more interesting from a reusability standpoint. Note that this requires query targets to explicitly set datasource for the same reason. + +#### fn queryOptions.withDatasourceMixin + +```jsonnet +queryOptions.withDatasourceMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +The datasource used in all targets. +#### fn queryOptions.withInterval + +```jsonnet +queryOptions.withInterval(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withMaxDataPoints + +```jsonnet +queryOptions.withMaxDataPoints(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +#### fn queryOptions.withTargets + +```jsonnet +queryOptions.withTargets(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTargetsMixin + +```jsonnet +queryOptions.withTargetsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTimeFrom + +```jsonnet +queryOptions.withTimeFrom(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTimeShift + +```jsonnet +queryOptions.withTimeShift(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTransformations + +```jsonnet +queryOptions.withTransformations(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn queryOptions.withTransformationsMixin + +```jsonnet +queryOptions.withTransformationsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### obj standardOptions + + +#### fn standardOptions.withDecimals + +```jsonnet +standardOptions.withDecimals(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Significant digits (for display) +#### fn standardOptions.withDisplayName + +```jsonnet +standardOptions.withDisplayName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The display value for this field. This supports template variables blank is auto +#### fn standardOptions.withFilterable + +```jsonnet +standardOptions.withFilterable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +True if data source field supports ad-hoc filters +#### fn standardOptions.withLinks + +```jsonnet +standardOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withLinksMixin + +```jsonnet +standardOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withMappings + +```jsonnet +standardOptions.withMappings(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMappingsMixin + +```jsonnet +standardOptions.withMappingsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMax + +```jsonnet +standardOptions.withMax(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withMin + +```jsonnet +standardOptions.withMin(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withNoValue + +```jsonnet +standardOptions.withNoValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Alternative to empty string +#### fn standardOptions.withOverrides + +```jsonnet +standardOptions.withOverrides(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withOverridesMixin + +```jsonnet +standardOptions.withOverridesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withPath + +```jsonnet +standardOptions.withPath(value) +``` + +PARAMETERS: + +* **value** (`string`) + +An explicit path to the field in the datasource. When the frame meta includes a path, +This will default to `${frame.meta.path}/${field.name} + +When defined, this value can be used as an identifier within the datasource scope, and +may be used to update the results +#### fn standardOptions.withUnit + +```jsonnet +standardOptions.withUnit(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Numeric Options +#### obj standardOptions.color + + +##### fn standardOptions.color.withFixedColor + +```jsonnet +standardOptions.color.withFixedColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Stores the fixed color value if mode is fixed +##### fn standardOptions.color.withMode + +```jsonnet +standardOptions.color.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The main color scheme mode +##### fn standardOptions.color.withSeriesBy + +```jsonnet +standardOptions.color.withSeriesBy(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"min"`, `"max"`, `"last"` + +TODO docs +#### obj standardOptions.thresholds + + +##### fn standardOptions.thresholds.withMode + +```jsonnet +standardOptions.thresholds.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"absolute"`, `"percentage"` + + +##### fn standardOptions.thresholds.withSteps + +```jsonnet +standardOptions.thresholds.withSteps(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity +##### fn standardOptions.thresholds.withStepsMixin + +```jsonnet +standardOptions.thresholds.withStepsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/timeSeries/panelOptions/link.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/timeSeries/panelOptions/link.md new file mode 100644 index 0000000000..106f9d2edb --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/timeSeries/panelOptions/link.md @@ -0,0 +1,145 @@ +# link + + + +## Index + +* [`fn withAsDropdown(value=true)`](#fn-withasdropdown) +* [`fn withIcon(value)`](#fn-withicon) +* [`fn withIncludeVars(value=true)`](#fn-withincludevars) +* [`fn withKeepTime(value=true)`](#fn-withkeeptime) +* [`fn withTags(value)`](#fn-withtags) +* [`fn withTagsMixin(value)`](#fn-withtagsmixin) +* [`fn withTargetBlank(value=true)`](#fn-withtargetblank) +* [`fn withTitle(value)`](#fn-withtitle) +* [`fn withTooltip(value)`](#fn-withtooltip) +* [`fn withType(value)`](#fn-withtype) +* [`fn withUrl(value)`](#fn-withurl) + +## Fields + +### fn withAsDropdown + +```jsonnet +withAsDropdown(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withIcon + +```jsonnet +withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withIncludeVars + +```jsonnet +withIncludeVars(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withKeepTime + +```jsonnet +withKeepTime(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTags + +```jsonnet +withTags(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTagsMixin + +```jsonnet +withTagsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTargetBlank + +```jsonnet +withTargetBlank(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTitle + +```jsonnet +withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withTooltip + +```jsonnet +withTooltip(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withType + +```jsonnet +withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"link"`, `"dashboards"` + +TODO docs +### fn withUrl + +```jsonnet +withUrl(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/timeSeries/queryOptions/transformation.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/timeSeries/queryOptions/transformation.md new file mode 100644 index 0000000000..dc832f653d --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/timeSeries/queryOptions/transformation.md @@ -0,0 +1,99 @@ +# transformation + + + +## Index + +* [`fn withDisabled(value=true)`](#fn-withdisabled) +* [`fn withFilter(value)`](#fn-withfilter) +* [`fn withFilterMixin(value)`](#fn-withfiltermixin) +* [`fn withId(value)`](#fn-withid) +* [`fn withOptions(value)`](#fn-withoptions) +* [`obj filter`](#obj-filter) + * [`fn withId(value="")`](#fn-filterwithid) + * [`fn withOptions(value)`](#fn-filterwithoptions) + +## Fields + +### fn withDisabled + +```jsonnet +withDisabled(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Disabled transformations are skipped +### fn withFilter + +```jsonnet +withFilter(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withFilterMixin + +```jsonnet +withFilterMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withId + +```jsonnet +withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Unique identifier of transformer +### fn withOptions + +```jsonnet +withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Options to be passed to the transformer +Valid options depend on the transformer id +### obj filter + + +#### fn filter.withId + +```jsonnet +filter.withId(value="") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `""` + + +#### fn filter.withOptions + +```jsonnet +filter.withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/timeSeries/standardOptions/mapping.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/timeSeries/standardOptions/mapping.md new file mode 100644 index 0000000000..93296972e8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/timeSeries/standardOptions/mapping.md @@ -0,0 +1,469 @@ +# mapping + + + +## Index + +* [`obj RangeMap`](#obj-rangemap) + * [`fn withOptions(value)`](#fn-rangemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-rangemapwithoptionsmixin) + * [`fn withType(value)`](#fn-rangemapwithtype) + * [`obj options`](#obj-rangemapoptions) + * [`fn withFrom(value)`](#fn-rangemapoptionswithfrom) + * [`fn withResult(value)`](#fn-rangemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-rangemapoptionswithresultmixin) + * [`fn withTo(value)`](#fn-rangemapoptionswithto) + * [`obj result`](#obj-rangemapoptionsresult) + * [`fn withColor(value)`](#fn-rangemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-rangemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-rangemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-rangemapoptionsresultwithtext) +* [`obj RegexMap`](#obj-regexmap) + * [`fn withOptions(value)`](#fn-regexmapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-regexmapwithoptionsmixin) + * [`fn withType(value)`](#fn-regexmapwithtype) + * [`obj options`](#obj-regexmapoptions) + * [`fn withPattern(value)`](#fn-regexmapoptionswithpattern) + * [`fn withResult(value)`](#fn-regexmapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-regexmapoptionswithresultmixin) + * [`obj result`](#obj-regexmapoptionsresult) + * [`fn withColor(value)`](#fn-regexmapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-regexmapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-regexmapoptionsresultwithindex) + * [`fn withText(value)`](#fn-regexmapoptionsresultwithtext) +* [`obj SpecialValueMap`](#obj-specialvaluemap) + * [`fn withOptions(value)`](#fn-specialvaluemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-specialvaluemapwithoptionsmixin) + * [`fn withType(value)`](#fn-specialvaluemapwithtype) + * [`obj options`](#obj-specialvaluemapoptions) + * [`fn withMatch(value)`](#fn-specialvaluemapoptionswithmatch) + * [`fn withPattern(value)`](#fn-specialvaluemapoptionswithpattern) + * [`fn withResult(value)`](#fn-specialvaluemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-specialvaluemapoptionswithresultmixin) + * [`obj result`](#obj-specialvaluemapoptionsresult) + * [`fn withColor(value)`](#fn-specialvaluemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-specialvaluemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-specialvaluemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-specialvaluemapoptionsresultwithtext) +* [`obj ValueMap`](#obj-valuemap) + * [`fn withOptions(value)`](#fn-valuemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-valuemapwithoptionsmixin) + * [`fn withType(value)`](#fn-valuemapwithtype) + +## Fields + +### obj RangeMap + + +#### fn RangeMap.withOptions + +```jsonnet +RangeMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withOptionsMixin + +```jsonnet +RangeMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withType + +```jsonnet +RangeMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RangeMap.options + + +##### fn RangeMap.options.withFrom + +```jsonnet +RangeMap.options.withFrom(value) +``` + +PARAMETERS: + +* **value** (`number`) + +to and from are `number | null` in current ts, really not sure what to do +##### fn RangeMap.options.withResult + +```jsonnet +RangeMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withResultMixin + +```jsonnet +RangeMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withTo + +```jsonnet +RangeMap.options.withTo(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +##### obj RangeMap.options.result + + +###### fn RangeMap.options.result.withColor + +```jsonnet +RangeMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIcon + +```jsonnet +RangeMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIndex + +```jsonnet +RangeMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RangeMap.options.result.withText + +```jsonnet +RangeMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj RegexMap + + +#### fn RegexMap.withOptions + +```jsonnet +RegexMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withOptionsMixin + +```jsonnet +RegexMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withType + +```jsonnet +RegexMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RegexMap.options + + +##### fn RegexMap.options.withPattern + +```jsonnet +RegexMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn RegexMap.options.withResult + +```jsonnet +RegexMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RegexMap.options.withResultMixin + +```jsonnet +RegexMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj RegexMap.options.result + + +###### fn RegexMap.options.result.withColor + +```jsonnet +RegexMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIcon + +```jsonnet +RegexMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIndex + +```jsonnet +RegexMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RegexMap.options.result.withText + +```jsonnet +RegexMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj SpecialValueMap + + +#### fn SpecialValueMap.withOptions + +```jsonnet +SpecialValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withOptionsMixin + +```jsonnet +SpecialValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withType + +```jsonnet +SpecialValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj SpecialValueMap.options + + +##### fn SpecialValueMap.options.withMatch + +```jsonnet +SpecialValueMap.options.withMatch(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"true"`, `"false"` + + +##### fn SpecialValueMap.options.withPattern + +```jsonnet +SpecialValueMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn SpecialValueMap.options.withResult + +```jsonnet +SpecialValueMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn SpecialValueMap.options.withResultMixin + +```jsonnet +SpecialValueMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj SpecialValueMap.options.result + + +###### fn SpecialValueMap.options.result.withColor + +```jsonnet +SpecialValueMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIcon + +```jsonnet +SpecialValueMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIndex + +```jsonnet +SpecialValueMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn SpecialValueMap.options.result.withText + +```jsonnet +SpecialValueMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj ValueMap + + +#### fn ValueMap.withOptions + +```jsonnet +ValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withOptionsMixin + +```jsonnet +ValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withType + +```jsonnet +ValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/timeSeries/standardOptions/override.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/timeSeries/standardOptions/override.md new file mode 100644 index 0000000000..154f3dbdac --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/timeSeries/standardOptions/override.md @@ -0,0 +1,244 @@ +# override + +Overrides allow you to customize visualization settings for specific fields or +series. This is accomplished by adding an override rule that targets +a particular set of fields and that can each define multiple options. + +```jsonnet +override.byType.new('number') ++ override.byType.withPropertiesFromOptions( + panel.standardOptions.withDecimals(2) + + panel.standardOptions.withUnit('s') +) +``` + + +## Index + +* [`obj byName`](#obj-byname) + * [`fn new(value)`](#fn-bynamenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bynamewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bynamewithproperty) +* [`obj byQuery`](#obj-byquery) + * [`fn new(value)`](#fn-byquerynew) + * [`fn withPropertiesFromOptions(options)`](#fn-byquerywithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byquerywithproperty) +* [`obj byRegexp`](#obj-byregexp) + * [`fn new(value)`](#fn-byregexpnew) + * [`fn withPropertiesFromOptions(options)`](#fn-byregexpwithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byregexpwithproperty) +* [`obj byType`](#obj-bytype) + * [`fn new(value)`](#fn-bytypenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bytypewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bytypewithproperty) +* [`obj byValue`](#obj-byvalue) + * [`fn new(value)`](#fn-byvaluenew) + * [`fn withPropertiesFromOptions(options)`](#fn-byvaluewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byvaluewithproperty) + +## Fields + +### obj byName + + +#### fn byName.new + +```jsonnet +byName.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byName`. +#### fn byName.withPropertiesFromOptions + +```jsonnet +byName.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byName.withProperty + +```jsonnet +byName.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byQuery + + +#### fn byQuery.new + +```jsonnet +byQuery.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byQuery`. +#### fn byQuery.withPropertiesFromOptions + +```jsonnet +byQuery.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byQuery.withProperty + +```jsonnet +byQuery.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byRegexp + + +#### fn byRegexp.new + +```jsonnet +byRegexp.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byRegexp`. +#### fn byRegexp.withPropertiesFromOptions + +```jsonnet +byRegexp.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byRegexp.withProperty + +```jsonnet +byRegexp.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byType + + +#### fn byType.new + +```jsonnet +byType.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byType`. +#### fn byType.withPropertiesFromOptions + +```jsonnet +byType.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byType.withProperty + +```jsonnet +byType.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byValue + + +#### fn byValue.new + +```jsonnet +byValue.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byValue`. +#### fn byValue.withPropertiesFromOptions + +```jsonnet +byValue.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byValue.withProperty + +```jsonnet +byValue.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/timeSeries/standardOptions/threshold/step.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/timeSeries/standardOptions/threshold/step.md new file mode 100644 index 0000000000..dd2dd227ff --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/timeSeries/standardOptions/threshold/step.md @@ -0,0 +1,60 @@ +# threshold.step + + + +## Index + +* [`fn withColor(value)`](#fn-withcolor) +* [`fn withIndex(value)`](#fn-withindex) +* [`fn withState(value)`](#fn-withstate) +* [`fn withValue(value)`](#fn-withvalue) + +## Fields + +### fn withColor + +```jsonnet +withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +### fn withIndex + +```jsonnet +withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Threshold index, an old property that is not needed an should only appear in older dashboards +### fn withState + +```jsonnet +withState(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO are the values here enumerable into a disjunction? +Some seem to be listed in typescript comment +### fn withValue + +```jsonnet +withValue(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +FIXME the corresponding typescript field is required/non-optional, but nulls currently appear here when serializing -Infinity to JSON \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/trend/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/trend/index.md new file mode 100644 index 0000000000..cb752f91ed --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/trend/index.md @@ -0,0 +1,1418 @@ +# trend + +grafonnet.panel.trend + +## Subpackages + +* [panelOptions.link](panelOptions/link.md) +* [queryOptions.transformation](queryOptions/transformation.md) +* [standardOptions.mapping](standardOptions/mapping.md) +* [standardOptions.override](standardOptions/override.md) +* [standardOptions.threshold.step](standardOptions/threshold/step.md) + +## Index + +* [`fn new(title)`](#fn-new) +* [`obj fieldConfig`](#obj-fieldconfig) + * [`obj defaults`](#obj-fieldconfigdefaults) + * [`obj custom`](#obj-fieldconfigdefaultscustom) + * [`fn withAxisCenteredZero(value=true)`](#fn-fieldconfigdefaultscustomwithaxiscenteredzero) + * [`fn withAxisColorMode(value)`](#fn-fieldconfigdefaultscustomwithaxiscolormode) + * [`fn withAxisGridShow(value=true)`](#fn-fieldconfigdefaultscustomwithaxisgridshow) + * [`fn withAxisLabel(value)`](#fn-fieldconfigdefaultscustomwithaxislabel) + * [`fn withAxisPlacement(value)`](#fn-fieldconfigdefaultscustomwithaxisplacement) + * [`fn withAxisSoftMax(value)`](#fn-fieldconfigdefaultscustomwithaxissoftmax) + * [`fn withAxisSoftMin(value)`](#fn-fieldconfigdefaultscustomwithaxissoftmin) + * [`fn withAxisWidth(value)`](#fn-fieldconfigdefaultscustomwithaxiswidth) + * [`fn withBarAlignment(value)`](#fn-fieldconfigdefaultscustomwithbaralignment) + * [`fn withBarMaxWidth(value)`](#fn-fieldconfigdefaultscustomwithbarmaxwidth) + * [`fn withBarWidthFactor(value)`](#fn-fieldconfigdefaultscustomwithbarwidthfactor) + * [`fn withDrawStyle(value)`](#fn-fieldconfigdefaultscustomwithdrawstyle) + * [`fn withFillBelowTo(value)`](#fn-fieldconfigdefaultscustomwithfillbelowto) + * [`fn withFillColor(value)`](#fn-fieldconfigdefaultscustomwithfillcolor) + * [`fn withFillOpacity(value)`](#fn-fieldconfigdefaultscustomwithfillopacity) + * [`fn withGradientMode(value)`](#fn-fieldconfigdefaultscustomwithgradientmode) + * [`fn withHideFrom(value)`](#fn-fieldconfigdefaultscustomwithhidefrom) + * [`fn withHideFromMixin(value)`](#fn-fieldconfigdefaultscustomwithhidefrommixin) + * [`fn withLineColor(value)`](#fn-fieldconfigdefaultscustomwithlinecolor) + * [`fn withLineInterpolation(value)`](#fn-fieldconfigdefaultscustomwithlineinterpolation) + * [`fn withLineStyle(value)`](#fn-fieldconfigdefaultscustomwithlinestyle) + * [`fn withLineStyleMixin(value)`](#fn-fieldconfigdefaultscustomwithlinestylemixin) + * [`fn withLineWidth(value)`](#fn-fieldconfigdefaultscustomwithlinewidth) + * [`fn withPointColor(value)`](#fn-fieldconfigdefaultscustomwithpointcolor) + * [`fn withPointSize(value)`](#fn-fieldconfigdefaultscustomwithpointsize) + * [`fn withPointSymbol(value)`](#fn-fieldconfigdefaultscustomwithpointsymbol) + * [`fn withScaleDistribution(value)`](#fn-fieldconfigdefaultscustomwithscaledistribution) + * [`fn withScaleDistributionMixin(value)`](#fn-fieldconfigdefaultscustomwithscaledistributionmixin) + * [`fn withShowPoints(value)`](#fn-fieldconfigdefaultscustomwithshowpoints) + * [`fn withSpanNulls(value)`](#fn-fieldconfigdefaultscustomwithspannulls) + * [`fn withSpanNullsMixin(value)`](#fn-fieldconfigdefaultscustomwithspannullsmixin) + * [`fn withStacking(value)`](#fn-fieldconfigdefaultscustomwithstacking) + * [`fn withStackingMixin(value)`](#fn-fieldconfigdefaultscustomwithstackingmixin) + * [`fn withThresholdsStyle(value)`](#fn-fieldconfigdefaultscustomwiththresholdsstyle) + * [`fn withThresholdsStyleMixin(value)`](#fn-fieldconfigdefaultscustomwiththresholdsstylemixin) + * [`fn withTransform(value)`](#fn-fieldconfigdefaultscustomwithtransform) + * [`obj hideFrom`](#obj-fieldconfigdefaultscustomhidefrom) + * [`fn withLegend(value=true)`](#fn-fieldconfigdefaultscustomhidefromwithlegend) + * [`fn withTooltip(value=true)`](#fn-fieldconfigdefaultscustomhidefromwithtooltip) + * [`fn withViz(value=true)`](#fn-fieldconfigdefaultscustomhidefromwithviz) + * [`obj lineStyle`](#obj-fieldconfigdefaultscustomlinestyle) + * [`fn withDash(value)`](#fn-fieldconfigdefaultscustomlinestylewithdash) + * [`fn withDashMixin(value)`](#fn-fieldconfigdefaultscustomlinestylewithdashmixin) + * [`fn withFill(value)`](#fn-fieldconfigdefaultscustomlinestylewithfill) + * [`obj scaleDistribution`](#obj-fieldconfigdefaultscustomscaledistribution) + * [`fn withLinearThreshold(value)`](#fn-fieldconfigdefaultscustomscaledistributionwithlinearthreshold) + * [`fn withLog(value)`](#fn-fieldconfigdefaultscustomscaledistributionwithlog) + * [`fn withType(value)`](#fn-fieldconfigdefaultscustomscaledistributionwithtype) + * [`obj stacking`](#obj-fieldconfigdefaultscustomstacking) + * [`fn withGroup(value)`](#fn-fieldconfigdefaultscustomstackingwithgroup) + * [`fn withMode(value)`](#fn-fieldconfigdefaultscustomstackingwithmode) + * [`obj thresholdsStyle`](#obj-fieldconfigdefaultscustomthresholdsstyle) + * [`fn withMode(value)`](#fn-fieldconfigdefaultscustomthresholdsstylewithmode) +* [`obj libraryPanel`](#obj-librarypanel) + * [`fn withName(value)`](#fn-librarypanelwithname) + * [`fn withUid(value)`](#fn-librarypanelwithuid) +* [`obj options`](#obj-options) + * [`fn withLegend(value)`](#fn-optionswithlegend) + * [`fn withLegendMixin(value)`](#fn-optionswithlegendmixin) + * [`fn withTooltip(value)`](#fn-optionswithtooltip) + * [`fn withTooltipMixin(value)`](#fn-optionswithtooltipmixin) + * [`fn withXField(value)`](#fn-optionswithxfield) + * [`obj legend`](#obj-optionslegend) + * [`fn withAsTable(value=true)`](#fn-optionslegendwithastable) + * [`fn withCalcs(value)`](#fn-optionslegendwithcalcs) + * [`fn withCalcsMixin(value)`](#fn-optionslegendwithcalcsmixin) + * [`fn withDisplayMode(value)`](#fn-optionslegendwithdisplaymode) + * [`fn withIsVisible(value=true)`](#fn-optionslegendwithisvisible) + * [`fn withPlacement(value)`](#fn-optionslegendwithplacement) + * [`fn withShowLegend(value=true)`](#fn-optionslegendwithshowlegend) + * [`fn withSortBy(value)`](#fn-optionslegendwithsortby) + * [`fn withSortDesc(value=true)`](#fn-optionslegendwithsortdesc) + * [`fn withWidth(value)`](#fn-optionslegendwithwidth) + * [`obj tooltip`](#obj-optionstooltip) + * [`fn withMode(value)`](#fn-optionstooltipwithmode) + * [`fn withSort(value)`](#fn-optionstooltipwithsort) +* [`obj panelOptions`](#obj-paneloptions) + * [`fn withDescription(value)`](#fn-paneloptionswithdescription) + * [`fn withGridPos(h="null", w="null", x="null", y="null")`](#fn-paneloptionswithgridpos) + * [`fn withLinks(value)`](#fn-paneloptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-paneloptionswithlinksmixin) + * [`fn withRepeat(value)`](#fn-paneloptionswithrepeat) + * [`fn withRepeatDirection(value="h")`](#fn-paneloptionswithrepeatdirection) + * [`fn withTitle(value)`](#fn-paneloptionswithtitle) + * [`fn withTransparent(value=true)`](#fn-paneloptionswithtransparent) +* [`obj queryOptions`](#obj-queryoptions) + * [`fn withDatasource(type, uid)`](#fn-queryoptionswithdatasource) + * [`fn withDatasourceMixin(value)`](#fn-queryoptionswithdatasourcemixin) + * [`fn withInterval(value)`](#fn-queryoptionswithinterval) + * [`fn withMaxDataPoints(value)`](#fn-queryoptionswithmaxdatapoints) + * [`fn withTargets(value)`](#fn-queryoptionswithtargets) + * [`fn withTargetsMixin(value)`](#fn-queryoptionswithtargetsmixin) + * [`fn withTimeFrom(value)`](#fn-queryoptionswithtimefrom) + * [`fn withTimeShift(value)`](#fn-queryoptionswithtimeshift) + * [`fn withTransformations(value)`](#fn-queryoptionswithtransformations) + * [`fn withTransformationsMixin(value)`](#fn-queryoptionswithtransformationsmixin) +* [`obj standardOptions`](#obj-standardoptions) + * [`fn withDecimals(value)`](#fn-standardoptionswithdecimals) + * [`fn withDisplayName(value)`](#fn-standardoptionswithdisplayname) + * [`fn withFilterable(value=true)`](#fn-standardoptionswithfilterable) + * [`fn withLinks(value)`](#fn-standardoptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-standardoptionswithlinksmixin) + * [`fn withMappings(value)`](#fn-standardoptionswithmappings) + * [`fn withMappingsMixin(value)`](#fn-standardoptionswithmappingsmixin) + * [`fn withMax(value)`](#fn-standardoptionswithmax) + * [`fn withMin(value)`](#fn-standardoptionswithmin) + * [`fn withNoValue(value)`](#fn-standardoptionswithnovalue) + * [`fn withOverrides(value)`](#fn-standardoptionswithoverrides) + * [`fn withOverridesMixin(value)`](#fn-standardoptionswithoverridesmixin) + * [`fn withPath(value)`](#fn-standardoptionswithpath) + * [`fn withUnit(value)`](#fn-standardoptionswithunit) + * [`obj color`](#obj-standardoptionscolor) + * [`fn withFixedColor(value)`](#fn-standardoptionscolorwithfixedcolor) + * [`fn withMode(value)`](#fn-standardoptionscolorwithmode) + * [`fn withSeriesBy(value)`](#fn-standardoptionscolorwithseriesby) + * [`obj thresholds`](#obj-standardoptionsthresholds) + * [`fn withMode(value)`](#fn-standardoptionsthresholdswithmode) + * [`fn withSteps(value)`](#fn-standardoptionsthresholdswithsteps) + * [`fn withStepsMixin(value)`](#fn-standardoptionsthresholdswithstepsmixin) + +## Fields + +### fn new + +```jsonnet +new(title) +``` + +PARAMETERS: + +* **title** (`string`) + +Creates a new trend panel with a title. +### obj fieldConfig + + +#### obj fieldConfig.defaults + + +##### obj fieldConfig.defaults.custom + + +###### fn fieldConfig.defaults.custom.withAxisCenteredZero + +```jsonnet +fieldConfig.defaults.custom.withAxisCenteredZero(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +###### fn fieldConfig.defaults.custom.withAxisColorMode + +```jsonnet +fieldConfig.defaults.custom.withAxisColorMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"text"`, `"series"` + +TODO docs +###### fn fieldConfig.defaults.custom.withAxisGridShow + +```jsonnet +fieldConfig.defaults.custom.withAxisGridShow(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +###### fn fieldConfig.defaults.custom.withAxisLabel + +```jsonnet +fieldConfig.defaults.custom.withAxisLabel(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn fieldConfig.defaults.custom.withAxisPlacement + +```jsonnet +fieldConfig.defaults.custom.withAxisPlacement(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"auto"`, `"top"`, `"right"`, `"bottom"`, `"left"`, `"hidden"` + +TODO docs +###### fn fieldConfig.defaults.custom.withAxisSoftMax + +```jsonnet +fieldConfig.defaults.custom.withAxisSoftMax(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +###### fn fieldConfig.defaults.custom.withAxisSoftMin + +```jsonnet +fieldConfig.defaults.custom.withAxisSoftMin(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +###### fn fieldConfig.defaults.custom.withAxisWidth + +```jsonnet +fieldConfig.defaults.custom.withAxisWidth(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +###### fn fieldConfig.defaults.custom.withBarAlignment + +```jsonnet +fieldConfig.defaults.custom.withBarAlignment(value) +``` + +PARAMETERS: + +* **value** (`integer`) + - valid values: `-1`, `0`, `1` + +TODO docs +###### fn fieldConfig.defaults.custom.withBarMaxWidth + +```jsonnet +fieldConfig.defaults.custom.withBarMaxWidth(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +###### fn fieldConfig.defaults.custom.withBarWidthFactor + +```jsonnet +fieldConfig.defaults.custom.withBarWidthFactor(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +###### fn fieldConfig.defaults.custom.withDrawStyle + +```jsonnet +fieldConfig.defaults.custom.withDrawStyle(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"line"`, `"bars"`, `"points"` + +TODO docs +###### fn fieldConfig.defaults.custom.withFillBelowTo + +```jsonnet +fieldConfig.defaults.custom.withFillBelowTo(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn fieldConfig.defaults.custom.withFillColor + +```jsonnet +fieldConfig.defaults.custom.withFillColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn fieldConfig.defaults.custom.withFillOpacity + +```jsonnet +fieldConfig.defaults.custom.withFillOpacity(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +###### fn fieldConfig.defaults.custom.withGradientMode + +```jsonnet +fieldConfig.defaults.custom.withGradientMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"none"`, `"opacity"`, `"hue"`, `"scheme"` + +TODO docs +###### fn fieldConfig.defaults.custom.withHideFrom + +```jsonnet +fieldConfig.defaults.custom.withHideFrom(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn fieldConfig.defaults.custom.withHideFromMixin + +```jsonnet +fieldConfig.defaults.custom.withHideFromMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn fieldConfig.defaults.custom.withLineColor + +```jsonnet +fieldConfig.defaults.custom.withLineColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn fieldConfig.defaults.custom.withLineInterpolation + +```jsonnet +fieldConfig.defaults.custom.withLineInterpolation(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"linear"`, `"smooth"`, `"stepBefore"`, `"stepAfter"` + +TODO docs +###### fn fieldConfig.defaults.custom.withLineStyle + +```jsonnet +fieldConfig.defaults.custom.withLineStyle(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn fieldConfig.defaults.custom.withLineStyleMixin + +```jsonnet +fieldConfig.defaults.custom.withLineStyleMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn fieldConfig.defaults.custom.withLineWidth + +```jsonnet +fieldConfig.defaults.custom.withLineWidth(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +###### fn fieldConfig.defaults.custom.withPointColor + +```jsonnet +fieldConfig.defaults.custom.withPointColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn fieldConfig.defaults.custom.withPointSize + +```jsonnet +fieldConfig.defaults.custom.withPointSize(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +###### fn fieldConfig.defaults.custom.withPointSymbol + +```jsonnet +fieldConfig.defaults.custom.withPointSymbol(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn fieldConfig.defaults.custom.withScaleDistribution + +```jsonnet +fieldConfig.defaults.custom.withScaleDistribution(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn fieldConfig.defaults.custom.withScaleDistributionMixin + +```jsonnet +fieldConfig.defaults.custom.withScaleDistributionMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn fieldConfig.defaults.custom.withShowPoints + +```jsonnet +fieldConfig.defaults.custom.withShowPoints(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"auto"`, `"never"`, `"always"` + +TODO docs +###### fn fieldConfig.defaults.custom.withSpanNulls + +```jsonnet +fieldConfig.defaults.custom.withSpanNulls(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Indicate if null values should be treated as gaps or connected. +When the value is a number, it represents the maximum delta in the +X axis that should be considered connected. For timeseries, this is milliseconds +###### fn fieldConfig.defaults.custom.withSpanNullsMixin + +```jsonnet +fieldConfig.defaults.custom.withSpanNullsMixin(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Indicate if null values should be treated as gaps or connected. +When the value is a number, it represents the maximum delta in the +X axis that should be considered connected. For timeseries, this is milliseconds +###### fn fieldConfig.defaults.custom.withStacking + +```jsonnet +fieldConfig.defaults.custom.withStacking(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn fieldConfig.defaults.custom.withStackingMixin + +```jsonnet +fieldConfig.defaults.custom.withStackingMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn fieldConfig.defaults.custom.withThresholdsStyle + +```jsonnet +fieldConfig.defaults.custom.withThresholdsStyle(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn fieldConfig.defaults.custom.withThresholdsStyleMixin + +```jsonnet +fieldConfig.defaults.custom.withThresholdsStyleMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +###### fn fieldConfig.defaults.custom.withTransform + +```jsonnet +fieldConfig.defaults.custom.withTransform(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"constant"`, `"negative-Y"` + +TODO docs +###### obj fieldConfig.defaults.custom.hideFrom + + +####### fn fieldConfig.defaults.custom.hideFrom.withLegend + +```jsonnet +fieldConfig.defaults.custom.hideFrom.withLegend(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +####### fn fieldConfig.defaults.custom.hideFrom.withTooltip + +```jsonnet +fieldConfig.defaults.custom.hideFrom.withTooltip(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +####### fn fieldConfig.defaults.custom.hideFrom.withViz + +```jsonnet +fieldConfig.defaults.custom.hideFrom.withViz(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +###### obj fieldConfig.defaults.custom.lineStyle + + +####### fn fieldConfig.defaults.custom.lineStyle.withDash + +```jsonnet +fieldConfig.defaults.custom.lineStyle.withDash(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +####### fn fieldConfig.defaults.custom.lineStyle.withDashMixin + +```jsonnet +fieldConfig.defaults.custom.lineStyle.withDashMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +####### fn fieldConfig.defaults.custom.lineStyle.withFill + +```jsonnet +fieldConfig.defaults.custom.lineStyle.withFill(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"solid"`, `"dash"`, `"dot"`, `"square"` + + +###### obj fieldConfig.defaults.custom.scaleDistribution + + +####### fn fieldConfig.defaults.custom.scaleDistribution.withLinearThreshold + +```jsonnet +fieldConfig.defaults.custom.scaleDistribution.withLinearThreshold(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +####### fn fieldConfig.defaults.custom.scaleDistribution.withLog + +```jsonnet +fieldConfig.defaults.custom.scaleDistribution.withLog(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +####### fn fieldConfig.defaults.custom.scaleDistribution.withType + +```jsonnet +fieldConfig.defaults.custom.scaleDistribution.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"linear"`, `"log"`, `"ordinal"`, `"symlog"` + +TODO docs +###### obj fieldConfig.defaults.custom.stacking + + +####### fn fieldConfig.defaults.custom.stacking.withGroup + +```jsonnet +fieldConfig.defaults.custom.stacking.withGroup(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +####### fn fieldConfig.defaults.custom.stacking.withMode + +```jsonnet +fieldConfig.defaults.custom.stacking.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"none"`, `"normal"`, `"percent"` + +TODO docs +###### obj fieldConfig.defaults.custom.thresholdsStyle + + +####### fn fieldConfig.defaults.custom.thresholdsStyle.withMode + +```jsonnet +fieldConfig.defaults.custom.thresholdsStyle.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"off"`, `"line"`, `"dashed"`, `"area"`, `"line+area"`, `"dashed+area"`, `"series"` + +TODO docs +### obj libraryPanel + + +#### fn libraryPanel.withName + +```jsonnet +libraryPanel.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn libraryPanel.withUid + +```jsonnet +libraryPanel.withUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj options + + +#### fn options.withLegend + +```jsonnet +options.withLegend(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withLegendMixin + +```jsonnet +options.withLegendMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withTooltip + +```jsonnet +options.withTooltip(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withTooltipMixin + +```jsonnet +options.withTooltipMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withXField + +```jsonnet +options.withXField(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of the x field to use (defaults to first number) +#### obj options.legend + + +##### fn options.legend.withAsTable + +```jsonnet +options.legend.withAsTable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.legend.withCalcs + +```jsonnet +options.legend.withCalcs(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +##### fn options.legend.withCalcsMixin + +```jsonnet +options.legend.withCalcsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +##### fn options.legend.withDisplayMode + +```jsonnet +options.legend.withDisplayMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"list"`, `"table"`, `"hidden"` + +TODO docs +Note: "hidden" needs to remain as an option for plugins compatibility +##### fn options.legend.withIsVisible + +```jsonnet +options.legend.withIsVisible(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.legend.withPlacement + +```jsonnet +options.legend.withPlacement(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"bottom"`, `"right"` + +TODO docs +##### fn options.legend.withShowLegend + +```jsonnet +options.legend.withShowLegend(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.legend.withSortBy + +```jsonnet +options.legend.withSortBy(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn options.legend.withSortDesc + +```jsonnet +options.legend.withSortDesc(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.legend.withWidth + +```jsonnet +options.legend.withWidth(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### obj options.tooltip + + +##### fn options.tooltip.withMode + +```jsonnet +options.tooltip.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"single"`, `"multi"`, `"none"` + +TODO docs +##### fn options.tooltip.withSort + +```jsonnet +options.tooltip.withSort(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"asc"`, `"desc"`, `"none"` + +TODO docs +### obj panelOptions + + +#### fn panelOptions.withDescription + +```jsonnet +panelOptions.withDescription(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Description. +#### fn panelOptions.withGridPos + +```jsonnet +panelOptions.withGridPos(h="null", w="null", x="null", y="null") +``` + +PARAMETERS: + +* **h** (`number`) + - default value: `"null"` +* **w** (`number`) + - default value: `"null"` +* **x** (`number`) + - default value: `"null"` +* **y** (`number`) + - default value: `"null"` + +`withGridPos` configures the height, width and xy coordinates of the panel. Also see `grafonnet.util.grid` for helper functions to calculate these fields. + +All arguments default to `null`, which means they will remain unchanged or unset. + +#### fn panelOptions.withLinks + +```jsonnet +panelOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withLinksMixin + +```jsonnet +panelOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withRepeat + +```jsonnet +panelOptions.withRepeat(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of template variable to repeat for. +#### fn panelOptions.withRepeatDirection + +```jsonnet +panelOptions.withRepeatDirection(value="h") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"h"` + - valid values: `"h"`, `"v"` + +Direction to repeat in if 'repeat' is set. +"h" for horizontal, "v" for vertical. +TODO this is probably optional +#### fn panelOptions.withTitle + +```jsonnet +panelOptions.withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Panel title. +#### fn panelOptions.withTransparent + +```jsonnet +panelOptions.withTransparent(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Whether to display the panel without a background. +### obj queryOptions + + +#### fn queryOptions.withDatasource + +```jsonnet +queryOptions.withDatasource(type, uid) +``` + +PARAMETERS: + +* **type** (`string`) +* **uid** (`string`) + +`withDatasource` sets the datasource for all queries in a panel. + +The default datasource for a panel is set to 'Mixed datasource' so panels can be datasource agnostic, which is a lot more interesting from a reusability standpoint. Note that this requires query targets to explicitly set datasource for the same reason. + +#### fn queryOptions.withDatasourceMixin + +```jsonnet +queryOptions.withDatasourceMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +The datasource used in all targets. +#### fn queryOptions.withInterval + +```jsonnet +queryOptions.withInterval(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withMaxDataPoints + +```jsonnet +queryOptions.withMaxDataPoints(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +#### fn queryOptions.withTargets + +```jsonnet +queryOptions.withTargets(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTargetsMixin + +```jsonnet +queryOptions.withTargetsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTimeFrom + +```jsonnet +queryOptions.withTimeFrom(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTimeShift + +```jsonnet +queryOptions.withTimeShift(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTransformations + +```jsonnet +queryOptions.withTransformations(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn queryOptions.withTransformationsMixin + +```jsonnet +queryOptions.withTransformationsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### obj standardOptions + + +#### fn standardOptions.withDecimals + +```jsonnet +standardOptions.withDecimals(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Significant digits (for display) +#### fn standardOptions.withDisplayName + +```jsonnet +standardOptions.withDisplayName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The display value for this field. This supports template variables blank is auto +#### fn standardOptions.withFilterable + +```jsonnet +standardOptions.withFilterable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +True if data source field supports ad-hoc filters +#### fn standardOptions.withLinks + +```jsonnet +standardOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withLinksMixin + +```jsonnet +standardOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withMappings + +```jsonnet +standardOptions.withMappings(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMappingsMixin + +```jsonnet +standardOptions.withMappingsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMax + +```jsonnet +standardOptions.withMax(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withMin + +```jsonnet +standardOptions.withMin(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withNoValue + +```jsonnet +standardOptions.withNoValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Alternative to empty string +#### fn standardOptions.withOverrides + +```jsonnet +standardOptions.withOverrides(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withOverridesMixin + +```jsonnet +standardOptions.withOverridesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withPath + +```jsonnet +standardOptions.withPath(value) +``` + +PARAMETERS: + +* **value** (`string`) + +An explicit path to the field in the datasource. When the frame meta includes a path, +This will default to `${frame.meta.path}/${field.name} + +When defined, this value can be used as an identifier within the datasource scope, and +may be used to update the results +#### fn standardOptions.withUnit + +```jsonnet +standardOptions.withUnit(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Numeric Options +#### obj standardOptions.color + + +##### fn standardOptions.color.withFixedColor + +```jsonnet +standardOptions.color.withFixedColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Stores the fixed color value if mode is fixed +##### fn standardOptions.color.withMode + +```jsonnet +standardOptions.color.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The main color scheme mode +##### fn standardOptions.color.withSeriesBy + +```jsonnet +standardOptions.color.withSeriesBy(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"min"`, `"max"`, `"last"` + +TODO docs +#### obj standardOptions.thresholds + + +##### fn standardOptions.thresholds.withMode + +```jsonnet +standardOptions.thresholds.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"absolute"`, `"percentage"` + + +##### fn standardOptions.thresholds.withSteps + +```jsonnet +standardOptions.thresholds.withSteps(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity +##### fn standardOptions.thresholds.withStepsMixin + +```jsonnet +standardOptions.thresholds.withStepsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/trend/panelOptions/link.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/trend/panelOptions/link.md new file mode 100644 index 0000000000..106f9d2edb --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/trend/panelOptions/link.md @@ -0,0 +1,145 @@ +# link + + + +## Index + +* [`fn withAsDropdown(value=true)`](#fn-withasdropdown) +* [`fn withIcon(value)`](#fn-withicon) +* [`fn withIncludeVars(value=true)`](#fn-withincludevars) +* [`fn withKeepTime(value=true)`](#fn-withkeeptime) +* [`fn withTags(value)`](#fn-withtags) +* [`fn withTagsMixin(value)`](#fn-withtagsmixin) +* [`fn withTargetBlank(value=true)`](#fn-withtargetblank) +* [`fn withTitle(value)`](#fn-withtitle) +* [`fn withTooltip(value)`](#fn-withtooltip) +* [`fn withType(value)`](#fn-withtype) +* [`fn withUrl(value)`](#fn-withurl) + +## Fields + +### fn withAsDropdown + +```jsonnet +withAsDropdown(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withIcon + +```jsonnet +withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withIncludeVars + +```jsonnet +withIncludeVars(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withKeepTime + +```jsonnet +withKeepTime(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTags + +```jsonnet +withTags(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTagsMixin + +```jsonnet +withTagsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTargetBlank + +```jsonnet +withTargetBlank(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTitle + +```jsonnet +withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withTooltip + +```jsonnet +withTooltip(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withType + +```jsonnet +withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"link"`, `"dashboards"` + +TODO docs +### fn withUrl + +```jsonnet +withUrl(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/trend/queryOptions/transformation.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/trend/queryOptions/transformation.md new file mode 100644 index 0000000000..dc832f653d --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/trend/queryOptions/transformation.md @@ -0,0 +1,99 @@ +# transformation + + + +## Index + +* [`fn withDisabled(value=true)`](#fn-withdisabled) +* [`fn withFilter(value)`](#fn-withfilter) +* [`fn withFilterMixin(value)`](#fn-withfiltermixin) +* [`fn withId(value)`](#fn-withid) +* [`fn withOptions(value)`](#fn-withoptions) +* [`obj filter`](#obj-filter) + * [`fn withId(value="")`](#fn-filterwithid) + * [`fn withOptions(value)`](#fn-filterwithoptions) + +## Fields + +### fn withDisabled + +```jsonnet +withDisabled(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Disabled transformations are skipped +### fn withFilter + +```jsonnet +withFilter(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withFilterMixin + +```jsonnet +withFilterMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withId + +```jsonnet +withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Unique identifier of transformer +### fn withOptions + +```jsonnet +withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Options to be passed to the transformer +Valid options depend on the transformer id +### obj filter + + +#### fn filter.withId + +```jsonnet +filter.withId(value="") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `""` + + +#### fn filter.withOptions + +```jsonnet +filter.withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/trend/standardOptions/mapping.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/trend/standardOptions/mapping.md new file mode 100644 index 0000000000..93296972e8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/trend/standardOptions/mapping.md @@ -0,0 +1,469 @@ +# mapping + + + +## Index + +* [`obj RangeMap`](#obj-rangemap) + * [`fn withOptions(value)`](#fn-rangemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-rangemapwithoptionsmixin) + * [`fn withType(value)`](#fn-rangemapwithtype) + * [`obj options`](#obj-rangemapoptions) + * [`fn withFrom(value)`](#fn-rangemapoptionswithfrom) + * [`fn withResult(value)`](#fn-rangemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-rangemapoptionswithresultmixin) + * [`fn withTo(value)`](#fn-rangemapoptionswithto) + * [`obj result`](#obj-rangemapoptionsresult) + * [`fn withColor(value)`](#fn-rangemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-rangemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-rangemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-rangemapoptionsresultwithtext) +* [`obj RegexMap`](#obj-regexmap) + * [`fn withOptions(value)`](#fn-regexmapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-regexmapwithoptionsmixin) + * [`fn withType(value)`](#fn-regexmapwithtype) + * [`obj options`](#obj-regexmapoptions) + * [`fn withPattern(value)`](#fn-regexmapoptionswithpattern) + * [`fn withResult(value)`](#fn-regexmapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-regexmapoptionswithresultmixin) + * [`obj result`](#obj-regexmapoptionsresult) + * [`fn withColor(value)`](#fn-regexmapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-regexmapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-regexmapoptionsresultwithindex) + * [`fn withText(value)`](#fn-regexmapoptionsresultwithtext) +* [`obj SpecialValueMap`](#obj-specialvaluemap) + * [`fn withOptions(value)`](#fn-specialvaluemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-specialvaluemapwithoptionsmixin) + * [`fn withType(value)`](#fn-specialvaluemapwithtype) + * [`obj options`](#obj-specialvaluemapoptions) + * [`fn withMatch(value)`](#fn-specialvaluemapoptionswithmatch) + * [`fn withPattern(value)`](#fn-specialvaluemapoptionswithpattern) + * [`fn withResult(value)`](#fn-specialvaluemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-specialvaluemapoptionswithresultmixin) + * [`obj result`](#obj-specialvaluemapoptionsresult) + * [`fn withColor(value)`](#fn-specialvaluemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-specialvaluemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-specialvaluemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-specialvaluemapoptionsresultwithtext) +* [`obj ValueMap`](#obj-valuemap) + * [`fn withOptions(value)`](#fn-valuemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-valuemapwithoptionsmixin) + * [`fn withType(value)`](#fn-valuemapwithtype) + +## Fields + +### obj RangeMap + + +#### fn RangeMap.withOptions + +```jsonnet +RangeMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withOptionsMixin + +```jsonnet +RangeMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withType + +```jsonnet +RangeMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RangeMap.options + + +##### fn RangeMap.options.withFrom + +```jsonnet +RangeMap.options.withFrom(value) +``` + +PARAMETERS: + +* **value** (`number`) + +to and from are `number | null` in current ts, really not sure what to do +##### fn RangeMap.options.withResult + +```jsonnet +RangeMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withResultMixin + +```jsonnet +RangeMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withTo + +```jsonnet +RangeMap.options.withTo(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +##### obj RangeMap.options.result + + +###### fn RangeMap.options.result.withColor + +```jsonnet +RangeMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIcon + +```jsonnet +RangeMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIndex + +```jsonnet +RangeMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RangeMap.options.result.withText + +```jsonnet +RangeMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj RegexMap + + +#### fn RegexMap.withOptions + +```jsonnet +RegexMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withOptionsMixin + +```jsonnet +RegexMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withType + +```jsonnet +RegexMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RegexMap.options + + +##### fn RegexMap.options.withPattern + +```jsonnet +RegexMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn RegexMap.options.withResult + +```jsonnet +RegexMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RegexMap.options.withResultMixin + +```jsonnet +RegexMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj RegexMap.options.result + + +###### fn RegexMap.options.result.withColor + +```jsonnet +RegexMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIcon + +```jsonnet +RegexMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIndex + +```jsonnet +RegexMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RegexMap.options.result.withText + +```jsonnet +RegexMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj SpecialValueMap + + +#### fn SpecialValueMap.withOptions + +```jsonnet +SpecialValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withOptionsMixin + +```jsonnet +SpecialValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withType + +```jsonnet +SpecialValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj SpecialValueMap.options + + +##### fn SpecialValueMap.options.withMatch + +```jsonnet +SpecialValueMap.options.withMatch(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"true"`, `"false"` + + +##### fn SpecialValueMap.options.withPattern + +```jsonnet +SpecialValueMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn SpecialValueMap.options.withResult + +```jsonnet +SpecialValueMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn SpecialValueMap.options.withResultMixin + +```jsonnet +SpecialValueMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj SpecialValueMap.options.result + + +###### fn SpecialValueMap.options.result.withColor + +```jsonnet +SpecialValueMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIcon + +```jsonnet +SpecialValueMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIndex + +```jsonnet +SpecialValueMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn SpecialValueMap.options.result.withText + +```jsonnet +SpecialValueMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj ValueMap + + +#### fn ValueMap.withOptions + +```jsonnet +ValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withOptionsMixin + +```jsonnet +ValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withType + +```jsonnet +ValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/trend/standardOptions/override.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/trend/standardOptions/override.md new file mode 100644 index 0000000000..154f3dbdac --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/trend/standardOptions/override.md @@ -0,0 +1,244 @@ +# override + +Overrides allow you to customize visualization settings for specific fields or +series. This is accomplished by adding an override rule that targets +a particular set of fields and that can each define multiple options. + +```jsonnet +override.byType.new('number') ++ override.byType.withPropertiesFromOptions( + panel.standardOptions.withDecimals(2) + + panel.standardOptions.withUnit('s') +) +``` + + +## Index + +* [`obj byName`](#obj-byname) + * [`fn new(value)`](#fn-bynamenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bynamewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bynamewithproperty) +* [`obj byQuery`](#obj-byquery) + * [`fn new(value)`](#fn-byquerynew) + * [`fn withPropertiesFromOptions(options)`](#fn-byquerywithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byquerywithproperty) +* [`obj byRegexp`](#obj-byregexp) + * [`fn new(value)`](#fn-byregexpnew) + * [`fn withPropertiesFromOptions(options)`](#fn-byregexpwithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byregexpwithproperty) +* [`obj byType`](#obj-bytype) + * [`fn new(value)`](#fn-bytypenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bytypewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bytypewithproperty) +* [`obj byValue`](#obj-byvalue) + * [`fn new(value)`](#fn-byvaluenew) + * [`fn withPropertiesFromOptions(options)`](#fn-byvaluewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byvaluewithproperty) + +## Fields + +### obj byName + + +#### fn byName.new + +```jsonnet +byName.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byName`. +#### fn byName.withPropertiesFromOptions + +```jsonnet +byName.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byName.withProperty + +```jsonnet +byName.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byQuery + + +#### fn byQuery.new + +```jsonnet +byQuery.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byQuery`. +#### fn byQuery.withPropertiesFromOptions + +```jsonnet +byQuery.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byQuery.withProperty + +```jsonnet +byQuery.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byRegexp + + +#### fn byRegexp.new + +```jsonnet +byRegexp.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byRegexp`. +#### fn byRegexp.withPropertiesFromOptions + +```jsonnet +byRegexp.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byRegexp.withProperty + +```jsonnet +byRegexp.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byType + + +#### fn byType.new + +```jsonnet +byType.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byType`. +#### fn byType.withPropertiesFromOptions + +```jsonnet +byType.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byType.withProperty + +```jsonnet +byType.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byValue + + +#### fn byValue.new + +```jsonnet +byValue.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byValue`. +#### fn byValue.withPropertiesFromOptions + +```jsonnet +byValue.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byValue.withProperty + +```jsonnet +byValue.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/trend/standardOptions/threshold/step.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/trend/standardOptions/threshold/step.md new file mode 100644 index 0000000000..dd2dd227ff --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/trend/standardOptions/threshold/step.md @@ -0,0 +1,60 @@ +# threshold.step + + + +## Index + +* [`fn withColor(value)`](#fn-withcolor) +* [`fn withIndex(value)`](#fn-withindex) +* [`fn withState(value)`](#fn-withstate) +* [`fn withValue(value)`](#fn-withvalue) + +## Fields + +### fn withColor + +```jsonnet +withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +### fn withIndex + +```jsonnet +withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Threshold index, an old property that is not needed an should only appear in older dashboards +### fn withState + +```jsonnet +withState(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO are the values here enumerable into a disjunction? +Some seem to be listed in typescript comment +### fn withValue + +```jsonnet +withValue(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +FIXME the corresponding typescript field is required/non-optional, but nulls currently appear here when serializing -Infinity to JSON \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/xyChart/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/xyChart/index.md new file mode 100644 index 0000000000..9f89ebce5b --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/xyChart/index.md @@ -0,0 +1,891 @@ +# xyChart + +grafonnet.panel.xyChart + +## Subpackages + +* [options.series](options/series.md) +* [panelOptions.link](panelOptions/link.md) +* [queryOptions.transformation](queryOptions/transformation.md) +* [standardOptions.mapping](standardOptions/mapping.md) +* [standardOptions.override](standardOptions/override.md) +* [standardOptions.threshold.step](standardOptions/threshold/step.md) + +## Index + +* [`fn new(title)`](#fn-new) +* [`obj libraryPanel`](#obj-librarypanel) + * [`fn withName(value)`](#fn-librarypanelwithname) + * [`fn withUid(value)`](#fn-librarypanelwithuid) +* [`obj options`](#obj-options) + * [`fn withDims(value)`](#fn-optionswithdims) + * [`fn withDimsMixin(value)`](#fn-optionswithdimsmixin) + * [`fn withLegend(value)`](#fn-optionswithlegend) + * [`fn withLegendMixin(value)`](#fn-optionswithlegendmixin) + * [`fn withSeries(value)`](#fn-optionswithseries) + * [`fn withSeriesMapping(value)`](#fn-optionswithseriesmapping) + * [`fn withSeriesMixin(value)`](#fn-optionswithseriesmixin) + * [`fn withTooltip(value)`](#fn-optionswithtooltip) + * [`fn withTooltipMixin(value)`](#fn-optionswithtooltipmixin) + * [`obj dims`](#obj-optionsdims) + * [`fn withExclude(value)`](#fn-optionsdimswithexclude) + * [`fn withExcludeMixin(value)`](#fn-optionsdimswithexcludemixin) + * [`fn withFrame(value)`](#fn-optionsdimswithframe) + * [`fn withX(value)`](#fn-optionsdimswithx) + * [`obj legend`](#obj-optionslegend) + * [`fn withAsTable(value=true)`](#fn-optionslegendwithastable) + * [`fn withCalcs(value)`](#fn-optionslegendwithcalcs) + * [`fn withCalcsMixin(value)`](#fn-optionslegendwithcalcsmixin) + * [`fn withDisplayMode(value)`](#fn-optionslegendwithdisplaymode) + * [`fn withIsVisible(value=true)`](#fn-optionslegendwithisvisible) + * [`fn withPlacement(value)`](#fn-optionslegendwithplacement) + * [`fn withShowLegend(value=true)`](#fn-optionslegendwithshowlegend) + * [`fn withSortBy(value)`](#fn-optionslegendwithsortby) + * [`fn withSortDesc(value=true)`](#fn-optionslegendwithsortdesc) + * [`fn withWidth(value)`](#fn-optionslegendwithwidth) + * [`obj tooltip`](#obj-optionstooltip) + * [`fn withMode(value)`](#fn-optionstooltipwithmode) + * [`fn withSort(value)`](#fn-optionstooltipwithsort) +* [`obj panelOptions`](#obj-paneloptions) + * [`fn withDescription(value)`](#fn-paneloptionswithdescription) + * [`fn withGridPos(h="null", w="null", x="null", y="null")`](#fn-paneloptionswithgridpos) + * [`fn withLinks(value)`](#fn-paneloptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-paneloptionswithlinksmixin) + * [`fn withRepeat(value)`](#fn-paneloptionswithrepeat) + * [`fn withRepeatDirection(value="h")`](#fn-paneloptionswithrepeatdirection) + * [`fn withTitle(value)`](#fn-paneloptionswithtitle) + * [`fn withTransparent(value=true)`](#fn-paneloptionswithtransparent) +* [`obj queryOptions`](#obj-queryoptions) + * [`fn withDatasource(type, uid)`](#fn-queryoptionswithdatasource) + * [`fn withDatasourceMixin(value)`](#fn-queryoptionswithdatasourcemixin) + * [`fn withInterval(value)`](#fn-queryoptionswithinterval) + * [`fn withMaxDataPoints(value)`](#fn-queryoptionswithmaxdatapoints) + * [`fn withTargets(value)`](#fn-queryoptionswithtargets) + * [`fn withTargetsMixin(value)`](#fn-queryoptionswithtargetsmixin) + * [`fn withTimeFrom(value)`](#fn-queryoptionswithtimefrom) + * [`fn withTimeShift(value)`](#fn-queryoptionswithtimeshift) + * [`fn withTransformations(value)`](#fn-queryoptionswithtransformations) + * [`fn withTransformationsMixin(value)`](#fn-queryoptionswithtransformationsmixin) +* [`obj standardOptions`](#obj-standardoptions) + * [`fn withDecimals(value)`](#fn-standardoptionswithdecimals) + * [`fn withDisplayName(value)`](#fn-standardoptionswithdisplayname) + * [`fn withFilterable(value=true)`](#fn-standardoptionswithfilterable) + * [`fn withLinks(value)`](#fn-standardoptionswithlinks) + * [`fn withLinksMixin(value)`](#fn-standardoptionswithlinksmixin) + * [`fn withMappings(value)`](#fn-standardoptionswithmappings) + * [`fn withMappingsMixin(value)`](#fn-standardoptionswithmappingsmixin) + * [`fn withMax(value)`](#fn-standardoptionswithmax) + * [`fn withMin(value)`](#fn-standardoptionswithmin) + * [`fn withNoValue(value)`](#fn-standardoptionswithnovalue) + * [`fn withOverrides(value)`](#fn-standardoptionswithoverrides) + * [`fn withOverridesMixin(value)`](#fn-standardoptionswithoverridesmixin) + * [`fn withPath(value)`](#fn-standardoptionswithpath) + * [`fn withUnit(value)`](#fn-standardoptionswithunit) + * [`obj color`](#obj-standardoptionscolor) + * [`fn withFixedColor(value)`](#fn-standardoptionscolorwithfixedcolor) + * [`fn withMode(value)`](#fn-standardoptionscolorwithmode) + * [`fn withSeriesBy(value)`](#fn-standardoptionscolorwithseriesby) + * [`obj thresholds`](#obj-standardoptionsthresholds) + * [`fn withMode(value)`](#fn-standardoptionsthresholdswithmode) + * [`fn withSteps(value)`](#fn-standardoptionsthresholdswithsteps) + * [`fn withStepsMixin(value)`](#fn-standardoptionsthresholdswithstepsmixin) + +## Fields + +### fn new + +```jsonnet +new(title) +``` + +PARAMETERS: + +* **title** (`string`) + +Creates a new xyChart panel with a title. +### obj libraryPanel + + +#### fn libraryPanel.withName + +```jsonnet +libraryPanel.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn libraryPanel.withUid + +```jsonnet +libraryPanel.withUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj options + + +#### fn options.withDims + +```jsonnet +options.withDims(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn options.withDimsMixin + +```jsonnet +options.withDimsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn options.withLegend + +```jsonnet +options.withLegend(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withLegendMixin + +```jsonnet +options.withLegendMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withSeries + +```jsonnet +options.withSeries(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn options.withSeriesMapping + +```jsonnet +options.withSeriesMapping(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"auto"`, `"manual"` + + +#### fn options.withSeriesMixin + +```jsonnet +options.withSeriesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn options.withTooltip + +```jsonnet +options.withTooltip(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### fn options.withTooltipMixin + +```jsonnet +options.withTooltipMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +#### obj options.dims + + +##### fn options.dims.withExclude + +```jsonnet +options.dims.withExclude(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +##### fn options.dims.withExcludeMixin + +```jsonnet +options.dims.withExcludeMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +##### fn options.dims.withFrame + +```jsonnet +options.dims.withFrame(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +##### fn options.dims.withX + +```jsonnet +options.dims.withX(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj options.legend + + +##### fn options.legend.withAsTable + +```jsonnet +options.legend.withAsTable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.legend.withCalcs + +```jsonnet +options.legend.withCalcs(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +##### fn options.legend.withCalcsMixin + +```jsonnet +options.legend.withCalcsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +##### fn options.legend.withDisplayMode + +```jsonnet +options.legend.withDisplayMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"list"`, `"table"`, `"hidden"` + +TODO docs +Note: "hidden" needs to remain as an option for plugins compatibility +##### fn options.legend.withIsVisible + +```jsonnet +options.legend.withIsVisible(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.legend.withPlacement + +```jsonnet +options.legend.withPlacement(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"bottom"`, `"right"` + +TODO docs +##### fn options.legend.withShowLegend + +```jsonnet +options.legend.withShowLegend(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.legend.withSortBy + +```jsonnet +options.legend.withSortBy(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn options.legend.withSortDesc + +```jsonnet +options.legend.withSortDesc(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn options.legend.withWidth + +```jsonnet +options.legend.withWidth(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### obj options.tooltip + + +##### fn options.tooltip.withMode + +```jsonnet +options.tooltip.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"single"`, `"multi"`, `"none"` + +TODO docs +##### fn options.tooltip.withSort + +```jsonnet +options.tooltip.withSort(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"asc"`, `"desc"`, `"none"` + +TODO docs +### obj panelOptions + + +#### fn panelOptions.withDescription + +```jsonnet +panelOptions.withDescription(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Description. +#### fn panelOptions.withGridPos + +```jsonnet +panelOptions.withGridPos(h="null", w="null", x="null", y="null") +``` + +PARAMETERS: + +* **h** (`number`) + - default value: `"null"` +* **w** (`number`) + - default value: `"null"` +* **x** (`number`) + - default value: `"null"` +* **y** (`number`) + - default value: `"null"` + +`withGridPos` configures the height, width and xy coordinates of the panel. Also see `grafonnet.util.grid` for helper functions to calculate these fields. + +All arguments default to `null`, which means they will remain unchanged or unset. + +#### fn panelOptions.withLinks + +```jsonnet +panelOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withLinksMixin + +```jsonnet +panelOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Panel links. +TODO fill this out - seems there are a couple variants? +#### fn panelOptions.withRepeat + +```jsonnet +panelOptions.withRepeat(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of template variable to repeat for. +#### fn panelOptions.withRepeatDirection + +```jsonnet +panelOptions.withRepeatDirection(value="h") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"h"` + - valid values: `"h"`, `"v"` + +Direction to repeat in if 'repeat' is set. +"h" for horizontal, "v" for vertical. +TODO this is probably optional +#### fn panelOptions.withTitle + +```jsonnet +panelOptions.withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Panel title. +#### fn panelOptions.withTransparent + +```jsonnet +panelOptions.withTransparent(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Whether to display the panel without a background. +### obj queryOptions + + +#### fn queryOptions.withDatasource + +```jsonnet +queryOptions.withDatasource(type, uid) +``` + +PARAMETERS: + +* **type** (`string`) +* **uid** (`string`) + +`withDatasource` sets the datasource for all queries in a panel. + +The default datasource for a panel is set to 'Mixed datasource' so panels can be datasource agnostic, which is a lot more interesting from a reusability standpoint. Note that this requires query targets to explicitly set datasource for the same reason. + +#### fn queryOptions.withDatasourceMixin + +```jsonnet +queryOptions.withDatasourceMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +The datasource used in all targets. +#### fn queryOptions.withInterval + +```jsonnet +queryOptions.withInterval(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withMaxDataPoints + +```jsonnet +queryOptions.withMaxDataPoints(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +#### fn queryOptions.withTargets + +```jsonnet +queryOptions.withTargets(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTargetsMixin + +```jsonnet +queryOptions.withTargetsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +TODO docs +#### fn queryOptions.withTimeFrom + +```jsonnet +queryOptions.withTimeFrom(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTimeShift + +```jsonnet +queryOptions.withTimeShift(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO tighter constraint +#### fn queryOptions.withTransformations + +```jsonnet +queryOptions.withTransformations(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn queryOptions.withTransformationsMixin + +```jsonnet +queryOptions.withTransformationsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### obj standardOptions + + +#### fn standardOptions.withDecimals + +```jsonnet +standardOptions.withDecimals(value) +``` + +PARAMETERS: + +* **value** (`number`) + +Significant digits (for display) +#### fn standardOptions.withDisplayName + +```jsonnet +standardOptions.withDisplayName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The display value for this field. This supports template variables blank is auto +#### fn standardOptions.withFilterable + +```jsonnet +standardOptions.withFilterable(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +True if data source field supports ad-hoc filters +#### fn standardOptions.withLinks + +```jsonnet +standardOptions.withLinks(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withLinksMixin + +```jsonnet +standardOptions.withLinksMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The behavior when clicking on a result +#### fn standardOptions.withMappings + +```jsonnet +standardOptions.withMappings(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMappingsMixin + +```jsonnet +standardOptions.withMappingsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Convert input values into a display string +#### fn standardOptions.withMax + +```jsonnet +standardOptions.withMax(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withMin + +```jsonnet +standardOptions.withMin(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn standardOptions.withNoValue + +```jsonnet +standardOptions.withNoValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Alternative to empty string +#### fn standardOptions.withOverrides + +```jsonnet +standardOptions.withOverrides(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withOverridesMixin + +```jsonnet +standardOptions.withOverridesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn standardOptions.withPath + +```jsonnet +standardOptions.withPath(value) +``` + +PARAMETERS: + +* **value** (`string`) + +An explicit path to the field in the datasource. When the frame meta includes a path, +This will default to `${frame.meta.path}/${field.name} + +When defined, this value can be used as an identifier within the datasource scope, and +may be used to update the results +#### fn standardOptions.withUnit + +```jsonnet +standardOptions.withUnit(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Numeric Options +#### obj standardOptions.color + + +##### fn standardOptions.color.withFixedColor + +```jsonnet +standardOptions.color.withFixedColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Stores the fixed color value if mode is fixed +##### fn standardOptions.color.withMode + +```jsonnet +standardOptions.color.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The main color scheme mode +##### fn standardOptions.color.withSeriesBy + +```jsonnet +standardOptions.color.withSeriesBy(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"min"`, `"max"`, `"last"` + +TODO docs +#### obj standardOptions.thresholds + + +##### fn standardOptions.thresholds.withMode + +```jsonnet +standardOptions.thresholds.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"absolute"`, `"percentage"` + + +##### fn standardOptions.thresholds.withSteps + +```jsonnet +standardOptions.thresholds.withSteps(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity +##### fn standardOptions.thresholds.withStepsMixin + +```jsonnet +standardOptions.thresholds.withStepsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Must be sorted by 'value', first value is always -Infinity \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/xyChart/options/series.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/xyChart/options/series.md new file mode 100644 index 0000000000..00891ab5d8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/xyChart/options/series.md @@ -0,0 +1,638 @@ +# series + + + +## Index + +* [`fn withAxisCenteredZero(value=true)`](#fn-withaxiscenteredzero) +* [`fn withAxisColorMode(value)`](#fn-withaxiscolormode) +* [`fn withAxisGridShow(value=true)`](#fn-withaxisgridshow) +* [`fn withAxisLabel(value)`](#fn-withaxislabel) +* [`fn withAxisPlacement(value)`](#fn-withaxisplacement) +* [`fn withAxisSoftMax(value)`](#fn-withaxissoftmax) +* [`fn withAxisSoftMin(value)`](#fn-withaxissoftmin) +* [`fn withAxisWidth(value)`](#fn-withaxiswidth) +* [`fn withHideFrom(value)`](#fn-withhidefrom) +* [`fn withHideFromMixin(value)`](#fn-withhidefrommixin) +* [`fn withLabel(value)`](#fn-withlabel) +* [`fn withLabelValue(value)`](#fn-withlabelvalue) +* [`fn withLabelValueMixin(value)`](#fn-withlabelvaluemixin) +* [`fn withLineColor(value)`](#fn-withlinecolor) +* [`fn withLineColorMixin(value)`](#fn-withlinecolormixin) +* [`fn withLineStyle(value)`](#fn-withlinestyle) +* [`fn withLineStyleMixin(value)`](#fn-withlinestylemixin) +* [`fn withLineWidth(value)`](#fn-withlinewidth) +* [`fn withName(value)`](#fn-withname) +* [`fn withPointColor(value)`](#fn-withpointcolor) +* [`fn withPointColorMixin(value)`](#fn-withpointcolormixin) +* [`fn withPointSize(value)`](#fn-withpointsize) +* [`fn withPointSizeMixin(value)`](#fn-withpointsizemixin) +* [`fn withScaleDistribution(value)`](#fn-withscaledistribution) +* [`fn withScaleDistributionMixin(value)`](#fn-withscaledistributionmixin) +* [`fn withShow(value)`](#fn-withshow) +* [`fn withX(value)`](#fn-withx) +* [`fn withY(value)`](#fn-withy) +* [`obj hideFrom`](#obj-hidefrom) + * [`fn withLegend(value=true)`](#fn-hidefromwithlegend) + * [`fn withTooltip(value=true)`](#fn-hidefromwithtooltip) + * [`fn withViz(value=true)`](#fn-hidefromwithviz) +* [`obj labelValue`](#obj-labelvalue) + * [`fn withField(value)`](#fn-labelvaluewithfield) + * [`fn withFixed(value)`](#fn-labelvaluewithfixed) + * [`fn withMode(value)`](#fn-labelvaluewithmode) +* [`obj lineColor`](#obj-linecolor) + * [`fn withField(value)`](#fn-linecolorwithfield) + * [`fn withFixed(value)`](#fn-linecolorwithfixed) +* [`obj lineStyle`](#obj-linestyle) + * [`fn withDash(value)`](#fn-linestylewithdash) + * [`fn withDashMixin(value)`](#fn-linestylewithdashmixin) + * [`fn withFill(value)`](#fn-linestylewithfill) +* [`obj pointColor`](#obj-pointcolor) + * [`fn withField(value)`](#fn-pointcolorwithfield) + * [`fn withFixed(value)`](#fn-pointcolorwithfixed) +* [`obj pointSize`](#obj-pointsize) + * [`fn withField(value)`](#fn-pointsizewithfield) + * [`fn withFixed(value)`](#fn-pointsizewithfixed) + * [`fn withMax(value)`](#fn-pointsizewithmax) + * [`fn withMin(value)`](#fn-pointsizewithmin) + * [`fn withMode(value)`](#fn-pointsizewithmode) +* [`obj scaleDistribution`](#obj-scaledistribution) + * [`fn withLinearThreshold(value)`](#fn-scaledistributionwithlinearthreshold) + * [`fn withLog(value)`](#fn-scaledistributionwithlog) + * [`fn withType(value)`](#fn-scaledistributionwithtype) + +## Fields + +### fn withAxisCenteredZero + +```jsonnet +withAxisCenteredZero(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withAxisColorMode + +```jsonnet +withAxisColorMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"text"`, `"series"` + +TODO docs +### fn withAxisGridShow + +```jsonnet +withAxisGridShow(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withAxisLabel + +```jsonnet +withAxisLabel(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withAxisPlacement + +```jsonnet +withAxisPlacement(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"auto"`, `"top"`, `"right"`, `"bottom"`, `"left"`, `"hidden"` + +TODO docs +### fn withAxisSoftMax + +```jsonnet +withAxisSoftMax(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +### fn withAxisSoftMin + +```jsonnet +withAxisSoftMin(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +### fn withAxisWidth + +```jsonnet +withAxisWidth(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +### fn withHideFrom + +```jsonnet +withHideFrom(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +### fn withHideFromMixin + +```jsonnet +withHideFromMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +### fn withLabel + +```jsonnet +withLabel(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"auto"`, `"never"`, `"always"` + +TODO docs +### fn withLabelValue + +```jsonnet +withLabelValue(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withLabelValueMixin + +```jsonnet +withLabelValueMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withLineColor + +```jsonnet +withLineColor(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withLineColorMixin + +```jsonnet +withLineColorMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withLineStyle + +```jsonnet +withLineStyle(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +### fn withLineStyleMixin + +```jsonnet +withLineStyleMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +### fn withLineWidth + +```jsonnet +withLineWidth(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +### fn withName + +```jsonnet +withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withPointColor + +```jsonnet +withPointColor(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withPointColorMixin + +```jsonnet +withPointColorMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withPointSize + +```jsonnet +withPointSize(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withPointSizeMixin + +```jsonnet +withPointSizeMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withScaleDistribution + +```jsonnet +withScaleDistribution(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +### fn withScaleDistributionMixin + +```jsonnet +withScaleDistributionMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +### fn withShow + +```jsonnet +withShow(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"points"`, `"lines"`, `"points+lines"` + + +### fn withX + +```jsonnet +withX(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withY + +```jsonnet +withY(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj hideFrom + + +#### fn hideFrom.withLegend + +```jsonnet +hideFrom.withLegend(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +#### fn hideFrom.withTooltip + +```jsonnet +hideFrom.withTooltip(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +#### fn hideFrom.withViz + +```jsonnet +hideFrom.withViz(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### obj labelValue + + +#### fn labelValue.withField + +```jsonnet +labelValue.withField(value) +``` + +PARAMETERS: + +* **value** (`string`) + +fixed: T -- will be added by each element +#### fn labelValue.withFixed + +```jsonnet +labelValue.withFixed(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn labelValue.withMode + +```jsonnet +labelValue.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"fixed"`, `"field"`, `"template"` + + +### obj lineColor + + +#### fn lineColor.withField + +```jsonnet +lineColor.withField(value) +``` + +PARAMETERS: + +* **value** (`string`) + +fixed: T -- will be added by each element +#### fn lineColor.withFixed + +```jsonnet +lineColor.withFixed(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj lineStyle + + +#### fn lineStyle.withDash + +```jsonnet +lineStyle.withDash(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn lineStyle.withDashMixin + +```jsonnet +lineStyle.withDashMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn lineStyle.withFill + +```jsonnet +lineStyle.withFill(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"solid"`, `"dash"`, `"dot"`, `"square"` + + +### obj pointColor + + +#### fn pointColor.withField + +```jsonnet +pointColor.withField(value) +``` + +PARAMETERS: + +* **value** (`string`) + +fixed: T -- will be added by each element +#### fn pointColor.withFixed + +```jsonnet +pointColor.withFixed(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj pointSize + + +#### fn pointSize.withField + +```jsonnet +pointSize.withField(value) +``` + +PARAMETERS: + +* **value** (`string`) + +fixed: T -- will be added by each element +#### fn pointSize.withFixed + +```jsonnet +pointSize.withFixed(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn pointSize.withMax + +```jsonnet +pointSize.withMax(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn pointSize.withMin + +```jsonnet +pointSize.withMin(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn pointSize.withMode + +```jsonnet +pointSize.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"linear"`, `"quad"` + + +### obj scaleDistribution + + +#### fn scaleDistribution.withLinearThreshold + +```jsonnet +scaleDistribution.withLinearThreshold(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn scaleDistribution.withLog + +```jsonnet +scaleDistribution.withLog(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn scaleDistribution.withType + +```jsonnet +scaleDistribution.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"linear"`, `"log"`, `"ordinal"`, `"symlog"` + +TODO docs \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/xyChart/panelOptions/link.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/xyChart/panelOptions/link.md new file mode 100644 index 0000000000..106f9d2edb --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/xyChart/panelOptions/link.md @@ -0,0 +1,145 @@ +# link + + + +## Index + +* [`fn withAsDropdown(value=true)`](#fn-withasdropdown) +* [`fn withIcon(value)`](#fn-withicon) +* [`fn withIncludeVars(value=true)`](#fn-withincludevars) +* [`fn withKeepTime(value=true)`](#fn-withkeeptime) +* [`fn withTags(value)`](#fn-withtags) +* [`fn withTagsMixin(value)`](#fn-withtagsmixin) +* [`fn withTargetBlank(value=true)`](#fn-withtargetblank) +* [`fn withTitle(value)`](#fn-withtitle) +* [`fn withTooltip(value)`](#fn-withtooltip) +* [`fn withType(value)`](#fn-withtype) +* [`fn withUrl(value)`](#fn-withurl) + +## Fields + +### fn withAsDropdown + +```jsonnet +withAsDropdown(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withIcon + +```jsonnet +withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withIncludeVars + +```jsonnet +withIncludeVars(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withKeepTime + +```jsonnet +withKeepTime(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTags + +```jsonnet +withTags(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTagsMixin + +```jsonnet +withTagsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withTargetBlank + +```jsonnet +withTargetBlank(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withTitle + +```jsonnet +withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withTooltip + +```jsonnet +withTooltip(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withType + +```jsonnet +withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"link"`, `"dashboards"` + +TODO docs +### fn withUrl + +```jsonnet +withUrl(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/xyChart/queryOptions/transformation.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/xyChart/queryOptions/transformation.md new file mode 100644 index 0000000000..dc832f653d --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/xyChart/queryOptions/transformation.md @@ -0,0 +1,99 @@ +# transformation + + + +## Index + +* [`fn withDisabled(value=true)`](#fn-withdisabled) +* [`fn withFilter(value)`](#fn-withfilter) +* [`fn withFilterMixin(value)`](#fn-withfiltermixin) +* [`fn withId(value)`](#fn-withid) +* [`fn withOptions(value)`](#fn-withoptions) +* [`obj filter`](#obj-filter) + * [`fn withId(value="")`](#fn-filterwithid) + * [`fn withOptions(value)`](#fn-filterwithoptions) + +## Fields + +### fn withDisabled + +```jsonnet +withDisabled(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Disabled transformations are skipped +### fn withFilter + +```jsonnet +withFilter(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withFilterMixin + +```jsonnet +withFilterMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withId + +```jsonnet +withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Unique identifier of transformer +### fn withOptions + +```jsonnet +withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Options to be passed to the transformer +Valid options depend on the transformer id +### obj filter + + +#### fn filter.withId + +```jsonnet +filter.withId(value="") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `""` + + +#### fn filter.withOptions + +```jsonnet +filter.withOptions(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/xyChart/standardOptions/mapping.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/xyChart/standardOptions/mapping.md new file mode 100644 index 0000000000..93296972e8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/xyChart/standardOptions/mapping.md @@ -0,0 +1,469 @@ +# mapping + + + +## Index + +* [`obj RangeMap`](#obj-rangemap) + * [`fn withOptions(value)`](#fn-rangemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-rangemapwithoptionsmixin) + * [`fn withType(value)`](#fn-rangemapwithtype) + * [`obj options`](#obj-rangemapoptions) + * [`fn withFrom(value)`](#fn-rangemapoptionswithfrom) + * [`fn withResult(value)`](#fn-rangemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-rangemapoptionswithresultmixin) + * [`fn withTo(value)`](#fn-rangemapoptionswithto) + * [`obj result`](#obj-rangemapoptionsresult) + * [`fn withColor(value)`](#fn-rangemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-rangemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-rangemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-rangemapoptionsresultwithtext) +* [`obj RegexMap`](#obj-regexmap) + * [`fn withOptions(value)`](#fn-regexmapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-regexmapwithoptionsmixin) + * [`fn withType(value)`](#fn-regexmapwithtype) + * [`obj options`](#obj-regexmapoptions) + * [`fn withPattern(value)`](#fn-regexmapoptionswithpattern) + * [`fn withResult(value)`](#fn-regexmapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-regexmapoptionswithresultmixin) + * [`obj result`](#obj-regexmapoptionsresult) + * [`fn withColor(value)`](#fn-regexmapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-regexmapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-regexmapoptionsresultwithindex) + * [`fn withText(value)`](#fn-regexmapoptionsresultwithtext) +* [`obj SpecialValueMap`](#obj-specialvaluemap) + * [`fn withOptions(value)`](#fn-specialvaluemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-specialvaluemapwithoptionsmixin) + * [`fn withType(value)`](#fn-specialvaluemapwithtype) + * [`obj options`](#obj-specialvaluemapoptions) + * [`fn withMatch(value)`](#fn-specialvaluemapoptionswithmatch) + * [`fn withPattern(value)`](#fn-specialvaluemapoptionswithpattern) + * [`fn withResult(value)`](#fn-specialvaluemapoptionswithresult) + * [`fn withResultMixin(value)`](#fn-specialvaluemapoptionswithresultmixin) + * [`obj result`](#obj-specialvaluemapoptionsresult) + * [`fn withColor(value)`](#fn-specialvaluemapoptionsresultwithcolor) + * [`fn withIcon(value)`](#fn-specialvaluemapoptionsresultwithicon) + * [`fn withIndex(value)`](#fn-specialvaluemapoptionsresultwithindex) + * [`fn withText(value)`](#fn-specialvaluemapoptionsresultwithtext) +* [`obj ValueMap`](#obj-valuemap) + * [`fn withOptions(value)`](#fn-valuemapwithoptions) + * [`fn withOptionsMixin(value)`](#fn-valuemapwithoptionsmixin) + * [`fn withType(value)`](#fn-valuemapwithtype) + +## Fields + +### obj RangeMap + + +#### fn RangeMap.withOptions + +```jsonnet +RangeMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withOptionsMixin + +```jsonnet +RangeMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RangeMap.withType + +```jsonnet +RangeMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RangeMap.options + + +##### fn RangeMap.options.withFrom + +```jsonnet +RangeMap.options.withFrom(value) +``` + +PARAMETERS: + +* **value** (`number`) + +to and from are `number | null` in current ts, really not sure what to do +##### fn RangeMap.options.withResult + +```jsonnet +RangeMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withResultMixin + +```jsonnet +RangeMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RangeMap.options.withTo + +```jsonnet +RangeMap.options.withTo(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +##### obj RangeMap.options.result + + +###### fn RangeMap.options.result.withColor + +```jsonnet +RangeMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIcon + +```jsonnet +RangeMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RangeMap.options.result.withIndex + +```jsonnet +RangeMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RangeMap.options.result.withText + +```jsonnet +RangeMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj RegexMap + + +#### fn RegexMap.withOptions + +```jsonnet +RegexMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withOptionsMixin + +```jsonnet +RegexMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn RegexMap.withType + +```jsonnet +RegexMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj RegexMap.options + + +##### fn RegexMap.options.withPattern + +```jsonnet +RegexMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn RegexMap.options.withResult + +```jsonnet +RegexMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn RegexMap.options.withResultMixin + +```jsonnet +RegexMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj RegexMap.options.result + + +###### fn RegexMap.options.result.withColor + +```jsonnet +RegexMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIcon + +```jsonnet +RegexMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn RegexMap.options.result.withIndex + +```jsonnet +RegexMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn RegexMap.options.result.withText + +```jsonnet +RegexMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj SpecialValueMap + + +#### fn SpecialValueMap.withOptions + +```jsonnet +SpecialValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withOptionsMixin + +```jsonnet +SpecialValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn SpecialValueMap.withType + +```jsonnet +SpecialValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj SpecialValueMap.options + + +##### fn SpecialValueMap.options.withMatch + +```jsonnet +SpecialValueMap.options.withMatch(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"true"`, `"false"` + + +##### fn SpecialValueMap.options.withPattern + +```jsonnet +SpecialValueMap.options.withPattern(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn SpecialValueMap.options.withResult + +```jsonnet +SpecialValueMap.options.withResult(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### fn SpecialValueMap.options.withResultMixin + +```jsonnet +SpecialValueMap.options.withResultMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +TODO docs +##### obj SpecialValueMap.options.result + + +###### fn SpecialValueMap.options.result.withColor + +```jsonnet +SpecialValueMap.options.result.withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIcon + +```jsonnet +SpecialValueMap.options.result.withIcon(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn SpecialValueMap.options.result.withIndex + +```jsonnet +SpecialValueMap.options.result.withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +###### fn SpecialValueMap.options.result.withText + +```jsonnet +SpecialValueMap.options.result.withText(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj ValueMap + + +#### fn ValueMap.withOptions + +```jsonnet +ValueMap.withOptions(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withOptionsMixin + +```jsonnet +ValueMap.withOptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn ValueMap.withType + +```jsonnet +ValueMap.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/xyChart/standardOptions/override.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/xyChart/standardOptions/override.md new file mode 100644 index 0000000000..154f3dbdac --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/xyChart/standardOptions/override.md @@ -0,0 +1,244 @@ +# override + +Overrides allow you to customize visualization settings for specific fields or +series. This is accomplished by adding an override rule that targets +a particular set of fields and that can each define multiple options. + +```jsonnet +override.byType.new('number') ++ override.byType.withPropertiesFromOptions( + panel.standardOptions.withDecimals(2) + + panel.standardOptions.withUnit('s') +) +``` + + +## Index + +* [`obj byName`](#obj-byname) + * [`fn new(value)`](#fn-bynamenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bynamewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bynamewithproperty) +* [`obj byQuery`](#obj-byquery) + * [`fn new(value)`](#fn-byquerynew) + * [`fn withPropertiesFromOptions(options)`](#fn-byquerywithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byquerywithproperty) +* [`obj byRegexp`](#obj-byregexp) + * [`fn new(value)`](#fn-byregexpnew) + * [`fn withPropertiesFromOptions(options)`](#fn-byregexpwithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byregexpwithproperty) +* [`obj byType`](#obj-bytype) + * [`fn new(value)`](#fn-bytypenew) + * [`fn withPropertiesFromOptions(options)`](#fn-bytypewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-bytypewithproperty) +* [`obj byValue`](#obj-byvalue) + * [`fn new(value)`](#fn-byvaluenew) + * [`fn withPropertiesFromOptions(options)`](#fn-byvaluewithpropertiesfromoptions) + * [`fn withProperty(id, value)`](#fn-byvaluewithproperty) + +## Fields + +### obj byName + + +#### fn byName.new + +```jsonnet +byName.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byName`. +#### fn byName.withPropertiesFromOptions + +```jsonnet +byName.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byName.withProperty + +```jsonnet +byName.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byQuery + + +#### fn byQuery.new + +```jsonnet +byQuery.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byQuery`. +#### fn byQuery.withPropertiesFromOptions + +```jsonnet +byQuery.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byQuery.withProperty + +```jsonnet +byQuery.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byRegexp + + +#### fn byRegexp.new + +```jsonnet +byRegexp.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byRegexp`. +#### fn byRegexp.withPropertiesFromOptions + +```jsonnet +byRegexp.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byRegexp.withProperty + +```jsonnet +byRegexp.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byType + + +#### fn byType.new + +```jsonnet +byType.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byType`. +#### fn byType.withPropertiesFromOptions + +```jsonnet +byType.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byType.withProperty + +```jsonnet +byType.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. + +### obj byValue + + +#### fn byValue.new + +```jsonnet +byValue.new(value) +``` + +PARAMETERS: + +* **value** (`string`) + +`new` creates a new override of type `byValue`. +#### fn byValue.withPropertiesFromOptions + +```jsonnet +byValue.withPropertiesFromOptions(options) +``` + +PARAMETERS: + +* **options** (`object`) + +`withPropertiesFromOptions` takes an object with properties that need to be +overridden. See example code above. + +#### fn byValue.withProperty + +```jsonnet +byValue.withProperty(id, value) +``` + +PARAMETERS: + +* **id** (`string`) +* **value** (`any`) + +`withProperty` adds a property that needs to be overridden. This function can +be called multiple time, adding more properties. diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/xyChart/standardOptions/threshold/step.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/xyChart/standardOptions/threshold/step.md new file mode 100644 index 0000000000..dd2dd227ff --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/panel/xyChart/standardOptions/threshold/step.md @@ -0,0 +1,60 @@ +# threshold.step + + + +## Index + +* [`fn withColor(value)`](#fn-withcolor) +* [`fn withIndex(value)`](#fn-withindex) +* [`fn withState(value)`](#fn-withstate) +* [`fn withValue(value)`](#fn-withvalue) + +## Fields + +### fn withColor + +```jsonnet +withColor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +### fn withIndex + +```jsonnet +withIndex(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Threshold index, an old property that is not needed an should only appear in older dashboards +### fn withState + +```jsonnet +withState(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TODO docs +TODO are the values here enumerable into a disjunction? +Some seem to be listed in typescript comment +### fn withValue + +```jsonnet +withValue(value) +``` + +PARAMETERS: + +* **value** (`number`) + +TODO docs +FIXME the corresponding typescript field is required/non-optional, but nulls currently appear here when serializing -Infinity to JSON \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/playlist/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/playlist/index.md new file mode 100644 index 0000000000..27624b512c --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/playlist/index.md @@ -0,0 +1,78 @@ +# playlist + +grafonnet.playlist + +## Subpackages + +* [items](items.md) + +## Index + +* [`fn withInterval(value="5m")`](#fn-withinterval) +* [`fn withItems(value)`](#fn-withitems) +* [`fn withItemsMixin(value)`](#fn-withitemsmixin) +* [`fn withName(value)`](#fn-withname) +* [`fn withUid(value)`](#fn-withuid) + +## Fields + +### fn withInterval + +```jsonnet +withInterval(value="5m") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"5m"` + +Interval sets the time between switching views in a playlist. +FIXME: Is this based on a standardized format or what options are available? Can datemath be used? +### fn withItems + +```jsonnet +withItems(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The ordered list of items that the playlist will iterate over. +FIXME! This should not be optional, but changing it makes the godegen awkward +### fn withItemsMixin + +```jsonnet +withItemsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +The ordered list of items that the playlist will iterate over. +FIXME! This should not be optional, but changing it makes the godegen awkward +### fn withName + +```jsonnet +withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of the playlist. +### fn withUid + +```jsonnet +withUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Unique playlist identifier. Generated on creation, either by the +creator of the playlist of by the application. \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/playlist/items.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/playlist/items.md new file mode 100644 index 0000000000..8361764359 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/playlist/items.md @@ -0,0 +1,53 @@ +# items + + + +## Index + +* [`fn withTitle(value)`](#fn-withtitle) +* [`fn withType(value)`](#fn-withtype) +* [`fn withValue(value)`](#fn-withvalue) + +## Fields + +### fn withTitle + +```jsonnet +withTitle(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Title is an unused property -- it will be removed in the future +### fn withType + +```jsonnet +withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"dashboard_by_uid"`, `"dashboard_by_id"`, `"dashboard_by_tag"` + +Type of the item. +### fn withValue + +```jsonnet +withValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Value depends on type and describes the playlist item. + + - dashboard_by_id: The value is an internal numerical identifier set by Grafana. This + is not portable as the numerical identifier is non-deterministic between different instances. + Will be replaced by dashboard_by_uid in the future. (deprecated) + - dashboard_by_tag: The value is a tag which is set on any number of dashboards. All + dashboards behind the tag will be added to the playlist. + - dashboard_by_uid: The value is the dashboard UID \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/preferences.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/preferences.md new file mode 100644 index 0000000000..7f6f9d5e11 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/preferences.md @@ -0,0 +1,110 @@ +# preferences + +grafonnet.preferences + +## Index + +* [`fn withHomeDashboardUID(value)`](#fn-withhomedashboarduid) +* [`fn withLanguage(value)`](#fn-withlanguage) +* [`fn withQueryHistory(value)`](#fn-withqueryhistory) +* [`fn withQueryHistoryMixin(value)`](#fn-withqueryhistorymixin) +* [`fn withTheme(value)`](#fn-withtheme) +* [`fn withTimezone(value)`](#fn-withtimezone) +* [`fn withWeekStart(value)`](#fn-withweekstart) +* [`obj queryHistory`](#obj-queryhistory) + * [`fn withHomeTab(value)`](#fn-queryhistorywithhometab) + +## Fields + +### fn withHomeDashboardUID + +```jsonnet +withHomeDashboardUID(value) +``` + +PARAMETERS: + +* **value** (`string`) + +UID for the home dashboard +### fn withLanguage + +```jsonnet +withLanguage(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Selected language (beta) +### fn withQueryHistory + +```jsonnet +withQueryHistory(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withQueryHistoryMixin + +```jsonnet +withQueryHistoryMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withTheme + +```jsonnet +withTheme(value) +``` + +PARAMETERS: + +* **value** (`string`) + +light, dark, empty is default +### fn withTimezone + +```jsonnet +withTimezone(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The timezone selection +TODO: this should use the timezone defined in common +### fn withWeekStart + +```jsonnet +withWeekStart(value) +``` + +PARAMETERS: + +* **value** (`string`) + +day of the week (sunday, monday, etc) +### obj queryHistory + + +#### fn queryHistory.withHomeTab + +```jsonnet +queryHistory.withHomeTab(value) +``` + +PARAMETERS: + +* **value** (`string`) + +one of: '' | 'query' | 'starred'; \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/publicdashboard.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/publicdashboard.md new file mode 100644 index 0000000000..9cb78fbd5c --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/publicdashboard.md @@ -0,0 +1,84 @@ +# publicdashboard + +grafonnet.publicdashboard + +## Index + +* [`fn withAccessToken(value)`](#fn-withaccesstoken) +* [`fn withAnnotationsEnabled(value=true)`](#fn-withannotationsenabled) +* [`fn withDashboardUid(value)`](#fn-withdashboarduid) +* [`fn withIsEnabled(value=true)`](#fn-withisenabled) +* [`fn withTimeSelectionEnabled(value=true)`](#fn-withtimeselectionenabled) +* [`fn withUid(value)`](#fn-withuid) + +## Fields + +### fn withAccessToken + +```jsonnet +withAccessToken(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Unique public access token +### fn withAnnotationsEnabled + +```jsonnet +withAnnotationsEnabled(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Flag that indicates if annotations are enabled +### fn withDashboardUid + +```jsonnet +withDashboardUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Dashboard unique identifier referenced by this public dashboard +### fn withIsEnabled + +```jsonnet +withIsEnabled(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Flag that indicates if the public dashboard is enabled +### fn withTimeSelectionEnabled + +```jsonnet +withTimeSelectionEnabled(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Flag that indicates if the time range picker is enabled +### fn withUid + +```jsonnet +withUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Unique public dashboard identifier \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/azureMonitor/azureMonitor/dimensionFilters.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/azureMonitor/azureMonitor/dimensionFilters.md new file mode 100644 index 0000000000..43b6cf5503 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/azureMonitor/azureMonitor/dimensionFilters.md @@ -0,0 +1,69 @@ +# dimensionFilters + + + +## Index + +* [`fn withDimension(value)`](#fn-withdimension) +* [`fn withFilter(value)`](#fn-withfilter) +* [`fn withFilters(value)`](#fn-withfilters) +* [`fn withFiltersMixin(value)`](#fn-withfiltersmixin) +* [`fn withOperator(value)`](#fn-withoperator) + +## Fields + +### fn withDimension + +```jsonnet +withDimension(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of Dimension to be filtered on. +### fn withFilter + +```jsonnet +withFilter(value) +``` + +PARAMETERS: + +* **value** (`string`) + +@deprecated filter is deprecated in favour of filters to support multiselect. +### fn withFilters + +```jsonnet +withFilters(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Values to match with the filter. +### fn withFiltersMixin + +```jsonnet +withFiltersMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Values to match with the filter. +### fn withOperator + +```jsonnet +withOperator(value) +``` + +PARAMETERS: + +* **value** (`string`) + +String denoting the filter operation. Supports 'eq' - equals,'ne' - not equals, 'sw' - starts with. Note that some dimensions may not support all operators. \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/azureMonitor/azureMonitor/resources.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/azureMonitor/azureMonitor/resources.md new file mode 100644 index 0000000000..18bb633afc --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/azureMonitor/azureMonitor/resources.md @@ -0,0 +1,68 @@ +# resources + + + +## Index + +* [`fn withMetricNamespace(value)`](#fn-withmetricnamespace) +* [`fn withRegion(value)`](#fn-withregion) +* [`fn withResourceGroup(value)`](#fn-withresourcegroup) +* [`fn withResourceName(value)`](#fn-withresourcename) +* [`fn withSubscription(value)`](#fn-withsubscription) + +## Fields + +### fn withMetricNamespace + +```jsonnet +withMetricNamespace(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withRegion + +```jsonnet +withRegion(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withResourceGroup + +```jsonnet +withResourceGroup(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withResourceName + +```jsonnet +withResourceName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withSubscription + +```jsonnet +withSubscription(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/azureMonitor/azureTraces/filters.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/azureMonitor/azureTraces/filters.md new file mode 100644 index 0000000000..0c5c7182a8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/azureMonitor/azureTraces/filters.md @@ -0,0 +1,57 @@ +# filters + + + +## Index + +* [`fn withFilters(value)`](#fn-withfilters) +* [`fn withFiltersMixin(value)`](#fn-withfiltersmixin) +* [`fn withOperation(value)`](#fn-withoperation) +* [`fn withProperty(value)`](#fn-withproperty) + +## Fields + +### fn withFilters + +```jsonnet +withFilters(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Values to filter by. +### fn withFiltersMixin + +```jsonnet +withFiltersMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Values to filter by. +### fn withOperation + +```jsonnet +withOperation(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Comparison operator to use. Either equals or not equals. +### fn withProperty + +```jsonnet +withProperty(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Property name, auto-populated based on available traces. \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/azureMonitor/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/azureMonitor/index.md new file mode 100644 index 0000000000..b836b44e3c --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/azureMonitor/index.md @@ -0,0 +1,1502 @@ +# azureMonitor + +grafonnet.query.azureMonitor + +## Subpackages + +* [azureMonitor.dimensionFilters](azureMonitor/dimensionFilters.md) +* [azureMonitor.resources](azureMonitor/resources.md) +* [azureTraces.filters](azureTraces/filters.md) + +## Index + +* [`fn withAzureLogAnalytics(value)`](#fn-withazureloganalytics) +* [`fn withAzureLogAnalyticsMixin(value)`](#fn-withazureloganalyticsmixin) +* [`fn withAzureMonitor(value)`](#fn-withazuremonitor) +* [`fn withAzureMonitorMixin(value)`](#fn-withazuremonitormixin) +* [`fn withAzureResourceGraph(value)`](#fn-withazureresourcegraph) +* [`fn withAzureResourceGraphMixin(value)`](#fn-withazureresourcegraphmixin) +* [`fn withAzureTraces(value)`](#fn-withazuretraces) +* [`fn withAzureTracesMixin(value)`](#fn-withazuretracesmixin) +* [`fn withDatasource(value)`](#fn-withdatasource) +* [`fn withGrafanaTemplateVariableFn(value)`](#fn-withgrafanatemplatevariablefn) +* [`fn withGrafanaTemplateVariableFnMixin(value)`](#fn-withgrafanatemplatevariablefnmixin) +* [`fn withHide(value=true)`](#fn-withhide) +* [`fn withNamespace(value)`](#fn-withnamespace) +* [`fn withQueryType(value)`](#fn-withquerytype) +* [`fn withRefId(value)`](#fn-withrefid) +* [`fn withRegion(value)`](#fn-withregion) +* [`fn withResource(value)`](#fn-withresource) +* [`fn withResourceGroup(value)`](#fn-withresourcegroup) +* [`fn withSubscription(value)`](#fn-withsubscription) +* [`fn withSubscriptions(value)`](#fn-withsubscriptions) +* [`fn withSubscriptionsMixin(value)`](#fn-withsubscriptionsmixin) +* [`obj azureLogAnalytics`](#obj-azureloganalytics) + * [`fn withQuery(value)`](#fn-azureloganalyticswithquery) + * [`fn withResource(value)`](#fn-azureloganalyticswithresource) + * [`fn withResources(value)`](#fn-azureloganalyticswithresources) + * [`fn withResourcesMixin(value)`](#fn-azureloganalyticswithresourcesmixin) + * [`fn withResultFormat(value)`](#fn-azureloganalyticswithresultformat) + * [`fn withWorkspace(value)`](#fn-azureloganalyticswithworkspace) +* [`obj azureMonitor`](#obj-azuremonitor) + * [`fn withAggregation(value)`](#fn-azuremonitorwithaggregation) + * [`fn withAlias(value)`](#fn-azuremonitorwithalias) + * [`fn withAllowedTimeGrainsMs(value)`](#fn-azuremonitorwithallowedtimegrainsms) + * [`fn withAllowedTimeGrainsMsMixin(value)`](#fn-azuremonitorwithallowedtimegrainsmsmixin) + * [`fn withCustomNamespace(value)`](#fn-azuremonitorwithcustomnamespace) + * [`fn withDimension(value)`](#fn-azuremonitorwithdimension) + * [`fn withDimensionFilter(value)`](#fn-azuremonitorwithdimensionfilter) + * [`fn withDimensionFilters(value)`](#fn-azuremonitorwithdimensionfilters) + * [`fn withDimensionFiltersMixin(value)`](#fn-azuremonitorwithdimensionfiltersmixin) + * [`fn withMetricDefinition(value)`](#fn-azuremonitorwithmetricdefinition) + * [`fn withMetricName(value)`](#fn-azuremonitorwithmetricname) + * [`fn withMetricNamespace(value)`](#fn-azuremonitorwithmetricnamespace) + * [`fn withRegion(value)`](#fn-azuremonitorwithregion) + * [`fn withResourceGroup(value)`](#fn-azuremonitorwithresourcegroup) + * [`fn withResourceName(value)`](#fn-azuremonitorwithresourcename) + * [`fn withResourceUri(value)`](#fn-azuremonitorwithresourceuri) + * [`fn withResources(value)`](#fn-azuremonitorwithresources) + * [`fn withResourcesMixin(value)`](#fn-azuremonitorwithresourcesmixin) + * [`fn withTimeGrain(value)`](#fn-azuremonitorwithtimegrain) + * [`fn withTimeGrainUnit(value)`](#fn-azuremonitorwithtimegrainunit) + * [`fn withTop(value)`](#fn-azuremonitorwithtop) +* [`obj azureResourceGraph`](#obj-azureresourcegraph) + * [`fn withQuery(value)`](#fn-azureresourcegraphwithquery) + * [`fn withResultFormat(value)`](#fn-azureresourcegraphwithresultformat) +* [`obj azureTraces`](#obj-azuretraces) + * [`fn withFilters(value)`](#fn-azuretraceswithfilters) + * [`fn withFiltersMixin(value)`](#fn-azuretraceswithfiltersmixin) + * [`fn withOperationId(value)`](#fn-azuretraceswithoperationid) + * [`fn withQuery(value)`](#fn-azuretraceswithquery) + * [`fn withResources(value)`](#fn-azuretraceswithresources) + * [`fn withResourcesMixin(value)`](#fn-azuretraceswithresourcesmixin) + * [`fn withResultFormat(value)`](#fn-azuretraceswithresultformat) + * [`fn withTraceTypes(value)`](#fn-azuretraceswithtracetypes) + * [`fn withTraceTypesMixin(value)`](#fn-azuretraceswithtracetypesmixin) +* [`obj grafanaTemplateVariableFn`](#obj-grafanatemplatevariablefn) + * [`fn withAppInsightsGroupByQuery(value)`](#fn-grafanatemplatevariablefnwithappinsightsgroupbyquery) + * [`fn withAppInsightsGroupByQueryMixin(value)`](#fn-grafanatemplatevariablefnwithappinsightsgroupbyquerymixin) + * [`fn withAppInsightsMetricNameQuery(value)`](#fn-grafanatemplatevariablefnwithappinsightsmetricnamequery) + * [`fn withAppInsightsMetricNameQueryMixin(value)`](#fn-grafanatemplatevariablefnwithappinsightsmetricnamequerymixin) + * [`fn withMetricDefinitionsQuery(value)`](#fn-grafanatemplatevariablefnwithmetricdefinitionsquery) + * [`fn withMetricDefinitionsQueryMixin(value)`](#fn-grafanatemplatevariablefnwithmetricdefinitionsquerymixin) + * [`fn withMetricNamesQuery(value)`](#fn-grafanatemplatevariablefnwithmetricnamesquery) + * [`fn withMetricNamesQueryMixin(value)`](#fn-grafanatemplatevariablefnwithmetricnamesquerymixin) + * [`fn withMetricNamespaceQuery(value)`](#fn-grafanatemplatevariablefnwithmetricnamespacequery) + * [`fn withMetricNamespaceQueryMixin(value)`](#fn-grafanatemplatevariablefnwithmetricnamespacequerymixin) + * [`fn withResourceGroupsQuery(value)`](#fn-grafanatemplatevariablefnwithresourcegroupsquery) + * [`fn withResourceGroupsQueryMixin(value)`](#fn-grafanatemplatevariablefnwithresourcegroupsquerymixin) + * [`fn withResourceNamesQuery(value)`](#fn-grafanatemplatevariablefnwithresourcenamesquery) + * [`fn withResourceNamesQueryMixin(value)`](#fn-grafanatemplatevariablefnwithresourcenamesquerymixin) + * [`fn withSubscriptionsQuery(value)`](#fn-grafanatemplatevariablefnwithsubscriptionsquery) + * [`fn withSubscriptionsQueryMixin(value)`](#fn-grafanatemplatevariablefnwithsubscriptionsquerymixin) + * [`fn withUnknownQuery(value)`](#fn-grafanatemplatevariablefnwithunknownquery) + * [`fn withUnknownQueryMixin(value)`](#fn-grafanatemplatevariablefnwithunknownquerymixin) + * [`fn withWorkspacesQuery(value)`](#fn-grafanatemplatevariablefnwithworkspacesquery) + * [`fn withWorkspacesQueryMixin(value)`](#fn-grafanatemplatevariablefnwithworkspacesquerymixin) + * [`obj AppInsightsGroupByQuery`](#obj-grafanatemplatevariablefnappinsightsgroupbyquery) + * [`fn withKind(value)`](#fn-grafanatemplatevariablefnappinsightsgroupbyquerywithkind) + * [`fn withMetricName(value)`](#fn-grafanatemplatevariablefnappinsightsgroupbyquerywithmetricname) + * [`fn withRawQuery(value)`](#fn-grafanatemplatevariablefnappinsightsgroupbyquerywithrawquery) + * [`obj AppInsightsMetricNameQuery`](#obj-grafanatemplatevariablefnappinsightsmetricnamequery) + * [`fn withKind(value)`](#fn-grafanatemplatevariablefnappinsightsmetricnamequerywithkind) + * [`fn withRawQuery(value)`](#fn-grafanatemplatevariablefnappinsightsmetricnamequerywithrawquery) + * [`obj MetricDefinitionsQuery`](#obj-grafanatemplatevariablefnmetricdefinitionsquery) + * [`fn withKind(value)`](#fn-grafanatemplatevariablefnmetricdefinitionsquerywithkind) + * [`fn withMetricNamespace(value)`](#fn-grafanatemplatevariablefnmetricdefinitionsquerywithmetricnamespace) + * [`fn withRawQuery(value)`](#fn-grafanatemplatevariablefnmetricdefinitionsquerywithrawquery) + * [`fn withResourceGroup(value)`](#fn-grafanatemplatevariablefnmetricdefinitionsquerywithresourcegroup) + * [`fn withResourceName(value)`](#fn-grafanatemplatevariablefnmetricdefinitionsquerywithresourcename) + * [`fn withSubscription(value)`](#fn-grafanatemplatevariablefnmetricdefinitionsquerywithsubscription) + * [`obj MetricNamesQuery`](#obj-grafanatemplatevariablefnmetricnamesquery) + * [`fn withKind(value)`](#fn-grafanatemplatevariablefnmetricnamesquerywithkind) + * [`fn withMetricNamespace(value)`](#fn-grafanatemplatevariablefnmetricnamesquerywithmetricnamespace) + * [`fn withRawQuery(value)`](#fn-grafanatemplatevariablefnmetricnamesquerywithrawquery) + * [`fn withResourceGroup(value)`](#fn-grafanatemplatevariablefnmetricnamesquerywithresourcegroup) + * [`fn withResourceName(value)`](#fn-grafanatemplatevariablefnmetricnamesquerywithresourcename) + * [`fn withSubscription(value)`](#fn-grafanatemplatevariablefnmetricnamesquerywithsubscription) + * [`obj MetricNamespaceQuery`](#obj-grafanatemplatevariablefnmetricnamespacequery) + * [`fn withKind(value)`](#fn-grafanatemplatevariablefnmetricnamespacequerywithkind) + * [`fn withMetricNamespace(value)`](#fn-grafanatemplatevariablefnmetricnamespacequerywithmetricnamespace) + * [`fn withRawQuery(value)`](#fn-grafanatemplatevariablefnmetricnamespacequerywithrawquery) + * [`fn withResourceGroup(value)`](#fn-grafanatemplatevariablefnmetricnamespacequerywithresourcegroup) + * [`fn withResourceName(value)`](#fn-grafanatemplatevariablefnmetricnamespacequerywithresourcename) + * [`fn withSubscription(value)`](#fn-grafanatemplatevariablefnmetricnamespacequerywithsubscription) + * [`obj ResourceGroupsQuery`](#obj-grafanatemplatevariablefnresourcegroupsquery) + * [`fn withKind(value)`](#fn-grafanatemplatevariablefnresourcegroupsquerywithkind) + * [`fn withRawQuery(value)`](#fn-grafanatemplatevariablefnresourcegroupsquerywithrawquery) + * [`fn withSubscription(value)`](#fn-grafanatemplatevariablefnresourcegroupsquerywithsubscription) + * [`obj ResourceNamesQuery`](#obj-grafanatemplatevariablefnresourcenamesquery) + * [`fn withKind(value)`](#fn-grafanatemplatevariablefnresourcenamesquerywithkind) + * [`fn withMetricNamespace(value)`](#fn-grafanatemplatevariablefnresourcenamesquerywithmetricnamespace) + * [`fn withRawQuery(value)`](#fn-grafanatemplatevariablefnresourcenamesquerywithrawquery) + * [`fn withResourceGroup(value)`](#fn-grafanatemplatevariablefnresourcenamesquerywithresourcegroup) + * [`fn withSubscription(value)`](#fn-grafanatemplatevariablefnresourcenamesquerywithsubscription) + * [`obj SubscriptionsQuery`](#obj-grafanatemplatevariablefnsubscriptionsquery) + * [`fn withKind(value)`](#fn-grafanatemplatevariablefnsubscriptionsquerywithkind) + * [`fn withRawQuery(value)`](#fn-grafanatemplatevariablefnsubscriptionsquerywithrawquery) + * [`obj UnknownQuery`](#obj-grafanatemplatevariablefnunknownquery) + * [`fn withKind(value)`](#fn-grafanatemplatevariablefnunknownquerywithkind) + * [`fn withRawQuery(value)`](#fn-grafanatemplatevariablefnunknownquerywithrawquery) + * [`obj WorkspacesQuery`](#obj-grafanatemplatevariablefnworkspacesquery) + * [`fn withKind(value)`](#fn-grafanatemplatevariablefnworkspacesquerywithkind) + * [`fn withRawQuery(value)`](#fn-grafanatemplatevariablefnworkspacesquerywithrawquery) + * [`fn withSubscription(value)`](#fn-grafanatemplatevariablefnworkspacesquerywithsubscription) + +## Fields + +### fn withAzureLogAnalytics + +```jsonnet +withAzureLogAnalytics(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Azure Monitor Logs sub-query properties +### fn withAzureLogAnalyticsMixin + +```jsonnet +withAzureLogAnalyticsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Azure Monitor Logs sub-query properties +### fn withAzureMonitor + +```jsonnet +withAzureMonitor(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withAzureMonitorMixin + +```jsonnet +withAzureMonitorMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withAzureResourceGraph + +```jsonnet +withAzureResourceGraph(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withAzureResourceGraphMixin + +```jsonnet +withAzureResourceGraphMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withAzureTraces + +```jsonnet +withAzureTraces(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Application Insights Traces sub-query properties +### fn withAzureTracesMixin + +```jsonnet +withAzureTracesMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +Application Insights Traces sub-query properties +### fn withDatasource + +```jsonnet +withDatasource(value) +``` + +PARAMETERS: + +* **value** (`string`) + +For mixed data sources the selected datasource is on the query level. +For non mixed scenarios this is undefined. +TODO find a better way to do this ^ that's friendly to schema +TODO this shouldn't be unknown but DataSourceRef | null +### fn withGrafanaTemplateVariableFn + +```jsonnet +withGrafanaTemplateVariableFn(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withGrafanaTemplateVariableFnMixin + +```jsonnet +withGrafanaTemplateVariableFnMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withHide + +```jsonnet +withHide(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +true if query is disabled (ie should not be returned to the dashboard) +Note this does not always imply that the query should not be executed since +the results from a hidden query may be used as the input to other queries (SSE etc) +### fn withNamespace + +```jsonnet +withNamespace(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withQueryType + +```jsonnet +withQueryType(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Specify the query flavor +TODO make this required and give it a default +### fn withRefId + +```jsonnet +withRefId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +A unique identifier for the query within the list of targets. +In server side expressions, the refId is used as a variable name to identify results. +By default, the UI will assign A->Z; however setting meaningful names may be useful. +### fn withRegion + +```jsonnet +withRegion(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Azure Monitor query type. +queryType: #AzureQueryType +### fn withResource + +```jsonnet +withResource(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withResourceGroup + +```jsonnet +withResourceGroup(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Template variables params. These exist for backwards compatiblity with legacy template variables. +### fn withSubscription + +```jsonnet +withSubscription(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Azure subscription containing the resource(s) to be queried. +### fn withSubscriptions + +```jsonnet +withSubscriptions(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Subscriptions to be queried via Azure Resource Graph. +### fn withSubscriptionsMixin + +```jsonnet +withSubscriptionsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Subscriptions to be queried via Azure Resource Graph. +### obj azureLogAnalytics + + +#### fn azureLogAnalytics.withQuery + +```jsonnet +azureLogAnalytics.withQuery(value) +``` + +PARAMETERS: + +* **value** (`string`) + +KQL query to be executed. +#### fn azureLogAnalytics.withResource + +```jsonnet +azureLogAnalytics.withResource(value) +``` + +PARAMETERS: + +* **value** (`string`) + +@deprecated Use resources instead +#### fn azureLogAnalytics.withResources + +```jsonnet +azureLogAnalytics.withResources(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Array of resource URIs to be queried. +#### fn azureLogAnalytics.withResourcesMixin + +```jsonnet +azureLogAnalytics.withResourcesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Array of resource URIs to be queried. +#### fn azureLogAnalytics.withResultFormat + +```jsonnet +azureLogAnalytics.withResultFormat(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"table"`, `"time_series"`, `"trace"` + + +#### fn azureLogAnalytics.withWorkspace + +```jsonnet +azureLogAnalytics.withWorkspace(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Workspace ID. This was removed in Grafana 8, but remains for backwards compat +### obj azureMonitor + + +#### fn azureMonitor.withAggregation + +```jsonnet +azureMonitor.withAggregation(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The aggregation to be used within the query. Defaults to the primaryAggregationType defined by the metric. +#### fn azureMonitor.withAlias + +```jsonnet +azureMonitor.withAlias(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Aliases can be set to modify the legend labels. e.g. {{ resourceGroup }}. See docs for more detail. +#### fn azureMonitor.withAllowedTimeGrainsMs + +```jsonnet +azureMonitor.withAllowedTimeGrainsMs(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Time grains that are supported by the metric. +#### fn azureMonitor.withAllowedTimeGrainsMsMixin + +```jsonnet +azureMonitor.withAllowedTimeGrainsMsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Time grains that are supported by the metric. +#### fn azureMonitor.withCustomNamespace + +```jsonnet +azureMonitor.withCustomNamespace(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Used as the value for the metricNamespace property when it's different from the resource namespace. +#### fn azureMonitor.withDimension + +```jsonnet +azureMonitor.withDimension(value) +``` + +PARAMETERS: + +* **value** (`string`) + +@deprecated This property was migrated to dimensionFilters and should only be accessed in the migration +#### fn azureMonitor.withDimensionFilter + +```jsonnet +azureMonitor.withDimensionFilter(value) +``` + +PARAMETERS: + +* **value** (`string`) + +@deprecated This property was migrated to dimensionFilters and should only be accessed in the migration +#### fn azureMonitor.withDimensionFilters + +```jsonnet +azureMonitor.withDimensionFilters(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Filters to reduce the set of data returned. Dimensions that can be filtered on are defined by the metric. +#### fn azureMonitor.withDimensionFiltersMixin + +```jsonnet +azureMonitor.withDimensionFiltersMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Filters to reduce the set of data returned. Dimensions that can be filtered on are defined by the metric. +#### fn azureMonitor.withMetricDefinition + +```jsonnet +azureMonitor.withMetricDefinition(value) +``` + +PARAMETERS: + +* **value** (`string`) + +@deprecated Use metricNamespace instead +#### fn azureMonitor.withMetricName + +```jsonnet +azureMonitor.withMetricName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The metric to query data for within the specified metricNamespace. e.g. UsedCapacity +#### fn azureMonitor.withMetricNamespace + +```jsonnet +azureMonitor.withMetricNamespace(value) +``` + +PARAMETERS: + +* **value** (`string`) + +metricNamespace is used as the resource type (or resource namespace). +It's usually equal to the target metric namespace. e.g. microsoft.storage/storageaccounts +Kept the name of the variable as metricNamespace to avoid backward incompatibility issues. +#### fn azureMonitor.withRegion + +```jsonnet +azureMonitor.withRegion(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The Azure region containing the resource(s). +#### fn azureMonitor.withResourceGroup + +```jsonnet +azureMonitor.withResourceGroup(value) +``` + +PARAMETERS: + +* **value** (`string`) + +@deprecated Use resources instead +#### fn azureMonitor.withResourceName + +```jsonnet +azureMonitor.withResourceName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +@deprecated Use resources instead +#### fn azureMonitor.withResourceUri + +```jsonnet +azureMonitor.withResourceUri(value) +``` + +PARAMETERS: + +* **value** (`string`) + +@deprecated Use resourceGroup, resourceName and metricNamespace instead +#### fn azureMonitor.withResources + +```jsonnet +azureMonitor.withResources(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Array of resource URIs to be queried. +#### fn azureMonitor.withResourcesMixin + +```jsonnet +azureMonitor.withResourcesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Array of resource URIs to be queried. +#### fn azureMonitor.withTimeGrain + +```jsonnet +azureMonitor.withTimeGrain(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The granularity of data points to be queried. Defaults to auto. +#### fn azureMonitor.withTimeGrainUnit + +```jsonnet +azureMonitor.withTimeGrainUnit(value) +``` + +PARAMETERS: + +* **value** (`string`) + +@deprecated +#### fn azureMonitor.withTop + +```jsonnet +azureMonitor.withTop(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Maximum number of records to return. Defaults to 10. +### obj azureResourceGraph + + +#### fn azureResourceGraph.withQuery + +```jsonnet +azureResourceGraph.withQuery(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Azure Resource Graph KQL query to be executed. +#### fn azureResourceGraph.withResultFormat + +```jsonnet +azureResourceGraph.withResultFormat(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Specifies the format results should be returned as. Defaults to table. +### obj azureTraces + + +#### fn azureTraces.withFilters + +```jsonnet +azureTraces.withFilters(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Filters for property values. +#### fn azureTraces.withFiltersMixin + +```jsonnet +azureTraces.withFiltersMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Filters for property values. +#### fn azureTraces.withOperationId + +```jsonnet +azureTraces.withOperationId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Operation ID. Used only for Traces queries. +#### fn azureTraces.withQuery + +```jsonnet +azureTraces.withQuery(value) +``` + +PARAMETERS: + +* **value** (`string`) + +KQL query to be executed. +#### fn azureTraces.withResources + +```jsonnet +azureTraces.withResources(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Array of resource URIs to be queried. +#### fn azureTraces.withResourcesMixin + +```jsonnet +azureTraces.withResourcesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Array of resource URIs to be queried. +#### fn azureTraces.withResultFormat + +```jsonnet +azureTraces.withResultFormat(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"table"`, `"time_series"`, `"trace"` + + +#### fn azureTraces.withTraceTypes + +```jsonnet +azureTraces.withTraceTypes(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Types of events to filter by. +#### fn azureTraces.withTraceTypesMixin + +```jsonnet +azureTraces.withTraceTypesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Types of events to filter by. +### obj grafanaTemplateVariableFn + + +#### fn grafanaTemplateVariableFn.withAppInsightsGroupByQuery + +```jsonnet +grafanaTemplateVariableFn.withAppInsightsGroupByQuery(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn grafanaTemplateVariableFn.withAppInsightsGroupByQueryMixin + +```jsonnet +grafanaTemplateVariableFn.withAppInsightsGroupByQueryMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn grafanaTemplateVariableFn.withAppInsightsMetricNameQuery + +```jsonnet +grafanaTemplateVariableFn.withAppInsightsMetricNameQuery(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn grafanaTemplateVariableFn.withAppInsightsMetricNameQueryMixin + +```jsonnet +grafanaTemplateVariableFn.withAppInsightsMetricNameQueryMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn grafanaTemplateVariableFn.withMetricDefinitionsQuery + +```jsonnet +grafanaTemplateVariableFn.withMetricDefinitionsQuery(value) +``` + +PARAMETERS: + +* **value** (`object`) + +@deprecated Use MetricNamespaceQuery instead +#### fn grafanaTemplateVariableFn.withMetricDefinitionsQueryMixin + +```jsonnet +grafanaTemplateVariableFn.withMetricDefinitionsQueryMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +@deprecated Use MetricNamespaceQuery instead +#### fn grafanaTemplateVariableFn.withMetricNamesQuery + +```jsonnet +grafanaTemplateVariableFn.withMetricNamesQuery(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn grafanaTemplateVariableFn.withMetricNamesQueryMixin + +```jsonnet +grafanaTemplateVariableFn.withMetricNamesQueryMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn grafanaTemplateVariableFn.withMetricNamespaceQuery + +```jsonnet +grafanaTemplateVariableFn.withMetricNamespaceQuery(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn grafanaTemplateVariableFn.withMetricNamespaceQueryMixin + +```jsonnet +grafanaTemplateVariableFn.withMetricNamespaceQueryMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn grafanaTemplateVariableFn.withResourceGroupsQuery + +```jsonnet +grafanaTemplateVariableFn.withResourceGroupsQuery(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn grafanaTemplateVariableFn.withResourceGroupsQueryMixin + +```jsonnet +grafanaTemplateVariableFn.withResourceGroupsQueryMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn grafanaTemplateVariableFn.withResourceNamesQuery + +```jsonnet +grafanaTemplateVariableFn.withResourceNamesQuery(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn grafanaTemplateVariableFn.withResourceNamesQueryMixin + +```jsonnet +grafanaTemplateVariableFn.withResourceNamesQueryMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn grafanaTemplateVariableFn.withSubscriptionsQuery + +```jsonnet +grafanaTemplateVariableFn.withSubscriptionsQuery(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn grafanaTemplateVariableFn.withSubscriptionsQueryMixin + +```jsonnet +grafanaTemplateVariableFn.withSubscriptionsQueryMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn grafanaTemplateVariableFn.withUnknownQuery + +```jsonnet +grafanaTemplateVariableFn.withUnknownQuery(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn grafanaTemplateVariableFn.withUnknownQueryMixin + +```jsonnet +grafanaTemplateVariableFn.withUnknownQueryMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn grafanaTemplateVariableFn.withWorkspacesQuery + +```jsonnet +grafanaTemplateVariableFn.withWorkspacesQuery(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn grafanaTemplateVariableFn.withWorkspacesQueryMixin + +```jsonnet +grafanaTemplateVariableFn.withWorkspacesQueryMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### obj grafanaTemplateVariableFn.AppInsightsGroupByQuery + + +##### fn grafanaTemplateVariableFn.AppInsightsGroupByQuery.withKind + +```jsonnet +grafanaTemplateVariableFn.AppInsightsGroupByQuery.withKind(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"AppInsightsGroupByQuery"` + + +##### fn grafanaTemplateVariableFn.AppInsightsGroupByQuery.withMetricName + +```jsonnet +grafanaTemplateVariableFn.AppInsightsGroupByQuery.withMetricName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn grafanaTemplateVariableFn.AppInsightsGroupByQuery.withRawQuery + +```jsonnet +grafanaTemplateVariableFn.AppInsightsGroupByQuery.withRawQuery(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj grafanaTemplateVariableFn.AppInsightsMetricNameQuery + + +##### fn grafanaTemplateVariableFn.AppInsightsMetricNameQuery.withKind + +```jsonnet +grafanaTemplateVariableFn.AppInsightsMetricNameQuery.withKind(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"AppInsightsMetricNameQuery"` + + +##### fn grafanaTemplateVariableFn.AppInsightsMetricNameQuery.withRawQuery + +```jsonnet +grafanaTemplateVariableFn.AppInsightsMetricNameQuery.withRawQuery(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj grafanaTemplateVariableFn.MetricDefinitionsQuery + + +##### fn grafanaTemplateVariableFn.MetricDefinitionsQuery.withKind + +```jsonnet +grafanaTemplateVariableFn.MetricDefinitionsQuery.withKind(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"MetricDefinitionsQuery"` + + +##### fn grafanaTemplateVariableFn.MetricDefinitionsQuery.withMetricNamespace + +```jsonnet +grafanaTemplateVariableFn.MetricDefinitionsQuery.withMetricNamespace(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn grafanaTemplateVariableFn.MetricDefinitionsQuery.withRawQuery + +```jsonnet +grafanaTemplateVariableFn.MetricDefinitionsQuery.withRawQuery(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn grafanaTemplateVariableFn.MetricDefinitionsQuery.withResourceGroup + +```jsonnet +grafanaTemplateVariableFn.MetricDefinitionsQuery.withResourceGroup(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn grafanaTemplateVariableFn.MetricDefinitionsQuery.withResourceName + +```jsonnet +grafanaTemplateVariableFn.MetricDefinitionsQuery.withResourceName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn grafanaTemplateVariableFn.MetricDefinitionsQuery.withSubscription + +```jsonnet +grafanaTemplateVariableFn.MetricDefinitionsQuery.withSubscription(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj grafanaTemplateVariableFn.MetricNamesQuery + + +##### fn grafanaTemplateVariableFn.MetricNamesQuery.withKind + +```jsonnet +grafanaTemplateVariableFn.MetricNamesQuery.withKind(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"MetricNamesQuery"` + + +##### fn grafanaTemplateVariableFn.MetricNamesQuery.withMetricNamespace + +```jsonnet +grafanaTemplateVariableFn.MetricNamesQuery.withMetricNamespace(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn grafanaTemplateVariableFn.MetricNamesQuery.withRawQuery + +```jsonnet +grafanaTemplateVariableFn.MetricNamesQuery.withRawQuery(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn grafanaTemplateVariableFn.MetricNamesQuery.withResourceGroup + +```jsonnet +grafanaTemplateVariableFn.MetricNamesQuery.withResourceGroup(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn grafanaTemplateVariableFn.MetricNamesQuery.withResourceName + +```jsonnet +grafanaTemplateVariableFn.MetricNamesQuery.withResourceName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn grafanaTemplateVariableFn.MetricNamesQuery.withSubscription + +```jsonnet +grafanaTemplateVariableFn.MetricNamesQuery.withSubscription(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj grafanaTemplateVariableFn.MetricNamespaceQuery + + +##### fn grafanaTemplateVariableFn.MetricNamespaceQuery.withKind + +```jsonnet +grafanaTemplateVariableFn.MetricNamespaceQuery.withKind(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"MetricNamespaceQuery"` + + +##### fn grafanaTemplateVariableFn.MetricNamespaceQuery.withMetricNamespace + +```jsonnet +grafanaTemplateVariableFn.MetricNamespaceQuery.withMetricNamespace(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn grafanaTemplateVariableFn.MetricNamespaceQuery.withRawQuery + +```jsonnet +grafanaTemplateVariableFn.MetricNamespaceQuery.withRawQuery(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn grafanaTemplateVariableFn.MetricNamespaceQuery.withResourceGroup + +```jsonnet +grafanaTemplateVariableFn.MetricNamespaceQuery.withResourceGroup(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn grafanaTemplateVariableFn.MetricNamespaceQuery.withResourceName + +```jsonnet +grafanaTemplateVariableFn.MetricNamespaceQuery.withResourceName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn grafanaTemplateVariableFn.MetricNamespaceQuery.withSubscription + +```jsonnet +grafanaTemplateVariableFn.MetricNamespaceQuery.withSubscription(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj grafanaTemplateVariableFn.ResourceGroupsQuery + + +##### fn grafanaTemplateVariableFn.ResourceGroupsQuery.withKind + +```jsonnet +grafanaTemplateVariableFn.ResourceGroupsQuery.withKind(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"ResourceGroupsQuery"` + + +##### fn grafanaTemplateVariableFn.ResourceGroupsQuery.withRawQuery + +```jsonnet +grafanaTemplateVariableFn.ResourceGroupsQuery.withRawQuery(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn grafanaTemplateVariableFn.ResourceGroupsQuery.withSubscription + +```jsonnet +grafanaTemplateVariableFn.ResourceGroupsQuery.withSubscription(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj grafanaTemplateVariableFn.ResourceNamesQuery + + +##### fn grafanaTemplateVariableFn.ResourceNamesQuery.withKind + +```jsonnet +grafanaTemplateVariableFn.ResourceNamesQuery.withKind(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"ResourceNamesQuery"` + + +##### fn grafanaTemplateVariableFn.ResourceNamesQuery.withMetricNamespace + +```jsonnet +grafanaTemplateVariableFn.ResourceNamesQuery.withMetricNamespace(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn grafanaTemplateVariableFn.ResourceNamesQuery.withRawQuery + +```jsonnet +grafanaTemplateVariableFn.ResourceNamesQuery.withRawQuery(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn grafanaTemplateVariableFn.ResourceNamesQuery.withResourceGroup + +```jsonnet +grafanaTemplateVariableFn.ResourceNamesQuery.withResourceGroup(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn grafanaTemplateVariableFn.ResourceNamesQuery.withSubscription + +```jsonnet +grafanaTemplateVariableFn.ResourceNamesQuery.withSubscription(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj grafanaTemplateVariableFn.SubscriptionsQuery + + +##### fn grafanaTemplateVariableFn.SubscriptionsQuery.withKind + +```jsonnet +grafanaTemplateVariableFn.SubscriptionsQuery.withKind(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"SubscriptionsQuery"` + + +##### fn grafanaTemplateVariableFn.SubscriptionsQuery.withRawQuery + +```jsonnet +grafanaTemplateVariableFn.SubscriptionsQuery.withRawQuery(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj grafanaTemplateVariableFn.UnknownQuery + + +##### fn grafanaTemplateVariableFn.UnknownQuery.withKind + +```jsonnet +grafanaTemplateVariableFn.UnknownQuery.withKind(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"UnknownQuery"` + + +##### fn grafanaTemplateVariableFn.UnknownQuery.withRawQuery + +```jsonnet +grafanaTemplateVariableFn.UnknownQuery.withRawQuery(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj grafanaTemplateVariableFn.WorkspacesQuery + + +##### fn grafanaTemplateVariableFn.WorkspacesQuery.withKind + +```jsonnet +grafanaTemplateVariableFn.WorkspacesQuery.withKind(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"WorkspacesQuery"` + + +##### fn grafanaTemplateVariableFn.WorkspacesQuery.withRawQuery + +```jsonnet +grafanaTemplateVariableFn.WorkspacesQuery.withRawQuery(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn grafanaTemplateVariableFn.WorkspacesQuery.withSubscription + +```jsonnet +grafanaTemplateVariableFn.WorkspacesQuery.withSubscription(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/cloudWatch/CloudWatchLogsQuery/logGroups.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/cloudWatch/CloudWatchLogsQuery/logGroups.md new file mode 100644 index 0000000000..a59d7777be --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/cloudWatch/CloudWatchLogsQuery/logGroups.md @@ -0,0 +1,57 @@ +# logGroups + + + +## Index + +* [`fn withAccountId(value)`](#fn-withaccountid) +* [`fn withAccountLabel(value)`](#fn-withaccountlabel) +* [`fn withArn(value)`](#fn-witharn) +* [`fn withName(value)`](#fn-withname) + +## Fields + +### fn withAccountId + +```jsonnet +withAccountId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +AccountId of the log group +### fn withAccountLabel + +```jsonnet +withAccountLabel(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Label of the log group +### fn withArn + +```jsonnet +withArn(value) +``` + +PARAMETERS: + +* **value** (`string`) + +ARN of the log group +### fn withName + +```jsonnet +withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of the log group \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/cloudWatch/CloudWatchMetricsQuery/sql/from/QueryEditorFunctionExpression/parameters.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/cloudWatch/CloudWatchMetricsQuery/sql/from/QueryEditorFunctionExpression/parameters.md new file mode 100644 index 0000000000..a7f0402012 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/cloudWatch/CloudWatchMetricsQuery/sql/from/QueryEditorFunctionExpression/parameters.md @@ -0,0 +1,32 @@ +# parameters + + + +## Index + +* [`fn withName(value)`](#fn-withname) +* [`fn withType(value)`](#fn-withtype) + +## Fields + +### fn withName + +```jsonnet +withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withType + +```jsonnet +withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/cloudWatch/CloudWatchMetricsQuery/sql/orderBy/parameters.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/cloudWatch/CloudWatchMetricsQuery/sql/orderBy/parameters.md new file mode 100644 index 0000000000..a7f0402012 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/cloudWatch/CloudWatchMetricsQuery/sql/orderBy/parameters.md @@ -0,0 +1,32 @@ +# parameters + + + +## Index + +* [`fn withName(value)`](#fn-withname) +* [`fn withType(value)`](#fn-withtype) + +## Fields + +### fn withName + +```jsonnet +withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withType + +```jsonnet +withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/cloudWatch/CloudWatchMetricsQuery/sql/select/parameters.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/cloudWatch/CloudWatchMetricsQuery/sql/select/parameters.md new file mode 100644 index 0000000000..a7f0402012 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/cloudWatch/CloudWatchMetricsQuery/sql/select/parameters.md @@ -0,0 +1,32 @@ +# parameters + + + +## Index + +* [`fn withName(value)`](#fn-withname) +* [`fn withType(value)`](#fn-withtype) + +## Fields + +### fn withName + +```jsonnet +withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withType + +```jsonnet +withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/cloudWatch/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/cloudWatch/index.md new file mode 100644 index 0000000000..36cc721989 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/cloudWatch/index.md @@ -0,0 +1,1272 @@ +# cloudWatch + +grafonnet.query.cloudWatch + +## Subpackages + +* [CloudWatchLogsQuery.logGroups](CloudWatchLogsQuery/logGroups.md) +* [CloudWatchMetricsQuery.sql.from.QueryEditorFunctionExpression.parameters](CloudWatchMetricsQuery/sql/from/QueryEditorFunctionExpression/parameters.md) +* [CloudWatchMetricsQuery.sql.orderBy.parameters](CloudWatchMetricsQuery/sql/orderBy/parameters.md) +* [CloudWatchMetricsQuery.sql.select.parameters](CloudWatchMetricsQuery/sql/select/parameters.md) + +## Index + +* [`obj CloudWatchAnnotationQuery`](#obj-cloudwatchannotationquery) + * [`fn withAccountId(value)`](#fn-cloudwatchannotationquerywithaccountid) + * [`fn withActionPrefix(value)`](#fn-cloudwatchannotationquerywithactionprefix) + * [`fn withAlarmNamePrefix(value)`](#fn-cloudwatchannotationquerywithalarmnameprefix) + * [`fn withDatasource(value)`](#fn-cloudwatchannotationquerywithdatasource) + * [`fn withDimensions(value)`](#fn-cloudwatchannotationquerywithdimensions) + * [`fn withDimensionsMixin(value)`](#fn-cloudwatchannotationquerywithdimensionsmixin) + * [`fn withHide(value=true)`](#fn-cloudwatchannotationquerywithhide) + * [`fn withMatchExact(value=true)`](#fn-cloudwatchannotationquerywithmatchexact) + * [`fn withMetricName(value)`](#fn-cloudwatchannotationquerywithmetricname) + * [`fn withNamespace(value)`](#fn-cloudwatchannotationquerywithnamespace) + * [`fn withPeriod(value)`](#fn-cloudwatchannotationquerywithperiod) + * [`fn withPrefixMatching(value=true)`](#fn-cloudwatchannotationquerywithprefixmatching) + * [`fn withQueryMode(value)`](#fn-cloudwatchannotationquerywithquerymode) + * [`fn withQueryType(value)`](#fn-cloudwatchannotationquerywithquerytype) + * [`fn withRefId(value)`](#fn-cloudwatchannotationquerywithrefid) + * [`fn withRegion(value)`](#fn-cloudwatchannotationquerywithregion) + * [`fn withStatistic(value)`](#fn-cloudwatchannotationquerywithstatistic) + * [`fn withStatistics(value)`](#fn-cloudwatchannotationquerywithstatistics) + * [`fn withStatisticsMixin(value)`](#fn-cloudwatchannotationquerywithstatisticsmixin) +* [`obj CloudWatchLogsQuery`](#obj-cloudwatchlogsquery) + * [`fn withDatasource(value)`](#fn-cloudwatchlogsquerywithdatasource) + * [`fn withExpression(value)`](#fn-cloudwatchlogsquerywithexpression) + * [`fn withHide(value=true)`](#fn-cloudwatchlogsquerywithhide) + * [`fn withId(value)`](#fn-cloudwatchlogsquerywithid) + * [`fn withLogGroupNames(value)`](#fn-cloudwatchlogsquerywithloggroupnames) + * [`fn withLogGroupNamesMixin(value)`](#fn-cloudwatchlogsquerywithloggroupnamesmixin) + * [`fn withLogGroups(value)`](#fn-cloudwatchlogsquerywithloggroups) + * [`fn withLogGroupsMixin(value)`](#fn-cloudwatchlogsquerywithloggroupsmixin) + * [`fn withQueryMode(value)`](#fn-cloudwatchlogsquerywithquerymode) + * [`fn withQueryType(value)`](#fn-cloudwatchlogsquerywithquerytype) + * [`fn withRefId(value)`](#fn-cloudwatchlogsquerywithrefid) + * [`fn withRegion(value)`](#fn-cloudwatchlogsquerywithregion) + * [`fn withStatsGroups(value)`](#fn-cloudwatchlogsquerywithstatsgroups) + * [`fn withStatsGroupsMixin(value)`](#fn-cloudwatchlogsquerywithstatsgroupsmixin) +* [`obj CloudWatchMetricsQuery`](#obj-cloudwatchmetricsquery) + * [`fn withAccountId(value)`](#fn-cloudwatchmetricsquerywithaccountid) + * [`fn withAlias(value)`](#fn-cloudwatchmetricsquerywithalias) + * [`fn withDatasource(value)`](#fn-cloudwatchmetricsquerywithdatasource) + * [`fn withDimensions(value)`](#fn-cloudwatchmetricsquerywithdimensions) + * [`fn withDimensionsMixin(value)`](#fn-cloudwatchmetricsquerywithdimensionsmixin) + * [`fn withExpression(value)`](#fn-cloudwatchmetricsquerywithexpression) + * [`fn withHide(value=true)`](#fn-cloudwatchmetricsquerywithhide) + * [`fn withId(value)`](#fn-cloudwatchmetricsquerywithid) + * [`fn withLabel(value)`](#fn-cloudwatchmetricsquerywithlabel) + * [`fn withMatchExact(value=true)`](#fn-cloudwatchmetricsquerywithmatchexact) + * [`fn withMetricEditorMode(value)`](#fn-cloudwatchmetricsquerywithmetriceditormode) + * [`fn withMetricName(value)`](#fn-cloudwatchmetricsquerywithmetricname) + * [`fn withMetricQueryType(value)`](#fn-cloudwatchmetricsquerywithmetricquerytype) + * [`fn withNamespace(value)`](#fn-cloudwatchmetricsquerywithnamespace) + * [`fn withPeriod(value)`](#fn-cloudwatchmetricsquerywithperiod) + * [`fn withQueryMode(value)`](#fn-cloudwatchmetricsquerywithquerymode) + * [`fn withQueryType(value)`](#fn-cloudwatchmetricsquerywithquerytype) + * [`fn withRefId(value)`](#fn-cloudwatchmetricsquerywithrefid) + * [`fn withRegion(value)`](#fn-cloudwatchmetricsquerywithregion) + * [`fn withSql(value)`](#fn-cloudwatchmetricsquerywithsql) + * [`fn withSqlExpression(value)`](#fn-cloudwatchmetricsquerywithsqlexpression) + * [`fn withSqlMixin(value)`](#fn-cloudwatchmetricsquerywithsqlmixin) + * [`fn withStatistic(value)`](#fn-cloudwatchmetricsquerywithstatistic) + * [`fn withStatistics(value)`](#fn-cloudwatchmetricsquerywithstatistics) + * [`fn withStatisticsMixin(value)`](#fn-cloudwatchmetricsquerywithstatisticsmixin) + * [`obj sql`](#obj-cloudwatchmetricsquerysql) + * [`fn withFrom(value)`](#fn-cloudwatchmetricsquerysqlwithfrom) + * [`fn withFromMixin(value)`](#fn-cloudwatchmetricsquerysqlwithfrommixin) + * [`fn withGroupBy(value)`](#fn-cloudwatchmetricsquerysqlwithgroupby) + * [`fn withGroupByMixin(value)`](#fn-cloudwatchmetricsquerysqlwithgroupbymixin) + * [`fn withLimit(value)`](#fn-cloudwatchmetricsquerysqlwithlimit) + * [`fn withOrderBy(value)`](#fn-cloudwatchmetricsquerysqlwithorderby) + * [`fn withOrderByDirection(value)`](#fn-cloudwatchmetricsquerysqlwithorderbydirection) + * [`fn withOrderByMixin(value)`](#fn-cloudwatchmetricsquerysqlwithorderbymixin) + * [`fn withSelect(value)`](#fn-cloudwatchmetricsquerysqlwithselect) + * [`fn withSelectMixin(value)`](#fn-cloudwatchmetricsquerysqlwithselectmixin) + * [`fn withWhere(value)`](#fn-cloudwatchmetricsquerysqlwithwhere) + * [`fn withWhereMixin(value)`](#fn-cloudwatchmetricsquerysqlwithwheremixin) + * [`obj from`](#obj-cloudwatchmetricsquerysqlfrom) + * [`fn withQueryEditorFunctionExpression(value)`](#fn-cloudwatchmetricsquerysqlfromwithqueryeditorfunctionexpression) + * [`fn withQueryEditorFunctionExpressionMixin(value)`](#fn-cloudwatchmetricsquerysqlfromwithqueryeditorfunctionexpressionmixin) + * [`fn withQueryEditorPropertyExpression(value)`](#fn-cloudwatchmetricsquerysqlfromwithqueryeditorpropertyexpression) + * [`fn withQueryEditorPropertyExpressionMixin(value)`](#fn-cloudwatchmetricsquerysqlfromwithqueryeditorpropertyexpressionmixin) + * [`obj QueryEditorFunctionExpression`](#obj-cloudwatchmetricsquerysqlfromqueryeditorfunctionexpression) + * [`fn withName(value)`](#fn-cloudwatchmetricsquerysqlfromqueryeditorfunctionexpressionwithname) + * [`fn withParameters(value)`](#fn-cloudwatchmetricsquerysqlfromqueryeditorfunctionexpressionwithparameters) + * [`fn withParametersMixin(value)`](#fn-cloudwatchmetricsquerysqlfromqueryeditorfunctionexpressionwithparametersmixin) + * [`fn withType(value)`](#fn-cloudwatchmetricsquerysqlfromqueryeditorfunctionexpressionwithtype) + * [`obj QueryEditorPropertyExpression`](#obj-cloudwatchmetricsquerysqlfromqueryeditorpropertyexpression) + * [`fn withProperty(value)`](#fn-cloudwatchmetricsquerysqlfromqueryeditorpropertyexpressionwithproperty) + * [`fn withPropertyMixin(value)`](#fn-cloudwatchmetricsquerysqlfromqueryeditorpropertyexpressionwithpropertymixin) + * [`fn withType(value)`](#fn-cloudwatchmetricsquerysqlfromqueryeditorpropertyexpressionwithtype) + * [`obj property`](#obj-cloudwatchmetricsquerysqlfromqueryeditorpropertyexpressionproperty) + * [`fn withName(value)`](#fn-cloudwatchmetricsquerysqlfromqueryeditorpropertyexpressionpropertywithname) + * [`fn withType(value)`](#fn-cloudwatchmetricsquerysqlfromqueryeditorpropertyexpressionpropertywithtype) + * [`obj groupBy`](#obj-cloudwatchmetricsquerysqlgroupby) + * [`fn withExpressions(value)`](#fn-cloudwatchmetricsquerysqlgroupbywithexpressions) + * [`fn withExpressionsMixin(value)`](#fn-cloudwatchmetricsquerysqlgroupbywithexpressionsmixin) + * [`fn withType(value)`](#fn-cloudwatchmetricsquerysqlgroupbywithtype) + * [`obj orderBy`](#obj-cloudwatchmetricsquerysqlorderby) + * [`fn withName(value)`](#fn-cloudwatchmetricsquerysqlorderbywithname) + * [`fn withParameters(value)`](#fn-cloudwatchmetricsquerysqlorderbywithparameters) + * [`fn withParametersMixin(value)`](#fn-cloudwatchmetricsquerysqlorderbywithparametersmixin) + * [`fn withType(value)`](#fn-cloudwatchmetricsquerysqlorderbywithtype) + * [`obj select`](#obj-cloudwatchmetricsquerysqlselect) + * [`fn withName(value)`](#fn-cloudwatchmetricsquerysqlselectwithname) + * [`fn withParameters(value)`](#fn-cloudwatchmetricsquerysqlselectwithparameters) + * [`fn withParametersMixin(value)`](#fn-cloudwatchmetricsquerysqlselectwithparametersmixin) + * [`fn withType(value)`](#fn-cloudwatchmetricsquerysqlselectwithtype) + * [`obj where`](#obj-cloudwatchmetricsquerysqlwhere) + * [`fn withExpressions(value)`](#fn-cloudwatchmetricsquerysqlwherewithexpressions) + * [`fn withExpressionsMixin(value)`](#fn-cloudwatchmetricsquerysqlwherewithexpressionsmixin) + * [`fn withType(value)`](#fn-cloudwatchmetricsquerysqlwherewithtype) + +## Fields + +### obj CloudWatchAnnotationQuery + + +#### fn CloudWatchAnnotationQuery.withAccountId + +```jsonnet +CloudWatchAnnotationQuery.withAccountId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The ID of the AWS account to query for the metric, specifying `all` will query all accounts that the monitoring account is permitted to query. +#### fn CloudWatchAnnotationQuery.withActionPrefix + +```jsonnet +CloudWatchAnnotationQuery.withActionPrefix(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Use this parameter to filter the results of the operation to only those alarms +that use a certain alarm action. For example, you could specify the ARN of +an SNS topic to find all alarms that send notifications to that topic. +e.g. `arn:aws:sns:us-east-1:123456789012:my-app-` would match `arn:aws:sns:us-east-1:123456789012:my-app-action` +but not match `arn:aws:sns:us-east-1:123456789012:your-app-action` +#### fn CloudWatchAnnotationQuery.withAlarmNamePrefix + +```jsonnet +CloudWatchAnnotationQuery.withAlarmNamePrefix(value) +``` + +PARAMETERS: + +* **value** (`string`) + +An alarm name prefix. If you specify this parameter, you receive information +about all alarms that have names that start with this prefix. +e.g. `my-team-service-` would match `my-team-service-high-cpu` but not match `your-team-service-high-cpu` +#### fn CloudWatchAnnotationQuery.withDatasource + +```jsonnet +CloudWatchAnnotationQuery.withDatasource(value) +``` + +PARAMETERS: + +* **value** (`string`) + +For mixed data sources the selected datasource is on the query level. +For non mixed scenarios this is undefined. +TODO find a better way to do this ^ that's friendly to schema +TODO this shouldn't be unknown but DataSourceRef | null +#### fn CloudWatchAnnotationQuery.withDimensions + +```jsonnet +CloudWatchAnnotationQuery.withDimensions(value) +``` + +PARAMETERS: + +* **value** (`object`) + +A name/value pair that is part of the identity of a metric. For example, you can get statistics for a specific EC2 instance by specifying the InstanceId dimension when you search for metrics. +#### fn CloudWatchAnnotationQuery.withDimensionsMixin + +```jsonnet +CloudWatchAnnotationQuery.withDimensionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +A name/value pair that is part of the identity of a metric. For example, you can get statistics for a specific EC2 instance by specifying the InstanceId dimension when you search for metrics. +#### fn CloudWatchAnnotationQuery.withHide + +```jsonnet +CloudWatchAnnotationQuery.withHide(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +true if query is disabled (ie should not be returned to the dashboard) +Note this does not always imply that the query should not be executed since +the results from a hidden query may be used as the input to other queries (SSE etc) +#### fn CloudWatchAnnotationQuery.withMatchExact + +```jsonnet +CloudWatchAnnotationQuery.withMatchExact(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Only show metrics that exactly match all defined dimension names. +#### fn CloudWatchAnnotationQuery.withMetricName + +```jsonnet +CloudWatchAnnotationQuery.withMetricName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of the metric +#### fn CloudWatchAnnotationQuery.withNamespace + +```jsonnet +CloudWatchAnnotationQuery.withNamespace(value) +``` + +PARAMETERS: + +* **value** (`string`) + +A namespace is a container for CloudWatch metrics. Metrics in different namespaces are isolated from each other, so that metrics from different applications are not mistakenly aggregated into the same statistics. For example, Amazon EC2 uses the AWS/EC2 namespace. +#### fn CloudWatchAnnotationQuery.withPeriod + +```jsonnet +CloudWatchAnnotationQuery.withPeriod(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The length of time associated with a specific Amazon CloudWatch statistic. Can be specified by a number of seconds, 'auto', or as a duration string e.g. '15m' being 15 minutes +#### fn CloudWatchAnnotationQuery.withPrefixMatching + +```jsonnet +CloudWatchAnnotationQuery.withPrefixMatching(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Enable matching on the prefix of the action name or alarm name, specify the prefixes with actionPrefix and/or alarmNamePrefix +#### fn CloudWatchAnnotationQuery.withQueryMode + +```jsonnet +CloudWatchAnnotationQuery.withQueryMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"Metrics"`, `"Logs"`, `"Annotations"` + + +#### fn CloudWatchAnnotationQuery.withQueryType + +```jsonnet +CloudWatchAnnotationQuery.withQueryType(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Specify the query flavor +TODO make this required and give it a default +#### fn CloudWatchAnnotationQuery.withRefId + +```jsonnet +CloudWatchAnnotationQuery.withRefId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +A unique identifier for the query within the list of targets. +In server side expressions, the refId is used as a variable name to identify results. +By default, the UI will assign A->Z; however setting meaningful names may be useful. +#### fn CloudWatchAnnotationQuery.withRegion + +```jsonnet +CloudWatchAnnotationQuery.withRegion(value) +``` + +PARAMETERS: + +* **value** (`string`) + +AWS region to query for the metric +#### fn CloudWatchAnnotationQuery.withStatistic + +```jsonnet +CloudWatchAnnotationQuery.withStatistic(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Metric data aggregations over specified periods of time. For detailed definitions of the statistics supported by CloudWatch, see https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Statistics-definitions.html. +#### fn CloudWatchAnnotationQuery.withStatistics + +```jsonnet +CloudWatchAnnotationQuery.withStatistics(value) +``` + +PARAMETERS: + +* **value** (`array`) + +@deprecated use statistic +#### fn CloudWatchAnnotationQuery.withStatisticsMixin + +```jsonnet +CloudWatchAnnotationQuery.withStatisticsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +@deprecated use statistic +### obj CloudWatchLogsQuery + + +#### fn CloudWatchLogsQuery.withDatasource + +```jsonnet +CloudWatchLogsQuery.withDatasource(value) +``` + +PARAMETERS: + +* **value** (`string`) + +For mixed data sources the selected datasource is on the query level. +For non mixed scenarios this is undefined. +TODO find a better way to do this ^ that's friendly to schema +TODO this shouldn't be unknown but DataSourceRef | null +#### fn CloudWatchLogsQuery.withExpression + +```jsonnet +CloudWatchLogsQuery.withExpression(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The CloudWatch Logs Insights query to execute +#### fn CloudWatchLogsQuery.withHide + +```jsonnet +CloudWatchLogsQuery.withHide(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +true if query is disabled (ie should not be returned to the dashboard) +Note this does not always imply that the query should not be executed since +the results from a hidden query may be used as the input to other queries (SSE etc) +#### fn CloudWatchLogsQuery.withId + +```jsonnet +CloudWatchLogsQuery.withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn CloudWatchLogsQuery.withLogGroupNames + +```jsonnet +CloudWatchLogsQuery.withLogGroupNames(value) +``` + +PARAMETERS: + +* **value** (`array`) + +@deprecated use logGroups +#### fn CloudWatchLogsQuery.withLogGroupNamesMixin + +```jsonnet +CloudWatchLogsQuery.withLogGroupNamesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +@deprecated use logGroups +#### fn CloudWatchLogsQuery.withLogGroups + +```jsonnet +CloudWatchLogsQuery.withLogGroups(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Log groups to query +#### fn CloudWatchLogsQuery.withLogGroupsMixin + +```jsonnet +CloudWatchLogsQuery.withLogGroupsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Log groups to query +#### fn CloudWatchLogsQuery.withQueryMode + +```jsonnet +CloudWatchLogsQuery.withQueryMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"Metrics"`, `"Logs"`, `"Annotations"` + + +#### fn CloudWatchLogsQuery.withQueryType + +```jsonnet +CloudWatchLogsQuery.withQueryType(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Specify the query flavor +TODO make this required and give it a default +#### fn CloudWatchLogsQuery.withRefId + +```jsonnet +CloudWatchLogsQuery.withRefId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +A unique identifier for the query within the list of targets. +In server side expressions, the refId is used as a variable name to identify results. +By default, the UI will assign A->Z; however setting meaningful names may be useful. +#### fn CloudWatchLogsQuery.withRegion + +```jsonnet +CloudWatchLogsQuery.withRegion(value) +``` + +PARAMETERS: + +* **value** (`string`) + +AWS region to query for the logs +#### fn CloudWatchLogsQuery.withStatsGroups + +```jsonnet +CloudWatchLogsQuery.withStatsGroups(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Fields to group the results by, this field is automatically populated whenever the query is updated +#### fn CloudWatchLogsQuery.withStatsGroupsMixin + +```jsonnet +CloudWatchLogsQuery.withStatsGroupsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Fields to group the results by, this field is automatically populated whenever the query is updated +### obj CloudWatchMetricsQuery + + +#### fn CloudWatchMetricsQuery.withAccountId + +```jsonnet +CloudWatchMetricsQuery.withAccountId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The ID of the AWS account to query for the metric, specifying `all` will query all accounts that the monitoring account is permitted to query. +#### fn CloudWatchMetricsQuery.withAlias + +```jsonnet +CloudWatchMetricsQuery.withAlias(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Deprecated: use label +@deprecated use label +#### fn CloudWatchMetricsQuery.withDatasource + +```jsonnet +CloudWatchMetricsQuery.withDatasource(value) +``` + +PARAMETERS: + +* **value** (`string`) + +For mixed data sources the selected datasource is on the query level. +For non mixed scenarios this is undefined. +TODO find a better way to do this ^ that's friendly to schema +TODO this shouldn't be unknown but DataSourceRef | null +#### fn CloudWatchMetricsQuery.withDimensions + +```jsonnet +CloudWatchMetricsQuery.withDimensions(value) +``` + +PARAMETERS: + +* **value** (`object`) + +A name/value pair that is part of the identity of a metric. For example, you can get statistics for a specific EC2 instance by specifying the InstanceId dimension when you search for metrics. +#### fn CloudWatchMetricsQuery.withDimensionsMixin + +```jsonnet +CloudWatchMetricsQuery.withDimensionsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +A name/value pair that is part of the identity of a metric. For example, you can get statistics for a specific EC2 instance by specifying the InstanceId dimension when you search for metrics. +#### fn CloudWatchMetricsQuery.withExpression + +```jsonnet +CloudWatchMetricsQuery.withExpression(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Math expression query +#### fn CloudWatchMetricsQuery.withHide + +```jsonnet +CloudWatchMetricsQuery.withHide(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +true if query is disabled (ie should not be returned to the dashboard) +Note this does not always imply that the query should not be executed since +the results from a hidden query may be used as the input to other queries (SSE etc) +#### fn CloudWatchMetricsQuery.withId + +```jsonnet +CloudWatchMetricsQuery.withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +ID can be used to reference other queries in math expressions. The ID can include numbers, letters, and underscore, and must start with a lowercase letter. +#### fn CloudWatchMetricsQuery.withLabel + +```jsonnet +CloudWatchMetricsQuery.withLabel(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Change the time series legend names using dynamic labels. See https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html for more details. +#### fn CloudWatchMetricsQuery.withMatchExact + +```jsonnet +CloudWatchMetricsQuery.withMatchExact(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Only show metrics that exactly match all defined dimension names. +#### fn CloudWatchMetricsQuery.withMetricEditorMode + +```jsonnet +CloudWatchMetricsQuery.withMetricEditorMode(value) +``` + +PARAMETERS: + +* **value** (`integer`) + - valid values: `0`, `1` + + +#### fn CloudWatchMetricsQuery.withMetricName + +```jsonnet +CloudWatchMetricsQuery.withMetricName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of the metric +#### fn CloudWatchMetricsQuery.withMetricQueryType + +```jsonnet +CloudWatchMetricsQuery.withMetricQueryType(value) +``` + +PARAMETERS: + +* **value** (`integer`) + - valid values: `0`, `1` + + +#### fn CloudWatchMetricsQuery.withNamespace + +```jsonnet +CloudWatchMetricsQuery.withNamespace(value) +``` + +PARAMETERS: + +* **value** (`string`) + +A namespace is a container for CloudWatch metrics. Metrics in different namespaces are isolated from each other, so that metrics from different applications are not mistakenly aggregated into the same statistics. For example, Amazon EC2 uses the AWS/EC2 namespace. +#### fn CloudWatchMetricsQuery.withPeriod + +```jsonnet +CloudWatchMetricsQuery.withPeriod(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The length of time associated with a specific Amazon CloudWatch statistic. Can be specified by a number of seconds, 'auto', or as a duration string e.g. '15m' being 15 minutes +#### fn CloudWatchMetricsQuery.withQueryMode + +```jsonnet +CloudWatchMetricsQuery.withQueryMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"Metrics"`, `"Logs"`, `"Annotations"` + + +#### fn CloudWatchMetricsQuery.withQueryType + +```jsonnet +CloudWatchMetricsQuery.withQueryType(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Specify the query flavor +TODO make this required and give it a default +#### fn CloudWatchMetricsQuery.withRefId + +```jsonnet +CloudWatchMetricsQuery.withRefId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +A unique identifier for the query within the list of targets. +In server side expressions, the refId is used as a variable name to identify results. +By default, the UI will assign A->Z; however setting meaningful names may be useful. +#### fn CloudWatchMetricsQuery.withRegion + +```jsonnet +CloudWatchMetricsQuery.withRegion(value) +``` + +PARAMETERS: + +* **value** (`string`) + +AWS region to query for the metric +#### fn CloudWatchMetricsQuery.withSql + +```jsonnet +CloudWatchMetricsQuery.withSql(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn CloudWatchMetricsQuery.withSqlExpression + +```jsonnet +CloudWatchMetricsQuery.withSqlExpression(value) +``` + +PARAMETERS: + +* **value** (`string`) + +When the metric query type is `metricQueryType` is set to `Query`, this field is used to specify the query string. +#### fn CloudWatchMetricsQuery.withSqlMixin + +```jsonnet +CloudWatchMetricsQuery.withSqlMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn CloudWatchMetricsQuery.withStatistic + +```jsonnet +CloudWatchMetricsQuery.withStatistic(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Metric data aggregations over specified periods of time. For detailed definitions of the statistics supported by CloudWatch, see https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Statistics-definitions.html. +#### fn CloudWatchMetricsQuery.withStatistics + +```jsonnet +CloudWatchMetricsQuery.withStatistics(value) +``` + +PARAMETERS: + +* **value** (`array`) + +@deprecated use statistic +#### fn CloudWatchMetricsQuery.withStatisticsMixin + +```jsonnet +CloudWatchMetricsQuery.withStatisticsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +@deprecated use statistic +#### obj CloudWatchMetricsQuery.sql + + +##### fn CloudWatchMetricsQuery.sql.withFrom + +```jsonnet +CloudWatchMetricsQuery.sql.withFrom(value) +``` + +PARAMETERS: + +* **value** (`object`) + +FROM part of the SQL expression +##### fn CloudWatchMetricsQuery.sql.withFromMixin + +```jsonnet +CloudWatchMetricsQuery.sql.withFromMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +FROM part of the SQL expression +##### fn CloudWatchMetricsQuery.sql.withGroupBy + +```jsonnet +CloudWatchMetricsQuery.sql.withGroupBy(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn CloudWatchMetricsQuery.sql.withGroupByMixin + +```jsonnet +CloudWatchMetricsQuery.sql.withGroupByMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn CloudWatchMetricsQuery.sql.withLimit + +```jsonnet +CloudWatchMetricsQuery.sql.withLimit(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +LIMIT part of the SQL expression +##### fn CloudWatchMetricsQuery.sql.withOrderBy + +```jsonnet +CloudWatchMetricsQuery.sql.withOrderBy(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn CloudWatchMetricsQuery.sql.withOrderByDirection + +```jsonnet +CloudWatchMetricsQuery.sql.withOrderByDirection(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The sort order of the SQL expression, `ASC` or `DESC` +##### fn CloudWatchMetricsQuery.sql.withOrderByMixin + +```jsonnet +CloudWatchMetricsQuery.sql.withOrderByMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn CloudWatchMetricsQuery.sql.withSelect + +```jsonnet +CloudWatchMetricsQuery.sql.withSelect(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn CloudWatchMetricsQuery.sql.withSelectMixin + +```jsonnet +CloudWatchMetricsQuery.sql.withSelectMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn CloudWatchMetricsQuery.sql.withWhere + +```jsonnet +CloudWatchMetricsQuery.sql.withWhere(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn CloudWatchMetricsQuery.sql.withWhereMixin + +```jsonnet +CloudWatchMetricsQuery.sql.withWhereMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### obj CloudWatchMetricsQuery.sql.from + + +###### fn CloudWatchMetricsQuery.sql.from.withQueryEditorFunctionExpression + +```jsonnet +CloudWatchMetricsQuery.sql.from.withQueryEditorFunctionExpression(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +###### fn CloudWatchMetricsQuery.sql.from.withQueryEditorFunctionExpressionMixin + +```jsonnet +CloudWatchMetricsQuery.sql.from.withQueryEditorFunctionExpressionMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +###### fn CloudWatchMetricsQuery.sql.from.withQueryEditorPropertyExpression + +```jsonnet +CloudWatchMetricsQuery.sql.from.withQueryEditorPropertyExpression(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +###### fn CloudWatchMetricsQuery.sql.from.withQueryEditorPropertyExpressionMixin + +```jsonnet +CloudWatchMetricsQuery.sql.from.withQueryEditorPropertyExpressionMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +###### obj CloudWatchMetricsQuery.sql.from.QueryEditorFunctionExpression + + +####### fn CloudWatchMetricsQuery.sql.from.QueryEditorFunctionExpression.withName + +```jsonnet +CloudWatchMetricsQuery.sql.from.QueryEditorFunctionExpression.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +####### fn CloudWatchMetricsQuery.sql.from.QueryEditorFunctionExpression.withParameters + +```jsonnet +CloudWatchMetricsQuery.sql.from.QueryEditorFunctionExpression.withParameters(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +####### fn CloudWatchMetricsQuery.sql.from.QueryEditorFunctionExpression.withParametersMixin + +```jsonnet +CloudWatchMetricsQuery.sql.from.QueryEditorFunctionExpression.withParametersMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +####### fn CloudWatchMetricsQuery.sql.from.QueryEditorFunctionExpression.withType + +```jsonnet +CloudWatchMetricsQuery.sql.from.QueryEditorFunctionExpression.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### obj CloudWatchMetricsQuery.sql.from.QueryEditorPropertyExpression + + +####### fn CloudWatchMetricsQuery.sql.from.QueryEditorPropertyExpression.withProperty + +```jsonnet +CloudWatchMetricsQuery.sql.from.QueryEditorPropertyExpression.withProperty(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +####### fn CloudWatchMetricsQuery.sql.from.QueryEditorPropertyExpression.withPropertyMixin + +```jsonnet +CloudWatchMetricsQuery.sql.from.QueryEditorPropertyExpression.withPropertyMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +####### fn CloudWatchMetricsQuery.sql.from.QueryEditorPropertyExpression.withType + +```jsonnet +CloudWatchMetricsQuery.sql.from.QueryEditorPropertyExpression.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +####### obj CloudWatchMetricsQuery.sql.from.QueryEditorPropertyExpression.property + + +######## fn CloudWatchMetricsQuery.sql.from.QueryEditorPropertyExpression.property.withName + +```jsonnet +CloudWatchMetricsQuery.sql.from.QueryEditorPropertyExpression.property.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +######## fn CloudWatchMetricsQuery.sql.from.QueryEditorPropertyExpression.property.withType + +```jsonnet +CloudWatchMetricsQuery.sql.from.QueryEditorPropertyExpression.property.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"string"` + + +##### obj CloudWatchMetricsQuery.sql.groupBy + + +###### fn CloudWatchMetricsQuery.sql.groupBy.withExpressions + +```jsonnet +CloudWatchMetricsQuery.sql.groupBy.withExpressions(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +###### fn CloudWatchMetricsQuery.sql.groupBy.withExpressionsMixin + +```jsonnet +CloudWatchMetricsQuery.sql.groupBy.withExpressionsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +###### fn CloudWatchMetricsQuery.sql.groupBy.withType + +```jsonnet +CloudWatchMetricsQuery.sql.groupBy.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"and"`, `"or"` + + +##### obj CloudWatchMetricsQuery.sql.orderBy + + +###### fn CloudWatchMetricsQuery.sql.orderBy.withName + +```jsonnet +CloudWatchMetricsQuery.sql.orderBy.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn CloudWatchMetricsQuery.sql.orderBy.withParameters + +```jsonnet +CloudWatchMetricsQuery.sql.orderBy.withParameters(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +###### fn CloudWatchMetricsQuery.sql.orderBy.withParametersMixin + +```jsonnet +CloudWatchMetricsQuery.sql.orderBy.withParametersMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +###### fn CloudWatchMetricsQuery.sql.orderBy.withType + +```jsonnet +CloudWatchMetricsQuery.sql.orderBy.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### obj CloudWatchMetricsQuery.sql.select + + +###### fn CloudWatchMetricsQuery.sql.select.withName + +```jsonnet +CloudWatchMetricsQuery.sql.select.withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn CloudWatchMetricsQuery.sql.select.withParameters + +```jsonnet +CloudWatchMetricsQuery.sql.select.withParameters(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +###### fn CloudWatchMetricsQuery.sql.select.withParametersMixin + +```jsonnet +CloudWatchMetricsQuery.sql.select.withParametersMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +###### fn CloudWatchMetricsQuery.sql.select.withType + +```jsonnet +CloudWatchMetricsQuery.sql.select.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### obj CloudWatchMetricsQuery.sql.where + + +###### fn CloudWatchMetricsQuery.sql.where.withExpressions + +```jsonnet +CloudWatchMetricsQuery.sql.where.withExpressions(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +###### fn CloudWatchMetricsQuery.sql.where.withExpressionsMixin + +```jsonnet +CloudWatchMetricsQuery.sql.where.withExpressionsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +###### fn CloudWatchMetricsQuery.sql.where.withType + +```jsonnet +CloudWatchMetricsQuery.sql.where.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"and"`, `"or"` + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/elasticsearch/bucketAggs/Filters/settings/filters.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/elasticsearch/bucketAggs/Filters/settings/filters.md new file mode 100644 index 0000000000..34d28192c5 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/elasticsearch/bucketAggs/Filters/settings/filters.md @@ -0,0 +1,32 @@ +# filters + + + +## Index + +* [`fn withLabel(value)`](#fn-withlabel) +* [`fn withQuery(value)`](#fn-withquery) + +## Fields + +### fn withLabel + +```jsonnet +withLabel(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withQuery + +```jsonnet +withQuery(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/elasticsearch/bucketAggs/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/elasticsearch/bucketAggs/index.md new file mode 100644 index 0000000000..07316dbca1 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/elasticsearch/bucketAggs/index.md @@ -0,0 +1,585 @@ +# bucketAggs + + + +## Subpackages + +* [Filters.settings.filters](Filters/settings/filters.md) + +## Index + +* [`obj DateHistogram`](#obj-datehistogram) + * [`fn withField(value)`](#fn-datehistogramwithfield) + * [`fn withId(value)`](#fn-datehistogramwithid) + * [`fn withSettings(value)`](#fn-datehistogramwithsettings) + * [`fn withSettingsMixin(value)`](#fn-datehistogramwithsettingsmixin) + * [`fn withType(value)`](#fn-datehistogramwithtype) + * [`obj settings`](#obj-datehistogramsettings) + * [`fn withInterval(value)`](#fn-datehistogramsettingswithinterval) + * [`fn withMinDocCount(value)`](#fn-datehistogramsettingswithmindoccount) + * [`fn withOffset(value)`](#fn-datehistogramsettingswithoffset) + * [`fn withTimeZone(value)`](#fn-datehistogramsettingswithtimezone) + * [`fn withTrimEdges(value)`](#fn-datehistogramsettingswithtrimedges) +* [`obj Filters`](#obj-filters) + * [`fn withId(value)`](#fn-filterswithid) + * [`fn withSettings(value)`](#fn-filterswithsettings) + * [`fn withSettingsMixin(value)`](#fn-filterswithsettingsmixin) + * [`fn withType(value)`](#fn-filterswithtype) + * [`obj settings`](#obj-filterssettings) + * [`fn withFilters(value)`](#fn-filterssettingswithfilters) + * [`fn withFiltersMixin(value)`](#fn-filterssettingswithfiltersmixin) +* [`obj GeoHashGrid`](#obj-geohashgrid) + * [`fn withField(value)`](#fn-geohashgridwithfield) + * [`fn withId(value)`](#fn-geohashgridwithid) + * [`fn withSettings(value)`](#fn-geohashgridwithsettings) + * [`fn withSettingsMixin(value)`](#fn-geohashgridwithsettingsmixin) + * [`fn withType(value)`](#fn-geohashgridwithtype) + * [`obj settings`](#obj-geohashgridsettings) + * [`fn withPrecision(value)`](#fn-geohashgridsettingswithprecision) +* [`obj Histogram`](#obj-histogram) + * [`fn withField(value)`](#fn-histogramwithfield) + * [`fn withId(value)`](#fn-histogramwithid) + * [`fn withSettings(value)`](#fn-histogramwithsettings) + * [`fn withSettingsMixin(value)`](#fn-histogramwithsettingsmixin) + * [`fn withType(value)`](#fn-histogramwithtype) + * [`obj settings`](#obj-histogramsettings) + * [`fn withInterval(value)`](#fn-histogramsettingswithinterval) + * [`fn withMinDocCount(value)`](#fn-histogramsettingswithmindoccount) +* [`obj Nested`](#obj-nested) + * [`fn withField(value)`](#fn-nestedwithfield) + * [`fn withId(value)`](#fn-nestedwithid) + * [`fn withSettings(value)`](#fn-nestedwithsettings) + * [`fn withSettingsMixin(value)`](#fn-nestedwithsettingsmixin) + * [`fn withType(value)`](#fn-nestedwithtype) +* [`obj Terms`](#obj-terms) + * [`fn withField(value)`](#fn-termswithfield) + * [`fn withId(value)`](#fn-termswithid) + * [`fn withSettings(value)`](#fn-termswithsettings) + * [`fn withSettingsMixin(value)`](#fn-termswithsettingsmixin) + * [`fn withType(value)`](#fn-termswithtype) + * [`obj settings`](#obj-termssettings) + * [`fn withMinDocCount(value)`](#fn-termssettingswithmindoccount) + * [`fn withMissing(value)`](#fn-termssettingswithmissing) + * [`fn withOrder(value)`](#fn-termssettingswithorder) + * [`fn withOrderBy(value)`](#fn-termssettingswithorderby) + * [`fn withSize(value)`](#fn-termssettingswithsize) + +## Fields + +### obj DateHistogram + + +#### fn DateHistogram.withField + +```jsonnet +DateHistogram.withField(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn DateHistogram.withId + +```jsonnet +DateHistogram.withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn DateHistogram.withSettings + +```jsonnet +DateHistogram.withSettings(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn DateHistogram.withSettingsMixin + +```jsonnet +DateHistogram.withSettingsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn DateHistogram.withType + +```jsonnet +DateHistogram.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj DateHistogram.settings + + +##### fn DateHistogram.settings.withInterval + +```jsonnet +DateHistogram.settings.withInterval(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn DateHistogram.settings.withMinDocCount + +```jsonnet +DateHistogram.settings.withMinDocCount(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn DateHistogram.settings.withOffset + +```jsonnet +DateHistogram.settings.withOffset(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn DateHistogram.settings.withTimeZone + +```jsonnet +DateHistogram.settings.withTimeZone(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn DateHistogram.settings.withTrimEdges + +```jsonnet +DateHistogram.settings.withTrimEdges(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj Filters + + +#### fn Filters.withId + +```jsonnet +Filters.withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn Filters.withSettings + +```jsonnet +Filters.withSettings(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn Filters.withSettingsMixin + +```jsonnet +Filters.withSettingsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn Filters.withType + +```jsonnet +Filters.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj Filters.settings + + +##### fn Filters.settings.withFilters + +```jsonnet +Filters.settings.withFilters(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +##### fn Filters.settings.withFiltersMixin + +```jsonnet +Filters.settings.withFiltersMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### obj GeoHashGrid + + +#### fn GeoHashGrid.withField + +```jsonnet +GeoHashGrid.withField(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn GeoHashGrid.withId + +```jsonnet +GeoHashGrid.withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn GeoHashGrid.withSettings + +```jsonnet +GeoHashGrid.withSettings(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn GeoHashGrid.withSettingsMixin + +```jsonnet +GeoHashGrid.withSettingsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn GeoHashGrid.withType + +```jsonnet +GeoHashGrid.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj GeoHashGrid.settings + + +##### fn GeoHashGrid.settings.withPrecision + +```jsonnet +GeoHashGrid.settings.withPrecision(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj Histogram + + +#### fn Histogram.withField + +```jsonnet +Histogram.withField(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn Histogram.withId + +```jsonnet +Histogram.withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn Histogram.withSettings + +```jsonnet +Histogram.withSettings(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn Histogram.withSettingsMixin + +```jsonnet +Histogram.withSettingsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn Histogram.withType + +```jsonnet +Histogram.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj Histogram.settings + + +##### fn Histogram.settings.withInterval + +```jsonnet +Histogram.settings.withInterval(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn Histogram.settings.withMinDocCount + +```jsonnet +Histogram.settings.withMinDocCount(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj Nested + + +#### fn Nested.withField + +```jsonnet +Nested.withField(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn Nested.withId + +```jsonnet +Nested.withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn Nested.withSettings + +```jsonnet +Nested.withSettings(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn Nested.withSettingsMixin + +```jsonnet +Nested.withSettingsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn Nested.withType + +```jsonnet +Nested.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj Terms + + +#### fn Terms.withField + +```jsonnet +Terms.withField(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn Terms.withId + +```jsonnet +Terms.withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn Terms.withSettings + +```jsonnet +Terms.withSettings(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn Terms.withSettingsMixin + +```jsonnet +Terms.withSettingsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn Terms.withType + +```jsonnet +Terms.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj Terms.settings + + +##### fn Terms.settings.withMinDocCount + +```jsonnet +Terms.settings.withMinDocCount(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn Terms.settings.withMissing + +```jsonnet +Terms.settings.withMissing(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn Terms.settings.withOrder + +```jsonnet +Terms.settings.withOrder(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"desc"`, `"asc"` + + +##### fn Terms.settings.withOrderBy + +```jsonnet +Terms.settings.withOrderBy(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn Terms.settings.withSize + +```jsonnet +Terms.settings.withSize(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/elasticsearch/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/elasticsearch/index.md new file mode 100644 index 0000000000..b5926b0b05 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/elasticsearch/index.md @@ -0,0 +1,155 @@ +# elasticsearch + +grafonnet.query.elasticsearch + +## Subpackages + +* [bucketAggs](bucketAggs/index.md) +* [metrics](metrics/index.md) + +## Index + +* [`fn withAlias(value)`](#fn-withalias) +* [`fn withBucketAggs(value)`](#fn-withbucketaggs) +* [`fn withBucketAggsMixin(value)`](#fn-withbucketaggsmixin) +* [`fn withDatasource(value)`](#fn-withdatasource) +* [`fn withHide(value=true)`](#fn-withhide) +* [`fn withMetrics(value)`](#fn-withmetrics) +* [`fn withMetricsMixin(value)`](#fn-withmetricsmixin) +* [`fn withQuery(value)`](#fn-withquery) +* [`fn withQueryType(value)`](#fn-withquerytype) +* [`fn withRefId(value)`](#fn-withrefid) +* [`fn withTimeField(value)`](#fn-withtimefield) + +## Fields + +### fn withAlias + +```jsonnet +withAlias(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Alias pattern +### fn withBucketAggs + +```jsonnet +withBucketAggs(value) +``` + +PARAMETERS: + +* **value** (`array`) + +List of bucket aggregations +### fn withBucketAggsMixin + +```jsonnet +withBucketAggsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +List of bucket aggregations +### fn withDatasource + +```jsonnet +withDatasource(value) +``` + +PARAMETERS: + +* **value** (`string`) + +For mixed data sources the selected datasource is on the query level. +For non mixed scenarios this is undefined. +TODO find a better way to do this ^ that's friendly to schema +TODO this shouldn't be unknown but DataSourceRef | null +### fn withHide + +```jsonnet +withHide(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +true if query is disabled (ie should not be returned to the dashboard) +Note this does not always imply that the query should not be executed since +the results from a hidden query may be used as the input to other queries (SSE etc) +### fn withMetrics + +```jsonnet +withMetrics(value) +``` + +PARAMETERS: + +* **value** (`array`) + +List of metric aggregations +### fn withMetricsMixin + +```jsonnet +withMetricsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +List of metric aggregations +### fn withQuery + +```jsonnet +withQuery(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Lucene query +### fn withQueryType + +```jsonnet +withQueryType(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Specify the query flavor +TODO make this required and give it a default +### fn withRefId + +```jsonnet +withRefId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +A unique identifier for the query within the list of targets. +In server side expressions, the refId is used as a variable name to identify results. +By default, the UI will assign A->Z; however setting meaningful names may be useful. +### fn withTimeField + +```jsonnet +withTimeField(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of time field \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/elasticsearch/metrics/MetricAggregationWithSettings/BucketScript/pipelineVariables.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/elasticsearch/metrics/MetricAggregationWithSettings/BucketScript/pipelineVariables.md new file mode 100644 index 0000000000..98f8952413 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/elasticsearch/metrics/MetricAggregationWithSettings/BucketScript/pipelineVariables.md @@ -0,0 +1,32 @@ +# pipelineVariables + + + +## Index + +* [`fn withName(value)`](#fn-withname) +* [`fn withPipelineAgg(value)`](#fn-withpipelineagg) + +## Fields + +### fn withName + +```jsonnet +withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withPipelineAgg + +```jsonnet +withPipelineAgg(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/elasticsearch/metrics/PipelineMetricAggregation/BucketScript/pipelineVariables.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/elasticsearch/metrics/PipelineMetricAggregation/BucketScript/pipelineVariables.md new file mode 100644 index 0000000000..98f8952413 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/elasticsearch/metrics/PipelineMetricAggregation/BucketScript/pipelineVariables.md @@ -0,0 +1,32 @@ +# pipelineVariables + + + +## Index + +* [`fn withName(value)`](#fn-withname) +* [`fn withPipelineAgg(value)`](#fn-withpipelineagg) + +## Fields + +### fn withName + +```jsonnet +withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withPipelineAgg + +```jsonnet +withPipelineAgg(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/elasticsearch/metrics/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/elasticsearch/metrics/index.md new file mode 100644 index 0000000000..3289312711 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/elasticsearch/metrics/index.md @@ -0,0 +1,2616 @@ +# metrics + + + +## Subpackages + +* [MetricAggregationWithSettings.BucketScript.pipelineVariables](MetricAggregationWithSettings/BucketScript/pipelineVariables.md) +* [PipelineMetricAggregation.BucketScript.pipelineVariables](PipelineMetricAggregation/BucketScript/pipelineVariables.md) + +## Index + +* [`obj Count`](#obj-count) + * [`fn withHide(value=true)`](#fn-countwithhide) + * [`fn withId(value)`](#fn-countwithid) + * [`fn withType(value)`](#fn-countwithtype) +* [`obj MetricAggregationWithSettings`](#obj-metricaggregationwithsettings) + * [`obj Average`](#obj-metricaggregationwithsettingsaverage) + * [`fn withField(value)`](#fn-metricaggregationwithsettingsaveragewithfield) + * [`fn withHide(value=true)`](#fn-metricaggregationwithsettingsaveragewithhide) + * [`fn withId(value)`](#fn-metricaggregationwithsettingsaveragewithid) + * [`fn withSettings(value)`](#fn-metricaggregationwithsettingsaveragewithsettings) + * [`fn withSettingsMixin(value)`](#fn-metricaggregationwithsettingsaveragewithsettingsmixin) + * [`fn withType(value)`](#fn-metricaggregationwithsettingsaveragewithtype) + * [`obj settings`](#obj-metricaggregationwithsettingsaveragesettings) + * [`fn withMissing(value)`](#fn-metricaggregationwithsettingsaveragesettingswithmissing) + * [`fn withScript(value)`](#fn-metricaggregationwithsettingsaveragesettingswithscript) + * [`fn withScriptMixin(value)`](#fn-metricaggregationwithsettingsaveragesettingswithscriptmixin) + * [`obj script`](#obj-metricaggregationwithsettingsaveragesettingsscript) + * [`fn withInline(value)`](#fn-metricaggregationwithsettingsaveragesettingsscriptwithinline) + * [`obj BucketScript`](#obj-metricaggregationwithsettingsbucketscript) + * [`fn withHide(value=true)`](#fn-metricaggregationwithsettingsbucketscriptwithhide) + * [`fn withId(value)`](#fn-metricaggregationwithsettingsbucketscriptwithid) + * [`fn withPipelineVariables(value)`](#fn-metricaggregationwithsettingsbucketscriptwithpipelinevariables) + * [`fn withPipelineVariablesMixin(value)`](#fn-metricaggregationwithsettingsbucketscriptwithpipelinevariablesmixin) + * [`fn withSettings(value)`](#fn-metricaggregationwithsettingsbucketscriptwithsettings) + * [`fn withSettingsMixin(value)`](#fn-metricaggregationwithsettingsbucketscriptwithsettingsmixin) + * [`fn withType(value)`](#fn-metricaggregationwithsettingsbucketscriptwithtype) + * [`obj settings`](#obj-metricaggregationwithsettingsbucketscriptsettings) + * [`fn withScript(value)`](#fn-metricaggregationwithsettingsbucketscriptsettingswithscript) + * [`fn withScriptMixin(value)`](#fn-metricaggregationwithsettingsbucketscriptsettingswithscriptmixin) + * [`obj script`](#obj-metricaggregationwithsettingsbucketscriptsettingsscript) + * [`fn withInline(value)`](#fn-metricaggregationwithsettingsbucketscriptsettingsscriptwithinline) + * [`obj CumulativeSum`](#obj-metricaggregationwithsettingscumulativesum) + * [`fn withField(value)`](#fn-metricaggregationwithsettingscumulativesumwithfield) + * [`fn withHide(value=true)`](#fn-metricaggregationwithsettingscumulativesumwithhide) + * [`fn withId(value)`](#fn-metricaggregationwithsettingscumulativesumwithid) + * [`fn withPipelineAgg(value)`](#fn-metricaggregationwithsettingscumulativesumwithpipelineagg) + * [`fn withSettings(value)`](#fn-metricaggregationwithsettingscumulativesumwithsettings) + * [`fn withSettingsMixin(value)`](#fn-metricaggregationwithsettingscumulativesumwithsettingsmixin) + * [`fn withType(value)`](#fn-metricaggregationwithsettingscumulativesumwithtype) + * [`obj settings`](#obj-metricaggregationwithsettingscumulativesumsettings) + * [`fn withFormat(value)`](#fn-metricaggregationwithsettingscumulativesumsettingswithformat) + * [`obj Derivative`](#obj-metricaggregationwithsettingsderivative) + * [`fn withField(value)`](#fn-metricaggregationwithsettingsderivativewithfield) + * [`fn withHide(value=true)`](#fn-metricaggregationwithsettingsderivativewithhide) + * [`fn withId(value)`](#fn-metricaggregationwithsettingsderivativewithid) + * [`fn withPipelineAgg(value)`](#fn-metricaggregationwithsettingsderivativewithpipelineagg) + * [`fn withSettings(value)`](#fn-metricaggregationwithsettingsderivativewithsettings) + * [`fn withSettingsMixin(value)`](#fn-metricaggregationwithsettingsderivativewithsettingsmixin) + * [`fn withType(value)`](#fn-metricaggregationwithsettingsderivativewithtype) + * [`obj settings`](#obj-metricaggregationwithsettingsderivativesettings) + * [`fn withUnit(value)`](#fn-metricaggregationwithsettingsderivativesettingswithunit) + * [`obj ExtendedStats`](#obj-metricaggregationwithsettingsextendedstats) + * [`fn withField(value)`](#fn-metricaggregationwithsettingsextendedstatswithfield) + * [`fn withHide(value=true)`](#fn-metricaggregationwithsettingsextendedstatswithhide) + * [`fn withId(value)`](#fn-metricaggregationwithsettingsextendedstatswithid) + * [`fn withMeta(value)`](#fn-metricaggregationwithsettingsextendedstatswithmeta) + * [`fn withMetaMixin(value)`](#fn-metricaggregationwithsettingsextendedstatswithmetamixin) + * [`fn withSettings(value)`](#fn-metricaggregationwithsettingsextendedstatswithsettings) + * [`fn withSettingsMixin(value)`](#fn-metricaggregationwithsettingsextendedstatswithsettingsmixin) + * [`fn withType(value)`](#fn-metricaggregationwithsettingsextendedstatswithtype) + * [`obj settings`](#obj-metricaggregationwithsettingsextendedstatssettings) + * [`fn withMissing(value)`](#fn-metricaggregationwithsettingsextendedstatssettingswithmissing) + * [`fn withScript(value)`](#fn-metricaggregationwithsettingsextendedstatssettingswithscript) + * [`fn withScriptMixin(value)`](#fn-metricaggregationwithsettingsextendedstatssettingswithscriptmixin) + * [`fn withSigma(value)`](#fn-metricaggregationwithsettingsextendedstatssettingswithsigma) + * [`obj script`](#obj-metricaggregationwithsettingsextendedstatssettingsscript) + * [`fn withInline(value)`](#fn-metricaggregationwithsettingsextendedstatssettingsscriptwithinline) + * [`obj Logs`](#obj-metricaggregationwithsettingslogs) + * [`fn withHide(value=true)`](#fn-metricaggregationwithsettingslogswithhide) + * [`fn withId(value)`](#fn-metricaggregationwithsettingslogswithid) + * [`fn withSettings(value)`](#fn-metricaggregationwithsettingslogswithsettings) + * [`fn withSettingsMixin(value)`](#fn-metricaggregationwithsettingslogswithsettingsmixin) + * [`fn withType(value)`](#fn-metricaggregationwithsettingslogswithtype) + * [`obj settings`](#obj-metricaggregationwithsettingslogssettings) + * [`fn withLimit(value)`](#fn-metricaggregationwithsettingslogssettingswithlimit) + * [`obj Max`](#obj-metricaggregationwithsettingsmax) + * [`fn withField(value)`](#fn-metricaggregationwithsettingsmaxwithfield) + * [`fn withHide(value=true)`](#fn-metricaggregationwithsettingsmaxwithhide) + * [`fn withId(value)`](#fn-metricaggregationwithsettingsmaxwithid) + * [`fn withSettings(value)`](#fn-metricaggregationwithsettingsmaxwithsettings) + * [`fn withSettingsMixin(value)`](#fn-metricaggregationwithsettingsmaxwithsettingsmixin) + * [`fn withType(value)`](#fn-metricaggregationwithsettingsmaxwithtype) + * [`obj settings`](#obj-metricaggregationwithsettingsmaxsettings) + * [`fn withMissing(value)`](#fn-metricaggregationwithsettingsmaxsettingswithmissing) + * [`fn withScript(value)`](#fn-metricaggregationwithsettingsmaxsettingswithscript) + * [`fn withScriptMixin(value)`](#fn-metricaggregationwithsettingsmaxsettingswithscriptmixin) + * [`obj script`](#obj-metricaggregationwithsettingsmaxsettingsscript) + * [`fn withInline(value)`](#fn-metricaggregationwithsettingsmaxsettingsscriptwithinline) + * [`obj Min`](#obj-metricaggregationwithsettingsmin) + * [`fn withField(value)`](#fn-metricaggregationwithsettingsminwithfield) + * [`fn withHide(value=true)`](#fn-metricaggregationwithsettingsminwithhide) + * [`fn withId(value)`](#fn-metricaggregationwithsettingsminwithid) + * [`fn withSettings(value)`](#fn-metricaggregationwithsettingsminwithsettings) + * [`fn withSettingsMixin(value)`](#fn-metricaggregationwithsettingsminwithsettingsmixin) + * [`fn withType(value)`](#fn-metricaggregationwithsettingsminwithtype) + * [`obj settings`](#obj-metricaggregationwithsettingsminsettings) + * [`fn withMissing(value)`](#fn-metricaggregationwithsettingsminsettingswithmissing) + * [`fn withScript(value)`](#fn-metricaggregationwithsettingsminsettingswithscript) + * [`fn withScriptMixin(value)`](#fn-metricaggregationwithsettingsminsettingswithscriptmixin) + * [`obj script`](#obj-metricaggregationwithsettingsminsettingsscript) + * [`fn withInline(value)`](#fn-metricaggregationwithsettingsminsettingsscriptwithinline) + * [`obj MovingAverage`](#obj-metricaggregationwithsettingsmovingaverage) + * [`fn withField(value)`](#fn-metricaggregationwithsettingsmovingaveragewithfield) + * [`fn withHide(value=true)`](#fn-metricaggregationwithsettingsmovingaveragewithhide) + * [`fn withId(value)`](#fn-metricaggregationwithsettingsmovingaveragewithid) + * [`fn withPipelineAgg(value)`](#fn-metricaggregationwithsettingsmovingaveragewithpipelineagg) + * [`fn withSettings(value)`](#fn-metricaggregationwithsettingsmovingaveragewithsettings) + * [`fn withSettingsMixin(value)`](#fn-metricaggregationwithsettingsmovingaveragewithsettingsmixin) + * [`fn withType(value)`](#fn-metricaggregationwithsettingsmovingaveragewithtype) + * [`obj MovingFunction`](#obj-metricaggregationwithsettingsmovingfunction) + * [`fn withField(value)`](#fn-metricaggregationwithsettingsmovingfunctionwithfield) + * [`fn withHide(value=true)`](#fn-metricaggregationwithsettingsmovingfunctionwithhide) + * [`fn withId(value)`](#fn-metricaggregationwithsettingsmovingfunctionwithid) + * [`fn withPipelineAgg(value)`](#fn-metricaggregationwithsettingsmovingfunctionwithpipelineagg) + * [`fn withSettings(value)`](#fn-metricaggregationwithsettingsmovingfunctionwithsettings) + * [`fn withSettingsMixin(value)`](#fn-metricaggregationwithsettingsmovingfunctionwithsettingsmixin) + * [`fn withType(value)`](#fn-metricaggregationwithsettingsmovingfunctionwithtype) + * [`obj settings`](#obj-metricaggregationwithsettingsmovingfunctionsettings) + * [`fn withScript(value)`](#fn-metricaggregationwithsettingsmovingfunctionsettingswithscript) + * [`fn withScriptMixin(value)`](#fn-metricaggregationwithsettingsmovingfunctionsettingswithscriptmixin) + * [`fn withShift(value)`](#fn-metricaggregationwithsettingsmovingfunctionsettingswithshift) + * [`fn withWindow(value)`](#fn-metricaggregationwithsettingsmovingfunctionsettingswithwindow) + * [`obj script`](#obj-metricaggregationwithsettingsmovingfunctionsettingsscript) + * [`fn withInline(value)`](#fn-metricaggregationwithsettingsmovingfunctionsettingsscriptwithinline) + * [`obj Percentiles`](#obj-metricaggregationwithsettingspercentiles) + * [`fn withField(value)`](#fn-metricaggregationwithsettingspercentileswithfield) + * [`fn withHide(value=true)`](#fn-metricaggregationwithsettingspercentileswithhide) + * [`fn withId(value)`](#fn-metricaggregationwithsettingspercentileswithid) + * [`fn withSettings(value)`](#fn-metricaggregationwithsettingspercentileswithsettings) + * [`fn withSettingsMixin(value)`](#fn-metricaggregationwithsettingspercentileswithsettingsmixin) + * [`fn withType(value)`](#fn-metricaggregationwithsettingspercentileswithtype) + * [`obj settings`](#obj-metricaggregationwithsettingspercentilessettings) + * [`fn withMissing(value)`](#fn-metricaggregationwithsettingspercentilessettingswithmissing) + * [`fn withPercents(value)`](#fn-metricaggregationwithsettingspercentilessettingswithpercents) + * [`fn withPercentsMixin(value)`](#fn-metricaggregationwithsettingspercentilessettingswithpercentsmixin) + * [`fn withScript(value)`](#fn-metricaggregationwithsettingspercentilessettingswithscript) + * [`fn withScriptMixin(value)`](#fn-metricaggregationwithsettingspercentilessettingswithscriptmixin) + * [`obj script`](#obj-metricaggregationwithsettingspercentilessettingsscript) + * [`fn withInline(value)`](#fn-metricaggregationwithsettingspercentilessettingsscriptwithinline) + * [`obj Rate`](#obj-metricaggregationwithsettingsrate) + * [`fn withField(value)`](#fn-metricaggregationwithsettingsratewithfield) + * [`fn withHide(value=true)`](#fn-metricaggregationwithsettingsratewithhide) + * [`fn withId(value)`](#fn-metricaggregationwithsettingsratewithid) + * [`fn withSettings(value)`](#fn-metricaggregationwithsettingsratewithsettings) + * [`fn withSettingsMixin(value)`](#fn-metricaggregationwithsettingsratewithsettingsmixin) + * [`fn withType(value)`](#fn-metricaggregationwithsettingsratewithtype) + * [`obj settings`](#obj-metricaggregationwithsettingsratesettings) + * [`fn withMode(value)`](#fn-metricaggregationwithsettingsratesettingswithmode) + * [`fn withUnit(value)`](#fn-metricaggregationwithsettingsratesettingswithunit) + * [`obj RawData`](#obj-metricaggregationwithsettingsrawdata) + * [`fn withHide(value=true)`](#fn-metricaggregationwithsettingsrawdatawithhide) + * [`fn withId(value)`](#fn-metricaggregationwithsettingsrawdatawithid) + * [`fn withSettings(value)`](#fn-metricaggregationwithsettingsrawdatawithsettings) + * [`fn withSettingsMixin(value)`](#fn-metricaggregationwithsettingsrawdatawithsettingsmixin) + * [`fn withType(value)`](#fn-metricaggregationwithsettingsrawdatawithtype) + * [`obj settings`](#obj-metricaggregationwithsettingsrawdatasettings) + * [`fn withSize(value)`](#fn-metricaggregationwithsettingsrawdatasettingswithsize) + * [`obj RawDocument`](#obj-metricaggregationwithsettingsrawdocument) + * [`fn withHide(value=true)`](#fn-metricaggregationwithsettingsrawdocumentwithhide) + * [`fn withId(value)`](#fn-metricaggregationwithsettingsrawdocumentwithid) + * [`fn withSettings(value)`](#fn-metricaggregationwithsettingsrawdocumentwithsettings) + * [`fn withSettingsMixin(value)`](#fn-metricaggregationwithsettingsrawdocumentwithsettingsmixin) + * [`fn withType(value)`](#fn-metricaggregationwithsettingsrawdocumentwithtype) + * [`obj settings`](#obj-metricaggregationwithsettingsrawdocumentsettings) + * [`fn withSize(value)`](#fn-metricaggregationwithsettingsrawdocumentsettingswithsize) + * [`obj SerialDiff`](#obj-metricaggregationwithsettingsserialdiff) + * [`fn withField(value)`](#fn-metricaggregationwithsettingsserialdiffwithfield) + * [`fn withHide(value=true)`](#fn-metricaggregationwithsettingsserialdiffwithhide) + * [`fn withId(value)`](#fn-metricaggregationwithsettingsserialdiffwithid) + * [`fn withPipelineAgg(value)`](#fn-metricaggregationwithsettingsserialdiffwithpipelineagg) + * [`fn withSettings(value)`](#fn-metricaggregationwithsettingsserialdiffwithsettings) + * [`fn withSettingsMixin(value)`](#fn-metricaggregationwithsettingsserialdiffwithsettingsmixin) + * [`fn withType(value)`](#fn-metricaggregationwithsettingsserialdiffwithtype) + * [`obj settings`](#obj-metricaggregationwithsettingsserialdiffsettings) + * [`fn withLag(value)`](#fn-metricaggregationwithsettingsserialdiffsettingswithlag) + * [`obj Sum`](#obj-metricaggregationwithsettingssum) + * [`fn withField(value)`](#fn-metricaggregationwithsettingssumwithfield) + * [`fn withHide(value=true)`](#fn-metricaggregationwithsettingssumwithhide) + * [`fn withId(value)`](#fn-metricaggregationwithsettingssumwithid) + * [`fn withSettings(value)`](#fn-metricaggregationwithsettingssumwithsettings) + * [`fn withSettingsMixin(value)`](#fn-metricaggregationwithsettingssumwithsettingsmixin) + * [`fn withType(value)`](#fn-metricaggregationwithsettingssumwithtype) + * [`obj settings`](#obj-metricaggregationwithsettingssumsettings) + * [`fn withMissing(value)`](#fn-metricaggregationwithsettingssumsettingswithmissing) + * [`fn withScript(value)`](#fn-metricaggregationwithsettingssumsettingswithscript) + * [`fn withScriptMixin(value)`](#fn-metricaggregationwithsettingssumsettingswithscriptmixin) + * [`obj script`](#obj-metricaggregationwithsettingssumsettingsscript) + * [`fn withInline(value)`](#fn-metricaggregationwithsettingssumsettingsscriptwithinline) + * [`obj TopMetrics`](#obj-metricaggregationwithsettingstopmetrics) + * [`fn withHide(value=true)`](#fn-metricaggregationwithsettingstopmetricswithhide) + * [`fn withId(value)`](#fn-metricaggregationwithsettingstopmetricswithid) + * [`fn withSettings(value)`](#fn-metricaggregationwithsettingstopmetricswithsettings) + * [`fn withSettingsMixin(value)`](#fn-metricaggregationwithsettingstopmetricswithsettingsmixin) + * [`fn withType(value)`](#fn-metricaggregationwithsettingstopmetricswithtype) + * [`obj settings`](#obj-metricaggregationwithsettingstopmetricssettings) + * [`fn withMetrics(value)`](#fn-metricaggregationwithsettingstopmetricssettingswithmetrics) + * [`fn withMetricsMixin(value)`](#fn-metricaggregationwithsettingstopmetricssettingswithmetricsmixin) + * [`fn withOrder(value)`](#fn-metricaggregationwithsettingstopmetricssettingswithorder) + * [`fn withOrderBy(value)`](#fn-metricaggregationwithsettingstopmetricssettingswithorderby) + * [`obj UniqueCount`](#obj-metricaggregationwithsettingsuniquecount) + * [`fn withField(value)`](#fn-metricaggregationwithsettingsuniquecountwithfield) + * [`fn withHide(value=true)`](#fn-metricaggregationwithsettingsuniquecountwithhide) + * [`fn withId(value)`](#fn-metricaggregationwithsettingsuniquecountwithid) + * [`fn withSettings(value)`](#fn-metricaggregationwithsettingsuniquecountwithsettings) + * [`fn withSettingsMixin(value)`](#fn-metricaggregationwithsettingsuniquecountwithsettingsmixin) + * [`fn withType(value)`](#fn-metricaggregationwithsettingsuniquecountwithtype) + * [`obj settings`](#obj-metricaggregationwithsettingsuniquecountsettings) + * [`fn withMissing(value)`](#fn-metricaggregationwithsettingsuniquecountsettingswithmissing) + * [`fn withPrecisionThreshold(value)`](#fn-metricaggregationwithsettingsuniquecountsettingswithprecisionthreshold) +* [`obj PipelineMetricAggregation`](#obj-pipelinemetricaggregation) + * [`obj BucketScript`](#obj-pipelinemetricaggregationbucketscript) + * [`fn withHide(value=true)`](#fn-pipelinemetricaggregationbucketscriptwithhide) + * [`fn withId(value)`](#fn-pipelinemetricaggregationbucketscriptwithid) + * [`fn withPipelineVariables(value)`](#fn-pipelinemetricaggregationbucketscriptwithpipelinevariables) + * [`fn withPipelineVariablesMixin(value)`](#fn-pipelinemetricaggregationbucketscriptwithpipelinevariablesmixin) + * [`fn withSettings(value)`](#fn-pipelinemetricaggregationbucketscriptwithsettings) + * [`fn withSettingsMixin(value)`](#fn-pipelinemetricaggregationbucketscriptwithsettingsmixin) + * [`fn withType(value)`](#fn-pipelinemetricaggregationbucketscriptwithtype) + * [`obj settings`](#obj-pipelinemetricaggregationbucketscriptsettings) + * [`fn withScript(value)`](#fn-pipelinemetricaggregationbucketscriptsettingswithscript) + * [`fn withScriptMixin(value)`](#fn-pipelinemetricaggregationbucketscriptsettingswithscriptmixin) + * [`obj script`](#obj-pipelinemetricaggregationbucketscriptsettingsscript) + * [`fn withInline(value)`](#fn-pipelinemetricaggregationbucketscriptsettingsscriptwithinline) + * [`obj CumulativeSum`](#obj-pipelinemetricaggregationcumulativesum) + * [`fn withField(value)`](#fn-pipelinemetricaggregationcumulativesumwithfield) + * [`fn withHide(value=true)`](#fn-pipelinemetricaggregationcumulativesumwithhide) + * [`fn withId(value)`](#fn-pipelinemetricaggregationcumulativesumwithid) + * [`fn withPipelineAgg(value)`](#fn-pipelinemetricaggregationcumulativesumwithpipelineagg) + * [`fn withSettings(value)`](#fn-pipelinemetricaggregationcumulativesumwithsettings) + * [`fn withSettingsMixin(value)`](#fn-pipelinemetricaggregationcumulativesumwithsettingsmixin) + * [`fn withType(value)`](#fn-pipelinemetricaggregationcumulativesumwithtype) + * [`obj settings`](#obj-pipelinemetricaggregationcumulativesumsettings) + * [`fn withFormat(value)`](#fn-pipelinemetricaggregationcumulativesumsettingswithformat) + * [`obj Derivative`](#obj-pipelinemetricaggregationderivative) + * [`fn withField(value)`](#fn-pipelinemetricaggregationderivativewithfield) + * [`fn withHide(value=true)`](#fn-pipelinemetricaggregationderivativewithhide) + * [`fn withId(value)`](#fn-pipelinemetricaggregationderivativewithid) + * [`fn withPipelineAgg(value)`](#fn-pipelinemetricaggregationderivativewithpipelineagg) + * [`fn withSettings(value)`](#fn-pipelinemetricaggregationderivativewithsettings) + * [`fn withSettingsMixin(value)`](#fn-pipelinemetricaggregationderivativewithsettingsmixin) + * [`fn withType(value)`](#fn-pipelinemetricaggregationderivativewithtype) + * [`obj settings`](#obj-pipelinemetricaggregationderivativesettings) + * [`fn withUnit(value)`](#fn-pipelinemetricaggregationderivativesettingswithunit) + * [`obj MovingAverage`](#obj-pipelinemetricaggregationmovingaverage) + * [`fn withField(value)`](#fn-pipelinemetricaggregationmovingaveragewithfield) + * [`fn withHide(value=true)`](#fn-pipelinemetricaggregationmovingaveragewithhide) + * [`fn withId(value)`](#fn-pipelinemetricaggregationmovingaveragewithid) + * [`fn withPipelineAgg(value)`](#fn-pipelinemetricaggregationmovingaveragewithpipelineagg) + * [`fn withSettings(value)`](#fn-pipelinemetricaggregationmovingaveragewithsettings) + * [`fn withSettingsMixin(value)`](#fn-pipelinemetricaggregationmovingaveragewithsettingsmixin) + * [`fn withType(value)`](#fn-pipelinemetricaggregationmovingaveragewithtype) + +## Fields + +### obj Count + + +#### fn Count.withHide + +```jsonnet +Count.withHide(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +#### fn Count.withId + +```jsonnet +Count.withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn Count.withType + +```jsonnet +Count.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj MetricAggregationWithSettings + + +#### obj MetricAggregationWithSettings.Average + + +##### fn MetricAggregationWithSettings.Average.withField + +```jsonnet +MetricAggregationWithSettings.Average.withField(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn MetricAggregationWithSettings.Average.withHide + +```jsonnet +MetricAggregationWithSettings.Average.withHide(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn MetricAggregationWithSettings.Average.withId + +```jsonnet +MetricAggregationWithSettings.Average.withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn MetricAggregationWithSettings.Average.withSettings + +```jsonnet +MetricAggregationWithSettings.Average.withSettings(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.Average.withSettingsMixin + +```jsonnet +MetricAggregationWithSettings.Average.withSettingsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.Average.withType + +```jsonnet +MetricAggregationWithSettings.Average.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### obj MetricAggregationWithSettings.Average.settings + + +###### fn MetricAggregationWithSettings.Average.settings.withMissing + +```jsonnet +MetricAggregationWithSettings.Average.settings.withMissing(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn MetricAggregationWithSettings.Average.settings.withScript + +```jsonnet +MetricAggregationWithSettings.Average.settings.withScript(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn MetricAggregationWithSettings.Average.settings.withScriptMixin + +```jsonnet +MetricAggregationWithSettings.Average.settings.withScriptMixin(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### obj MetricAggregationWithSettings.Average.settings.script + + +####### fn MetricAggregationWithSettings.Average.settings.script.withInline + +```jsonnet +MetricAggregationWithSettings.Average.settings.script.withInline(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj MetricAggregationWithSettings.BucketScript + + +##### fn MetricAggregationWithSettings.BucketScript.withHide + +```jsonnet +MetricAggregationWithSettings.BucketScript.withHide(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn MetricAggregationWithSettings.BucketScript.withId + +```jsonnet +MetricAggregationWithSettings.BucketScript.withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn MetricAggregationWithSettings.BucketScript.withPipelineVariables + +```jsonnet +MetricAggregationWithSettings.BucketScript.withPipelineVariables(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +##### fn MetricAggregationWithSettings.BucketScript.withPipelineVariablesMixin + +```jsonnet +MetricAggregationWithSettings.BucketScript.withPipelineVariablesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +##### fn MetricAggregationWithSettings.BucketScript.withSettings + +```jsonnet +MetricAggregationWithSettings.BucketScript.withSettings(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.BucketScript.withSettingsMixin + +```jsonnet +MetricAggregationWithSettings.BucketScript.withSettingsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.BucketScript.withType + +```jsonnet +MetricAggregationWithSettings.BucketScript.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### obj MetricAggregationWithSettings.BucketScript.settings + + +###### fn MetricAggregationWithSettings.BucketScript.settings.withScript + +```jsonnet +MetricAggregationWithSettings.BucketScript.settings.withScript(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn MetricAggregationWithSettings.BucketScript.settings.withScriptMixin + +```jsonnet +MetricAggregationWithSettings.BucketScript.settings.withScriptMixin(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### obj MetricAggregationWithSettings.BucketScript.settings.script + + +####### fn MetricAggregationWithSettings.BucketScript.settings.script.withInline + +```jsonnet +MetricAggregationWithSettings.BucketScript.settings.script.withInline(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj MetricAggregationWithSettings.CumulativeSum + + +##### fn MetricAggregationWithSettings.CumulativeSum.withField + +```jsonnet +MetricAggregationWithSettings.CumulativeSum.withField(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn MetricAggregationWithSettings.CumulativeSum.withHide + +```jsonnet +MetricAggregationWithSettings.CumulativeSum.withHide(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn MetricAggregationWithSettings.CumulativeSum.withId + +```jsonnet +MetricAggregationWithSettings.CumulativeSum.withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn MetricAggregationWithSettings.CumulativeSum.withPipelineAgg + +```jsonnet +MetricAggregationWithSettings.CumulativeSum.withPipelineAgg(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn MetricAggregationWithSettings.CumulativeSum.withSettings + +```jsonnet +MetricAggregationWithSettings.CumulativeSum.withSettings(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.CumulativeSum.withSettingsMixin + +```jsonnet +MetricAggregationWithSettings.CumulativeSum.withSettingsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.CumulativeSum.withType + +```jsonnet +MetricAggregationWithSettings.CumulativeSum.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### obj MetricAggregationWithSettings.CumulativeSum.settings + + +###### fn MetricAggregationWithSettings.CumulativeSum.settings.withFormat + +```jsonnet +MetricAggregationWithSettings.CumulativeSum.settings.withFormat(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj MetricAggregationWithSettings.Derivative + + +##### fn MetricAggregationWithSettings.Derivative.withField + +```jsonnet +MetricAggregationWithSettings.Derivative.withField(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn MetricAggregationWithSettings.Derivative.withHide + +```jsonnet +MetricAggregationWithSettings.Derivative.withHide(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn MetricAggregationWithSettings.Derivative.withId + +```jsonnet +MetricAggregationWithSettings.Derivative.withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn MetricAggregationWithSettings.Derivative.withPipelineAgg + +```jsonnet +MetricAggregationWithSettings.Derivative.withPipelineAgg(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn MetricAggregationWithSettings.Derivative.withSettings + +```jsonnet +MetricAggregationWithSettings.Derivative.withSettings(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.Derivative.withSettingsMixin + +```jsonnet +MetricAggregationWithSettings.Derivative.withSettingsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.Derivative.withType + +```jsonnet +MetricAggregationWithSettings.Derivative.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### obj MetricAggregationWithSettings.Derivative.settings + + +###### fn MetricAggregationWithSettings.Derivative.settings.withUnit + +```jsonnet +MetricAggregationWithSettings.Derivative.settings.withUnit(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj MetricAggregationWithSettings.ExtendedStats + + +##### fn MetricAggregationWithSettings.ExtendedStats.withField + +```jsonnet +MetricAggregationWithSettings.ExtendedStats.withField(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn MetricAggregationWithSettings.ExtendedStats.withHide + +```jsonnet +MetricAggregationWithSettings.ExtendedStats.withHide(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn MetricAggregationWithSettings.ExtendedStats.withId + +```jsonnet +MetricAggregationWithSettings.ExtendedStats.withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn MetricAggregationWithSettings.ExtendedStats.withMeta + +```jsonnet +MetricAggregationWithSettings.ExtendedStats.withMeta(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.ExtendedStats.withMetaMixin + +```jsonnet +MetricAggregationWithSettings.ExtendedStats.withMetaMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.ExtendedStats.withSettings + +```jsonnet +MetricAggregationWithSettings.ExtendedStats.withSettings(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.ExtendedStats.withSettingsMixin + +```jsonnet +MetricAggregationWithSettings.ExtendedStats.withSettingsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.ExtendedStats.withType + +```jsonnet +MetricAggregationWithSettings.ExtendedStats.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### obj MetricAggregationWithSettings.ExtendedStats.settings + + +###### fn MetricAggregationWithSettings.ExtendedStats.settings.withMissing + +```jsonnet +MetricAggregationWithSettings.ExtendedStats.settings.withMissing(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn MetricAggregationWithSettings.ExtendedStats.settings.withScript + +```jsonnet +MetricAggregationWithSettings.ExtendedStats.settings.withScript(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn MetricAggregationWithSettings.ExtendedStats.settings.withScriptMixin + +```jsonnet +MetricAggregationWithSettings.ExtendedStats.settings.withScriptMixin(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn MetricAggregationWithSettings.ExtendedStats.settings.withSigma + +```jsonnet +MetricAggregationWithSettings.ExtendedStats.settings.withSigma(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### obj MetricAggregationWithSettings.ExtendedStats.settings.script + + +####### fn MetricAggregationWithSettings.ExtendedStats.settings.script.withInline + +```jsonnet +MetricAggregationWithSettings.ExtendedStats.settings.script.withInline(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj MetricAggregationWithSettings.Logs + + +##### fn MetricAggregationWithSettings.Logs.withHide + +```jsonnet +MetricAggregationWithSettings.Logs.withHide(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn MetricAggregationWithSettings.Logs.withId + +```jsonnet +MetricAggregationWithSettings.Logs.withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn MetricAggregationWithSettings.Logs.withSettings + +```jsonnet +MetricAggregationWithSettings.Logs.withSettings(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.Logs.withSettingsMixin + +```jsonnet +MetricAggregationWithSettings.Logs.withSettingsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.Logs.withType + +```jsonnet +MetricAggregationWithSettings.Logs.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### obj MetricAggregationWithSettings.Logs.settings + + +###### fn MetricAggregationWithSettings.Logs.settings.withLimit + +```jsonnet +MetricAggregationWithSettings.Logs.settings.withLimit(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj MetricAggregationWithSettings.Max + + +##### fn MetricAggregationWithSettings.Max.withField + +```jsonnet +MetricAggregationWithSettings.Max.withField(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn MetricAggregationWithSettings.Max.withHide + +```jsonnet +MetricAggregationWithSettings.Max.withHide(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn MetricAggregationWithSettings.Max.withId + +```jsonnet +MetricAggregationWithSettings.Max.withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn MetricAggregationWithSettings.Max.withSettings + +```jsonnet +MetricAggregationWithSettings.Max.withSettings(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.Max.withSettingsMixin + +```jsonnet +MetricAggregationWithSettings.Max.withSettingsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.Max.withType + +```jsonnet +MetricAggregationWithSettings.Max.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### obj MetricAggregationWithSettings.Max.settings + + +###### fn MetricAggregationWithSettings.Max.settings.withMissing + +```jsonnet +MetricAggregationWithSettings.Max.settings.withMissing(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn MetricAggregationWithSettings.Max.settings.withScript + +```jsonnet +MetricAggregationWithSettings.Max.settings.withScript(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn MetricAggregationWithSettings.Max.settings.withScriptMixin + +```jsonnet +MetricAggregationWithSettings.Max.settings.withScriptMixin(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### obj MetricAggregationWithSettings.Max.settings.script + + +####### fn MetricAggregationWithSettings.Max.settings.script.withInline + +```jsonnet +MetricAggregationWithSettings.Max.settings.script.withInline(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj MetricAggregationWithSettings.Min + + +##### fn MetricAggregationWithSettings.Min.withField + +```jsonnet +MetricAggregationWithSettings.Min.withField(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn MetricAggregationWithSettings.Min.withHide + +```jsonnet +MetricAggregationWithSettings.Min.withHide(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn MetricAggregationWithSettings.Min.withId + +```jsonnet +MetricAggregationWithSettings.Min.withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn MetricAggregationWithSettings.Min.withSettings + +```jsonnet +MetricAggregationWithSettings.Min.withSettings(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.Min.withSettingsMixin + +```jsonnet +MetricAggregationWithSettings.Min.withSettingsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.Min.withType + +```jsonnet +MetricAggregationWithSettings.Min.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### obj MetricAggregationWithSettings.Min.settings + + +###### fn MetricAggregationWithSettings.Min.settings.withMissing + +```jsonnet +MetricAggregationWithSettings.Min.settings.withMissing(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn MetricAggregationWithSettings.Min.settings.withScript + +```jsonnet +MetricAggregationWithSettings.Min.settings.withScript(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn MetricAggregationWithSettings.Min.settings.withScriptMixin + +```jsonnet +MetricAggregationWithSettings.Min.settings.withScriptMixin(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### obj MetricAggregationWithSettings.Min.settings.script + + +####### fn MetricAggregationWithSettings.Min.settings.script.withInline + +```jsonnet +MetricAggregationWithSettings.Min.settings.script.withInline(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj MetricAggregationWithSettings.MovingAverage + + +##### fn MetricAggregationWithSettings.MovingAverage.withField + +```jsonnet +MetricAggregationWithSettings.MovingAverage.withField(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn MetricAggregationWithSettings.MovingAverage.withHide + +```jsonnet +MetricAggregationWithSettings.MovingAverage.withHide(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn MetricAggregationWithSettings.MovingAverage.withId + +```jsonnet +MetricAggregationWithSettings.MovingAverage.withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn MetricAggregationWithSettings.MovingAverage.withPipelineAgg + +```jsonnet +MetricAggregationWithSettings.MovingAverage.withPipelineAgg(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn MetricAggregationWithSettings.MovingAverage.withSettings + +```jsonnet +MetricAggregationWithSettings.MovingAverage.withSettings(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.MovingAverage.withSettingsMixin + +```jsonnet +MetricAggregationWithSettings.MovingAverage.withSettingsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.MovingAverage.withType + +```jsonnet +MetricAggregationWithSettings.MovingAverage.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj MetricAggregationWithSettings.MovingFunction + + +##### fn MetricAggregationWithSettings.MovingFunction.withField + +```jsonnet +MetricAggregationWithSettings.MovingFunction.withField(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn MetricAggregationWithSettings.MovingFunction.withHide + +```jsonnet +MetricAggregationWithSettings.MovingFunction.withHide(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn MetricAggregationWithSettings.MovingFunction.withId + +```jsonnet +MetricAggregationWithSettings.MovingFunction.withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn MetricAggregationWithSettings.MovingFunction.withPipelineAgg + +```jsonnet +MetricAggregationWithSettings.MovingFunction.withPipelineAgg(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn MetricAggregationWithSettings.MovingFunction.withSettings + +```jsonnet +MetricAggregationWithSettings.MovingFunction.withSettings(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.MovingFunction.withSettingsMixin + +```jsonnet +MetricAggregationWithSettings.MovingFunction.withSettingsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.MovingFunction.withType + +```jsonnet +MetricAggregationWithSettings.MovingFunction.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### obj MetricAggregationWithSettings.MovingFunction.settings + + +###### fn MetricAggregationWithSettings.MovingFunction.settings.withScript + +```jsonnet +MetricAggregationWithSettings.MovingFunction.settings.withScript(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn MetricAggregationWithSettings.MovingFunction.settings.withScriptMixin + +```jsonnet +MetricAggregationWithSettings.MovingFunction.settings.withScriptMixin(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn MetricAggregationWithSettings.MovingFunction.settings.withShift + +```jsonnet +MetricAggregationWithSettings.MovingFunction.settings.withShift(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn MetricAggregationWithSettings.MovingFunction.settings.withWindow + +```jsonnet +MetricAggregationWithSettings.MovingFunction.settings.withWindow(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### obj MetricAggregationWithSettings.MovingFunction.settings.script + + +####### fn MetricAggregationWithSettings.MovingFunction.settings.script.withInline + +```jsonnet +MetricAggregationWithSettings.MovingFunction.settings.script.withInline(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj MetricAggregationWithSettings.Percentiles + + +##### fn MetricAggregationWithSettings.Percentiles.withField + +```jsonnet +MetricAggregationWithSettings.Percentiles.withField(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn MetricAggregationWithSettings.Percentiles.withHide + +```jsonnet +MetricAggregationWithSettings.Percentiles.withHide(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn MetricAggregationWithSettings.Percentiles.withId + +```jsonnet +MetricAggregationWithSettings.Percentiles.withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn MetricAggregationWithSettings.Percentiles.withSettings + +```jsonnet +MetricAggregationWithSettings.Percentiles.withSettings(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.Percentiles.withSettingsMixin + +```jsonnet +MetricAggregationWithSettings.Percentiles.withSettingsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.Percentiles.withType + +```jsonnet +MetricAggregationWithSettings.Percentiles.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### obj MetricAggregationWithSettings.Percentiles.settings + + +###### fn MetricAggregationWithSettings.Percentiles.settings.withMissing + +```jsonnet +MetricAggregationWithSettings.Percentiles.settings.withMissing(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn MetricAggregationWithSettings.Percentiles.settings.withPercents + +```jsonnet +MetricAggregationWithSettings.Percentiles.settings.withPercents(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +###### fn MetricAggregationWithSettings.Percentiles.settings.withPercentsMixin + +```jsonnet +MetricAggregationWithSettings.Percentiles.settings.withPercentsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +###### fn MetricAggregationWithSettings.Percentiles.settings.withScript + +```jsonnet +MetricAggregationWithSettings.Percentiles.settings.withScript(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn MetricAggregationWithSettings.Percentiles.settings.withScriptMixin + +```jsonnet +MetricAggregationWithSettings.Percentiles.settings.withScriptMixin(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### obj MetricAggregationWithSettings.Percentiles.settings.script + + +####### fn MetricAggregationWithSettings.Percentiles.settings.script.withInline + +```jsonnet +MetricAggregationWithSettings.Percentiles.settings.script.withInline(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj MetricAggregationWithSettings.Rate + + +##### fn MetricAggregationWithSettings.Rate.withField + +```jsonnet +MetricAggregationWithSettings.Rate.withField(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn MetricAggregationWithSettings.Rate.withHide + +```jsonnet +MetricAggregationWithSettings.Rate.withHide(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn MetricAggregationWithSettings.Rate.withId + +```jsonnet +MetricAggregationWithSettings.Rate.withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn MetricAggregationWithSettings.Rate.withSettings + +```jsonnet +MetricAggregationWithSettings.Rate.withSettings(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.Rate.withSettingsMixin + +```jsonnet +MetricAggregationWithSettings.Rate.withSettingsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.Rate.withType + +```jsonnet +MetricAggregationWithSettings.Rate.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### obj MetricAggregationWithSettings.Rate.settings + + +###### fn MetricAggregationWithSettings.Rate.settings.withMode + +```jsonnet +MetricAggregationWithSettings.Rate.settings.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn MetricAggregationWithSettings.Rate.settings.withUnit + +```jsonnet +MetricAggregationWithSettings.Rate.settings.withUnit(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj MetricAggregationWithSettings.RawData + + +##### fn MetricAggregationWithSettings.RawData.withHide + +```jsonnet +MetricAggregationWithSettings.RawData.withHide(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn MetricAggregationWithSettings.RawData.withId + +```jsonnet +MetricAggregationWithSettings.RawData.withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn MetricAggregationWithSettings.RawData.withSettings + +```jsonnet +MetricAggregationWithSettings.RawData.withSettings(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.RawData.withSettingsMixin + +```jsonnet +MetricAggregationWithSettings.RawData.withSettingsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.RawData.withType + +```jsonnet +MetricAggregationWithSettings.RawData.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### obj MetricAggregationWithSettings.RawData.settings + + +###### fn MetricAggregationWithSettings.RawData.settings.withSize + +```jsonnet +MetricAggregationWithSettings.RawData.settings.withSize(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj MetricAggregationWithSettings.RawDocument + + +##### fn MetricAggregationWithSettings.RawDocument.withHide + +```jsonnet +MetricAggregationWithSettings.RawDocument.withHide(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn MetricAggregationWithSettings.RawDocument.withId + +```jsonnet +MetricAggregationWithSettings.RawDocument.withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn MetricAggregationWithSettings.RawDocument.withSettings + +```jsonnet +MetricAggregationWithSettings.RawDocument.withSettings(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.RawDocument.withSettingsMixin + +```jsonnet +MetricAggregationWithSettings.RawDocument.withSettingsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.RawDocument.withType + +```jsonnet +MetricAggregationWithSettings.RawDocument.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### obj MetricAggregationWithSettings.RawDocument.settings + + +###### fn MetricAggregationWithSettings.RawDocument.settings.withSize + +```jsonnet +MetricAggregationWithSettings.RawDocument.settings.withSize(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj MetricAggregationWithSettings.SerialDiff + + +##### fn MetricAggregationWithSettings.SerialDiff.withField + +```jsonnet +MetricAggregationWithSettings.SerialDiff.withField(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn MetricAggregationWithSettings.SerialDiff.withHide + +```jsonnet +MetricAggregationWithSettings.SerialDiff.withHide(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn MetricAggregationWithSettings.SerialDiff.withId + +```jsonnet +MetricAggregationWithSettings.SerialDiff.withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn MetricAggregationWithSettings.SerialDiff.withPipelineAgg + +```jsonnet +MetricAggregationWithSettings.SerialDiff.withPipelineAgg(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn MetricAggregationWithSettings.SerialDiff.withSettings + +```jsonnet +MetricAggregationWithSettings.SerialDiff.withSettings(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.SerialDiff.withSettingsMixin + +```jsonnet +MetricAggregationWithSettings.SerialDiff.withSettingsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.SerialDiff.withType + +```jsonnet +MetricAggregationWithSettings.SerialDiff.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### obj MetricAggregationWithSettings.SerialDiff.settings + + +###### fn MetricAggregationWithSettings.SerialDiff.settings.withLag + +```jsonnet +MetricAggregationWithSettings.SerialDiff.settings.withLag(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj MetricAggregationWithSettings.Sum + + +##### fn MetricAggregationWithSettings.Sum.withField + +```jsonnet +MetricAggregationWithSettings.Sum.withField(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn MetricAggregationWithSettings.Sum.withHide + +```jsonnet +MetricAggregationWithSettings.Sum.withHide(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn MetricAggregationWithSettings.Sum.withId + +```jsonnet +MetricAggregationWithSettings.Sum.withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn MetricAggregationWithSettings.Sum.withSettings + +```jsonnet +MetricAggregationWithSettings.Sum.withSettings(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.Sum.withSettingsMixin + +```jsonnet +MetricAggregationWithSettings.Sum.withSettingsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.Sum.withType + +```jsonnet +MetricAggregationWithSettings.Sum.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### obj MetricAggregationWithSettings.Sum.settings + + +###### fn MetricAggregationWithSettings.Sum.settings.withMissing + +```jsonnet +MetricAggregationWithSettings.Sum.settings.withMissing(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn MetricAggregationWithSettings.Sum.settings.withScript + +```jsonnet +MetricAggregationWithSettings.Sum.settings.withScript(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn MetricAggregationWithSettings.Sum.settings.withScriptMixin + +```jsonnet +MetricAggregationWithSettings.Sum.settings.withScriptMixin(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### obj MetricAggregationWithSettings.Sum.settings.script + + +####### fn MetricAggregationWithSettings.Sum.settings.script.withInline + +```jsonnet +MetricAggregationWithSettings.Sum.settings.script.withInline(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj MetricAggregationWithSettings.TopMetrics + + +##### fn MetricAggregationWithSettings.TopMetrics.withHide + +```jsonnet +MetricAggregationWithSettings.TopMetrics.withHide(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn MetricAggregationWithSettings.TopMetrics.withId + +```jsonnet +MetricAggregationWithSettings.TopMetrics.withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn MetricAggregationWithSettings.TopMetrics.withSettings + +```jsonnet +MetricAggregationWithSettings.TopMetrics.withSettings(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.TopMetrics.withSettingsMixin + +```jsonnet +MetricAggregationWithSettings.TopMetrics.withSettingsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.TopMetrics.withType + +```jsonnet +MetricAggregationWithSettings.TopMetrics.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### obj MetricAggregationWithSettings.TopMetrics.settings + + +###### fn MetricAggregationWithSettings.TopMetrics.settings.withMetrics + +```jsonnet +MetricAggregationWithSettings.TopMetrics.settings.withMetrics(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +###### fn MetricAggregationWithSettings.TopMetrics.settings.withMetricsMixin + +```jsonnet +MetricAggregationWithSettings.TopMetrics.settings.withMetricsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +###### fn MetricAggregationWithSettings.TopMetrics.settings.withOrder + +```jsonnet +MetricAggregationWithSettings.TopMetrics.settings.withOrder(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn MetricAggregationWithSettings.TopMetrics.settings.withOrderBy + +```jsonnet +MetricAggregationWithSettings.TopMetrics.settings.withOrderBy(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj MetricAggregationWithSettings.UniqueCount + + +##### fn MetricAggregationWithSettings.UniqueCount.withField + +```jsonnet +MetricAggregationWithSettings.UniqueCount.withField(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn MetricAggregationWithSettings.UniqueCount.withHide + +```jsonnet +MetricAggregationWithSettings.UniqueCount.withHide(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn MetricAggregationWithSettings.UniqueCount.withId + +```jsonnet +MetricAggregationWithSettings.UniqueCount.withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn MetricAggregationWithSettings.UniqueCount.withSettings + +```jsonnet +MetricAggregationWithSettings.UniqueCount.withSettings(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.UniqueCount.withSettingsMixin + +```jsonnet +MetricAggregationWithSettings.UniqueCount.withSettingsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn MetricAggregationWithSettings.UniqueCount.withType + +```jsonnet +MetricAggregationWithSettings.UniqueCount.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### obj MetricAggregationWithSettings.UniqueCount.settings + + +###### fn MetricAggregationWithSettings.UniqueCount.settings.withMissing + +```jsonnet +MetricAggregationWithSettings.UniqueCount.settings.withMissing(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn MetricAggregationWithSettings.UniqueCount.settings.withPrecisionThreshold + +```jsonnet +MetricAggregationWithSettings.UniqueCount.settings.withPrecisionThreshold(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj PipelineMetricAggregation + + +#### obj PipelineMetricAggregation.BucketScript + + +##### fn PipelineMetricAggregation.BucketScript.withHide + +```jsonnet +PipelineMetricAggregation.BucketScript.withHide(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn PipelineMetricAggregation.BucketScript.withId + +```jsonnet +PipelineMetricAggregation.BucketScript.withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn PipelineMetricAggregation.BucketScript.withPipelineVariables + +```jsonnet +PipelineMetricAggregation.BucketScript.withPipelineVariables(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +##### fn PipelineMetricAggregation.BucketScript.withPipelineVariablesMixin + +```jsonnet +PipelineMetricAggregation.BucketScript.withPipelineVariablesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +##### fn PipelineMetricAggregation.BucketScript.withSettings + +```jsonnet +PipelineMetricAggregation.BucketScript.withSettings(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn PipelineMetricAggregation.BucketScript.withSettingsMixin + +```jsonnet +PipelineMetricAggregation.BucketScript.withSettingsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn PipelineMetricAggregation.BucketScript.withType + +```jsonnet +PipelineMetricAggregation.BucketScript.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### obj PipelineMetricAggregation.BucketScript.settings + + +###### fn PipelineMetricAggregation.BucketScript.settings.withScript + +```jsonnet +PipelineMetricAggregation.BucketScript.settings.withScript(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### fn PipelineMetricAggregation.BucketScript.settings.withScriptMixin + +```jsonnet +PipelineMetricAggregation.BucketScript.settings.withScriptMixin(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +###### obj PipelineMetricAggregation.BucketScript.settings.script + + +####### fn PipelineMetricAggregation.BucketScript.settings.script.withInline + +```jsonnet +PipelineMetricAggregation.BucketScript.settings.script.withInline(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj PipelineMetricAggregation.CumulativeSum + + +##### fn PipelineMetricAggregation.CumulativeSum.withField + +```jsonnet +PipelineMetricAggregation.CumulativeSum.withField(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn PipelineMetricAggregation.CumulativeSum.withHide + +```jsonnet +PipelineMetricAggregation.CumulativeSum.withHide(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn PipelineMetricAggregation.CumulativeSum.withId + +```jsonnet +PipelineMetricAggregation.CumulativeSum.withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn PipelineMetricAggregation.CumulativeSum.withPipelineAgg + +```jsonnet +PipelineMetricAggregation.CumulativeSum.withPipelineAgg(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn PipelineMetricAggregation.CumulativeSum.withSettings + +```jsonnet +PipelineMetricAggregation.CumulativeSum.withSettings(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn PipelineMetricAggregation.CumulativeSum.withSettingsMixin + +```jsonnet +PipelineMetricAggregation.CumulativeSum.withSettingsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn PipelineMetricAggregation.CumulativeSum.withType + +```jsonnet +PipelineMetricAggregation.CumulativeSum.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### obj PipelineMetricAggregation.CumulativeSum.settings + + +###### fn PipelineMetricAggregation.CumulativeSum.settings.withFormat + +```jsonnet +PipelineMetricAggregation.CumulativeSum.settings.withFormat(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj PipelineMetricAggregation.Derivative + + +##### fn PipelineMetricAggregation.Derivative.withField + +```jsonnet +PipelineMetricAggregation.Derivative.withField(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn PipelineMetricAggregation.Derivative.withHide + +```jsonnet +PipelineMetricAggregation.Derivative.withHide(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn PipelineMetricAggregation.Derivative.withId + +```jsonnet +PipelineMetricAggregation.Derivative.withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn PipelineMetricAggregation.Derivative.withPipelineAgg + +```jsonnet +PipelineMetricAggregation.Derivative.withPipelineAgg(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn PipelineMetricAggregation.Derivative.withSettings + +```jsonnet +PipelineMetricAggregation.Derivative.withSettings(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn PipelineMetricAggregation.Derivative.withSettingsMixin + +```jsonnet +PipelineMetricAggregation.Derivative.withSettingsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn PipelineMetricAggregation.Derivative.withType + +```jsonnet +PipelineMetricAggregation.Derivative.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### obj PipelineMetricAggregation.Derivative.settings + + +###### fn PipelineMetricAggregation.Derivative.settings.withUnit + +```jsonnet +PipelineMetricAggregation.Derivative.settings.withUnit(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### obj PipelineMetricAggregation.MovingAverage + + +##### fn PipelineMetricAggregation.MovingAverage.withField + +```jsonnet +PipelineMetricAggregation.MovingAverage.withField(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn PipelineMetricAggregation.MovingAverage.withHide + +```jsonnet +PipelineMetricAggregation.MovingAverage.withHide(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +##### fn PipelineMetricAggregation.MovingAverage.withId + +```jsonnet +PipelineMetricAggregation.MovingAverage.withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn PipelineMetricAggregation.MovingAverage.withPipelineAgg + +```jsonnet +PipelineMetricAggregation.MovingAverage.withPipelineAgg(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn PipelineMetricAggregation.MovingAverage.withSettings + +```jsonnet +PipelineMetricAggregation.MovingAverage.withSettings(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn PipelineMetricAggregation.MovingAverage.withSettingsMixin + +```jsonnet +PipelineMetricAggregation.MovingAverage.withSettingsMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +##### fn PipelineMetricAggregation.MovingAverage.withType + +```jsonnet +PipelineMetricAggregation.MovingAverage.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/grafanaPyroscope.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/grafanaPyroscope.md new file mode 100644 index 0000000000..69779d9133 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/grafanaPyroscope.md @@ -0,0 +1,127 @@ +# grafanaPyroscope + +grafonnet.query.grafanaPyroscope + +## Index + +* [`fn withDatasource(value)`](#fn-withdatasource) +* [`fn withGroupBy(value)`](#fn-withgroupby) +* [`fn withGroupByMixin(value)`](#fn-withgroupbymixin) +* [`fn withHide(value=true)`](#fn-withhide) +* [`fn withLabelSelector(value="{}")`](#fn-withlabelselector) +* [`fn withMaxNodes(value)`](#fn-withmaxnodes) +* [`fn withProfileTypeId(value)`](#fn-withprofiletypeid) +* [`fn withQueryType(value)`](#fn-withquerytype) +* [`fn withRefId(value)`](#fn-withrefid) + +## Fields + +### fn withDatasource + +```jsonnet +withDatasource(value) +``` + +PARAMETERS: + +* **value** (`string`) + +For mixed data sources the selected datasource is on the query level. +For non mixed scenarios this is undefined. +TODO find a better way to do this ^ that's friendly to schema +TODO this shouldn't be unknown but DataSourceRef | null +### fn withGroupBy + +```jsonnet +withGroupBy(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Allows to group the results. +### fn withGroupByMixin + +```jsonnet +withGroupByMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Allows to group the results. +### fn withHide + +```jsonnet +withHide(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +true if query is disabled (ie should not be returned to the dashboard) +Note this does not always imply that the query should not be executed since +the results from a hidden query may be used as the input to other queries (SSE etc) +### fn withLabelSelector + +```jsonnet +withLabelSelector(value="{}") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"{}"` + +Specifies the query label selectors. +### fn withMaxNodes + +```jsonnet +withMaxNodes(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Sets the maximum number of nodes in the flamegraph. +### fn withProfileTypeId + +```jsonnet +withProfileTypeId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Specifies the type of profile to query. +### fn withQueryType + +```jsonnet +withQueryType(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Specify the query flavor +TODO make this required and give it a default +### fn withRefId + +```jsonnet +withRefId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +A unique identifier for the query within the list of targets. +In server side expressions, the refId is used as a variable name to identify results. +By default, the UI will assign A->Z; however setting meaningful names may be useful. \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/index.md new file mode 100644 index 0000000000..f1f6ee6c04 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/index.md @@ -0,0 +1,15 @@ +# query + +grafonnet.query + +## Subpackages + +* [azureMonitor](azureMonitor/index.md) +* [cloudWatch](cloudWatch/index.md) +* [elasticsearch](elasticsearch/index.md) +* [grafanaPyroscope](grafanaPyroscope.md) +* [loki](loki.md) +* [parca](parca.md) +* [prometheus](prometheus.md) +* [tempo](tempo/index.md) +* [testData](testData/index.md) diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/loki.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/loki.md new file mode 100644 index 0000000000..99fd4081b2 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/loki.md @@ -0,0 +1,163 @@ +# loki + +grafonnet.query.loki + +## Index + +* [`fn new(datasource, expr)`](#fn-new) +* [`fn withDatasource(value)`](#fn-withdatasource) +* [`fn withEditorMode(value)`](#fn-witheditormode) +* [`fn withExpr(value)`](#fn-withexpr) +* [`fn withHide(value=true)`](#fn-withhide) +* [`fn withInstant(value=true)`](#fn-withinstant) +* [`fn withLegendFormat(value)`](#fn-withlegendformat) +* [`fn withMaxLines(value)`](#fn-withmaxlines) +* [`fn withQueryType(value)`](#fn-withquerytype) +* [`fn withRange(value=true)`](#fn-withrange) +* [`fn withRefId(value)`](#fn-withrefid) +* [`fn withResolution(value)`](#fn-withresolution) + +## Fields + +### fn new + +```jsonnet +new(datasource, expr) +``` + +PARAMETERS: + +* **datasource** (`string`) +* **expr** (`string`) + +Creates a new loki query target for panels. +### fn withDatasource + +```jsonnet +withDatasource(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Set the datasource for this query. +### fn withEditorMode + +```jsonnet +withEditorMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"code"`, `"builder"` + + +### fn withExpr + +```jsonnet +withExpr(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The LogQL query. +### fn withHide + +```jsonnet +withHide(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +true if query is disabled (ie should not be returned to the dashboard) +Note this does not always imply that the query should not be executed since +the results from a hidden query may be used as the input to other queries (SSE etc) +### fn withInstant + +```jsonnet +withInstant(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +@deprecated, now use queryType. +### fn withLegendFormat + +```jsonnet +withLegendFormat(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Used to override the name of the series. +### fn withMaxLines + +```jsonnet +withMaxLines(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Used to limit the number of log rows returned. +### fn withQueryType + +```jsonnet +withQueryType(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Specify the query flavor +TODO make this required and give it a default +### fn withRange + +```jsonnet +withRange(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +@deprecated, now use queryType. +### fn withRefId + +```jsonnet +withRefId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +A unique identifier for the query within the list of targets. +In server side expressions, the refId is used as a variable name to identify results. +By default, the UI will assign A->Z; however setting meaningful names may be useful. +### fn withResolution + +```jsonnet +withResolution(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Used to scale the interval value. \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/parca.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/parca.md new file mode 100644 index 0000000000..6edbee5f4c --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/parca.md @@ -0,0 +1,91 @@ +# parca + +grafonnet.query.parca + +## Index + +* [`fn withDatasource(value)`](#fn-withdatasource) +* [`fn withHide(value=true)`](#fn-withhide) +* [`fn withLabelSelector(value="{}")`](#fn-withlabelselector) +* [`fn withProfileTypeId(value)`](#fn-withprofiletypeid) +* [`fn withQueryType(value)`](#fn-withquerytype) +* [`fn withRefId(value)`](#fn-withrefid) + +## Fields + +### fn withDatasource + +```jsonnet +withDatasource(value) +``` + +PARAMETERS: + +* **value** (`string`) + +For mixed data sources the selected datasource is on the query level. +For non mixed scenarios this is undefined. +TODO find a better way to do this ^ that's friendly to schema +TODO this shouldn't be unknown but DataSourceRef | null +### fn withHide + +```jsonnet +withHide(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +true if query is disabled (ie should not be returned to the dashboard) +Note this does not always imply that the query should not be executed since +the results from a hidden query may be used as the input to other queries (SSE etc) +### fn withLabelSelector + +```jsonnet +withLabelSelector(value="{}") +``` + +PARAMETERS: + +* **value** (`string`) + - default value: `"{}"` + +Specifies the query label selectors. +### fn withProfileTypeId + +```jsonnet +withProfileTypeId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Specifies the type of profile to query. +### fn withQueryType + +```jsonnet +withQueryType(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Specify the query flavor +TODO make this required and give it a default +### fn withRefId + +```jsonnet +withRefId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +A unique identifier for the query within the list of targets. +In server side expressions, the refId is used as a variable name to identify results. +By default, the UI will assign A->Z; however setting meaningful names may be useful. \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/prometheus.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/prometheus.md new file mode 100644 index 0000000000..d211529495 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/prometheus.md @@ -0,0 +1,177 @@ +# prometheus + +grafonnet.query.prometheus + +## Index + +* [`fn new(datasource, expr)`](#fn-new) +* [`fn withDatasource(value)`](#fn-withdatasource) +* [`fn withEditorMode(value)`](#fn-witheditormode) +* [`fn withExemplar(value=true)`](#fn-withexemplar) +* [`fn withExpr(value)`](#fn-withexpr) +* [`fn withFormat(value)`](#fn-withformat) +* [`fn withHide(value=true)`](#fn-withhide) +* [`fn withInstant(value=true)`](#fn-withinstant) +* [`fn withIntervalFactor(value)`](#fn-withintervalfactor) +* [`fn withLegendFormat(value)`](#fn-withlegendformat) +* [`fn withQueryType(value)`](#fn-withquerytype) +* [`fn withRange(value=true)`](#fn-withrange) +* [`fn withRefId(value)`](#fn-withrefid) + +## Fields + +### fn new + +```jsonnet +new(datasource, expr) +``` + +PARAMETERS: + +* **datasource** (`string`) +* **expr** (`string`) + +Creates a new prometheus query target for panels. +### fn withDatasource + +```jsonnet +withDatasource(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Set the datasource for this query. +### fn withEditorMode + +```jsonnet +withEditorMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"code"`, `"builder"` + + +### fn withExemplar + +```jsonnet +withExemplar(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Execute an additional query to identify interesting raw samples relevant for the given expr +### fn withExpr + +```jsonnet +withExpr(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The actual expression/query that will be evaluated by Prometheus +### fn withFormat + +```jsonnet +withFormat(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"time_series"`, `"table"`, `"heatmap"` + + +### fn withHide + +```jsonnet +withHide(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +true if query is disabled (ie should not be returned to the dashboard) +Note this does not always imply that the query should not be executed since +the results from a hidden query may be used as the input to other queries (SSE etc) +### fn withInstant + +```jsonnet +withInstant(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Returns only the latest value that Prometheus has scraped for the requested time series +### fn withIntervalFactor + +```jsonnet +withIntervalFactor(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Set the interval factor for this query. +### fn withLegendFormat + +```jsonnet +withLegendFormat(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Set the legend format for this query. +### fn withQueryType + +```jsonnet +withQueryType(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Specify the query flavor +TODO make this required and give it a default +### fn withRange + +```jsonnet +withRange(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +Returns a Range vector, comprised of a set of time series containing a range of data points over time for each time series +### fn withRefId + +```jsonnet +withRefId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +A unique identifier for the query within the list of targets. +In server side expressions, the refId is used as a variable name to identify results. +By default, the UI will assign A->Z; however setting meaningful names may be useful. \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/tempo/filters.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/tempo/filters.md new file mode 100644 index 0000000000..b0ecd49145 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/tempo/filters.md @@ -0,0 +1,94 @@ +# filters + + + +## Index + +* [`fn withId(value)`](#fn-withid) +* [`fn withOperator(value)`](#fn-withoperator) +* [`fn withScope(value)`](#fn-withscope) +* [`fn withTag(value)`](#fn-withtag) +* [`fn withValue(value)`](#fn-withvalue) +* [`fn withValueMixin(value)`](#fn-withvaluemixin) +* [`fn withValueType(value)`](#fn-withvaluetype) + +## Fields + +### fn withId + +```jsonnet +withId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Uniquely identify the filter, will not be used in the query generation +### fn withOperator + +```jsonnet +withOperator(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The operator that connects the tag to the value, for example: =, >, !=, =~ +### fn withScope + +```jsonnet +withScope(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"unscoped"`, `"resource"`, `"span"` + +static fields are pre-set in the UI, dynamic fields are added by the user +### fn withTag + +```jsonnet +withTag(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The tag for the search filter, for example: .http.status_code, .service.name, status +### fn withValue + +```jsonnet +withValue(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The value for the search filter +### fn withValueMixin + +```jsonnet +withValueMixin(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The value for the search filter +### fn withValueType + +```jsonnet +withValueType(value) +``` + +PARAMETERS: + +* **value** (`string`) + +The type of the value, used for example to check whether we need to wrap the value in quotes when generating the query \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/tempo/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/tempo/index.md new file mode 100644 index 0000000000..9949daae06 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/tempo/index.md @@ -0,0 +1,201 @@ +# tempo + +grafonnet.query.tempo + +## Subpackages + +* [filters](filters.md) + +## Index + +* [`fn new(datasource, query, filters)`](#fn-new) +* [`fn withDatasource(value)`](#fn-withdatasource) +* [`fn withFilters(value)`](#fn-withfilters) +* [`fn withFiltersMixin(value)`](#fn-withfiltersmixin) +* [`fn withHide(value=true)`](#fn-withhide) +* [`fn withLimit(value)`](#fn-withlimit) +* [`fn withMaxDuration(value)`](#fn-withmaxduration) +* [`fn withMinDuration(value)`](#fn-withminduration) +* [`fn withQuery(value)`](#fn-withquery) +* [`fn withQueryType(value)`](#fn-withquerytype) +* [`fn withRefId(value)`](#fn-withrefid) +* [`fn withSearch(value)`](#fn-withsearch) +* [`fn withServiceMapQuery(value)`](#fn-withservicemapquery) +* [`fn withServiceName(value)`](#fn-withservicename) +* [`fn withSpanName(value)`](#fn-withspanname) + +## Fields + +### fn new + +```jsonnet +new(datasource, query, filters) +``` + +PARAMETERS: + +* **datasource** (`string`) +* **query** (`string`) +* **filters** (`array`) + +Creates a new tempo query target for panels. +### fn withDatasource + +```jsonnet +withDatasource(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Set the datasource for this query. +### fn withFilters + +```jsonnet +withFilters(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withFiltersMixin + +```jsonnet +withFiltersMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withHide + +```jsonnet +withHide(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +true if query is disabled (ie should not be returned to the dashboard) +Note this does not always imply that the query should not be executed since +the results from a hidden query may be used as the input to other queries (SSE etc) +### fn withLimit + +```jsonnet +withLimit(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Defines the maximum number of traces that are returned from Tempo +### fn withMaxDuration + +```jsonnet +withMaxDuration(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Define the maximum duration to select traces. Use duration format, for example: 1.2s, 100ms +### fn withMinDuration + +```jsonnet +withMinDuration(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Define the minimum duration to select traces. Use duration format, for example: 1.2s, 100ms +### fn withQuery + +```jsonnet +withQuery(value) +``` + +PARAMETERS: + +* **value** (`string`) + +TraceQL query or trace ID +### fn withQueryType + +```jsonnet +withQueryType(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Specify the query flavor +TODO make this required and give it a default +### fn withRefId + +```jsonnet +withRefId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +A unique identifier for the query within the list of targets. +In server side expressions, the refId is used as a variable name to identify results. +By default, the UI will assign A->Z; however setting meaningful names may be useful. +### fn withSearch + +```jsonnet +withSearch(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Logfmt query to filter traces by their tags. Example: http.status_code=200 error=true +### fn withServiceMapQuery + +```jsonnet +withServiceMapQuery(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Filters to be included in a PromQL query to select data for the service graph. Example: {client="app",service="app"} +### fn withServiceName + +```jsonnet +withServiceName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Query traces by service name +### fn withSpanName + +```jsonnet +withSpanName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Query traces by span name \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/testData/csvWave.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/testData/csvWave.md new file mode 100644 index 0000000000..8927e1ccd4 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/testData/csvWave.md @@ -0,0 +1,56 @@ +# csvWave + + + +## Index + +* [`fn withLabels(value)`](#fn-withlabels) +* [`fn withName(value)`](#fn-withname) +* [`fn withTimeStep(value)`](#fn-withtimestep) +* [`fn withValuesCSV(value)`](#fn-withvaluescsv) + +## Fields + +### fn withLabels + +```jsonnet +withLabels(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withName + +```jsonnet +withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withTimeStep + +```jsonnet +withTimeStep(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +### fn withValuesCSV + +```jsonnet +withValuesCSV(value) +``` + +PARAMETERS: + +* **value** (`string`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/testData/index.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/testData/index.md new file mode 100644 index 0000000000..5387d19959 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/query/testData/index.md @@ -0,0 +1,760 @@ +# testData + +grafonnet.query.testData + +## Subpackages + +* [csvWave](csvWave.md) + +## Index + +* [`fn withAlias(value)`](#fn-withalias) +* [`fn withChannel(value)`](#fn-withchannel) +* [`fn withCsvContent(value)`](#fn-withcsvcontent) +* [`fn withCsvFileName(value)`](#fn-withcsvfilename) +* [`fn withCsvWave(value)`](#fn-withcsvwave) +* [`fn withCsvWaveMixin(value)`](#fn-withcsvwavemixin) +* [`fn withDatasource(value)`](#fn-withdatasource) +* [`fn withErrorType(value)`](#fn-witherrortype) +* [`fn withHide(value=true)`](#fn-withhide) +* [`fn withLabels(value)`](#fn-withlabels) +* [`fn withLevelColumn(value=true)`](#fn-withlevelcolumn) +* [`fn withLines(value)`](#fn-withlines) +* [`fn withNodes(value)`](#fn-withnodes) +* [`fn withNodesMixin(value)`](#fn-withnodesmixin) +* [`fn withPoints(value)`](#fn-withpoints) +* [`fn withPointsMixin(value)`](#fn-withpointsmixin) +* [`fn withPulseWave(value)`](#fn-withpulsewave) +* [`fn withPulseWaveMixin(value)`](#fn-withpulsewavemixin) +* [`fn withQueryType(value)`](#fn-withquerytype) +* [`fn withRawFrameContent(value)`](#fn-withrawframecontent) +* [`fn withRefId(value)`](#fn-withrefid) +* [`fn withScenarioId(value)`](#fn-withscenarioid) +* [`fn withSeriesCount(value)`](#fn-withseriescount) +* [`fn withSim(value)`](#fn-withsim) +* [`fn withSimMixin(value)`](#fn-withsimmixin) +* [`fn withSpanCount(value)`](#fn-withspancount) +* [`fn withStream(value)`](#fn-withstream) +* [`fn withStreamMixin(value)`](#fn-withstreammixin) +* [`fn withStringInput(value)`](#fn-withstringinput) +* [`fn withUsa(value)`](#fn-withusa) +* [`fn withUsaMixin(value)`](#fn-withusamixin) +* [`obj nodes`](#obj-nodes) + * [`fn withCount(value)`](#fn-nodeswithcount) + * [`fn withType(value)`](#fn-nodeswithtype) +* [`obj pulseWave`](#obj-pulsewave) + * [`fn withOffCount(value)`](#fn-pulsewavewithoffcount) + * [`fn withOffValue(value)`](#fn-pulsewavewithoffvalue) + * [`fn withOnCount(value)`](#fn-pulsewavewithoncount) + * [`fn withOnValue(value)`](#fn-pulsewavewithonvalue) + * [`fn withTimeStep(value)`](#fn-pulsewavewithtimestep) +* [`obj sim`](#obj-sim) + * [`fn withConfig(value)`](#fn-simwithconfig) + * [`fn withConfigMixin(value)`](#fn-simwithconfigmixin) + * [`fn withKey(value)`](#fn-simwithkey) + * [`fn withKeyMixin(value)`](#fn-simwithkeymixin) + * [`fn withLast(value=true)`](#fn-simwithlast) + * [`fn withStream(value=true)`](#fn-simwithstream) + * [`obj key`](#obj-simkey) + * [`fn withTick(value)`](#fn-simkeywithtick) + * [`fn withType(value)`](#fn-simkeywithtype) + * [`fn withUid(value)`](#fn-simkeywithuid) +* [`obj stream`](#obj-stream) + * [`fn withBands(value)`](#fn-streamwithbands) + * [`fn withNoise(value)`](#fn-streamwithnoise) + * [`fn withSpeed(value)`](#fn-streamwithspeed) + * [`fn withSpread(value)`](#fn-streamwithspread) + * [`fn withType(value)`](#fn-streamwithtype) + * [`fn withUrl(value)`](#fn-streamwithurl) +* [`obj usa`](#obj-usa) + * [`fn withFields(value)`](#fn-usawithfields) + * [`fn withFieldsMixin(value)`](#fn-usawithfieldsmixin) + * [`fn withMode(value)`](#fn-usawithmode) + * [`fn withPeriod(value)`](#fn-usawithperiod) + * [`fn withStates(value)`](#fn-usawithstates) + * [`fn withStatesMixin(value)`](#fn-usawithstatesmixin) + +## Fields + +### fn withAlias + +```jsonnet +withAlias(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withChannel + +```jsonnet +withChannel(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withCsvContent + +```jsonnet +withCsvContent(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withCsvFileName + +```jsonnet +withCsvFileName(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withCsvWave + +```jsonnet +withCsvWave(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withCsvWaveMixin + +```jsonnet +withCsvWaveMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withDatasource + +```jsonnet +withDatasource(value) +``` + +PARAMETERS: + +* **value** (`string`) + +For mixed data sources the selected datasource is on the query level. +For non mixed scenarios this is undefined. +TODO find a better way to do this ^ that's friendly to schema +TODO this shouldn't be unknown but DataSourceRef | null +### fn withErrorType + +```jsonnet +withErrorType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"server_panic"`, `"frontend_exception"`, `"frontend_observable"` + + +### fn withHide + +```jsonnet +withHide(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +true if query is disabled (ie should not be returned to the dashboard) +Note this does not always imply that the query should not be executed since +the results from a hidden query may be used as the input to other queries (SSE etc) +### fn withLabels + +```jsonnet +withLabels(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withLevelColumn + +```jsonnet +withLevelColumn(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +### fn withLines + +```jsonnet +withLines(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +### fn withNodes + +```jsonnet +withNodes(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withNodesMixin + +```jsonnet +withNodesMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withPoints + +```jsonnet +withPoints(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withPointsMixin + +```jsonnet +withPointsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +### fn withPulseWave + +```jsonnet +withPulseWave(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withPulseWaveMixin + +```jsonnet +withPulseWaveMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withQueryType + +```jsonnet +withQueryType(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Specify the query flavor +TODO make this required and give it a default +### fn withRawFrameContent + +```jsonnet +withRawFrameContent(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withRefId + +```jsonnet +withRefId(value) +``` + +PARAMETERS: + +* **value** (`string`) + +A unique identifier for the query within the list of targets. +In server side expressions, the refId is used as a variable name to identify results. +By default, the UI will assign A->Z; however setting meaningful names may be useful. +### fn withScenarioId + +```jsonnet +withScenarioId(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"random_walk"`, `"slow_query"`, `"random_walk_with_error"`, `"random_walk_table"`, `"exponential_heatmap_bucket_data"`, `"linear_heatmap_bucket_data"`, `"no_data_points"`, `"datapoints_outside_range"`, `"csv_metric_values"`, `"predictable_pulse"`, `"predictable_csv_wave"`, `"streaming_client"`, `"simulation"`, `"usa"`, `"live"`, `"grafana_api"`, `"arrow"`, `"annotations"`, `"table_static"`, `"server_error_500"`, `"logs"`, `"node_graph"`, `"flame_graph"`, `"raw_frame"`, `"csv_file"`, `"csv_content"`, `"trace"`, `"manual_entry"`, `"variables-query"` + + +### fn withSeriesCount + +```jsonnet +withSeriesCount(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +### fn withSim + +```jsonnet +withSim(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withSimMixin + +```jsonnet +withSimMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withSpanCount + +```jsonnet +withSpanCount(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +### fn withStream + +```jsonnet +withStream(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withStreamMixin + +```jsonnet +withStreamMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withStringInput + +```jsonnet +withStringInput(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### fn withUsa + +```jsonnet +withUsa(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### fn withUsaMixin + +```jsonnet +withUsaMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +### obj nodes + + +#### fn nodes.withCount + +```jsonnet +nodes.withCount(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +#### fn nodes.withType + +```jsonnet +nodes.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"random"`, `"response"`, `"random edges"` + + +### obj pulseWave + + +#### fn pulseWave.withOffCount + +```jsonnet +pulseWave.withOffCount(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +#### fn pulseWave.withOffValue + +```jsonnet +pulseWave.withOffValue(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn pulseWave.withOnCount + +```jsonnet +pulseWave.withOnCount(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +#### fn pulseWave.withOnValue + +```jsonnet +pulseWave.withOnValue(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +#### fn pulseWave.withTimeStep + +```jsonnet +pulseWave.withTimeStep(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +### obj sim + + +#### fn sim.withConfig + +```jsonnet +sim.withConfig(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn sim.withConfigMixin + +```jsonnet +sim.withConfigMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn sim.withKey + +```jsonnet +sim.withKey(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn sim.withKeyMixin + +```jsonnet +sim.withKeyMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + + +#### fn sim.withLast + +```jsonnet +sim.withLast(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +#### fn sim.withStream + +```jsonnet +sim.withStream(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + + +#### obj sim.key + + +##### fn sim.key.withTick + +```jsonnet +sim.key.withTick(value) +``` + +PARAMETERS: + +* **value** (`number`) + + +##### fn sim.key.withType + +```jsonnet +sim.key.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +##### fn sim.key.withUid + +```jsonnet +sim.key.withUid(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj stream + + +#### fn stream.withBands + +```jsonnet +stream.withBands(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +#### fn stream.withNoise + +```jsonnet +stream.withNoise(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +#### fn stream.withSpeed + +```jsonnet +stream.withSpeed(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +#### fn stream.withSpread + +```jsonnet +stream.withSpread(value) +``` + +PARAMETERS: + +* **value** (`integer`) + + +#### fn stream.withType + +```jsonnet +stream.withType(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"signal"`, `"logs"`, `"fetch"` + + +#### fn stream.withUrl + +```jsonnet +stream.withUrl(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +### obj usa + + +#### fn usa.withFields + +```jsonnet +usa.withFields(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn usa.withFieldsMixin + +```jsonnet +usa.withFieldsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn usa.withMode + +```jsonnet +usa.withMode(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn usa.withPeriod + +```jsonnet +usa.withPeriod(value) +``` + +PARAMETERS: + +* **value** (`string`) + + +#### fn usa.withStates + +```jsonnet +usa.withStates(value) +``` + +PARAMETERS: + +* **value** (`array`) + + +#### fn usa.withStatesMixin + +```jsonnet +usa.withStatesMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/serviceaccount.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/serviceaccount.md new file mode 100644 index 0000000000..0e83b435af --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/serviceaccount.md @@ -0,0 +1,157 @@ +# serviceaccount + +grafonnet.serviceaccount + +## Index + +* [`fn withAccessControl(value)`](#fn-withaccesscontrol) +* [`fn withAccessControlMixin(value)`](#fn-withaccesscontrolmixin) +* [`fn withAvatarUrl(value)`](#fn-withavatarurl) +* [`fn withId(value)`](#fn-withid) +* [`fn withIsDisabled(value=true)`](#fn-withisdisabled) +* [`fn withLogin(value)`](#fn-withlogin) +* [`fn withName(value)`](#fn-withname) +* [`fn withOrgId(value)`](#fn-withorgid) +* [`fn withRole(value)`](#fn-withrole) +* [`fn withTeams(value)`](#fn-withteams) +* [`fn withTeamsMixin(value)`](#fn-withteamsmixin) +* [`fn withTokens(value)`](#fn-withtokens) + +## Fields + +### fn withAccessControl + +```jsonnet +withAccessControl(value) +``` + +PARAMETERS: + +* **value** (`object`) + +AccessControl metadata associated with a given resource. +### fn withAccessControlMixin + +```jsonnet +withAccessControlMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +AccessControl metadata associated with a given resource. +### fn withAvatarUrl + +```jsonnet +withAvatarUrl(value) +``` + +PARAMETERS: + +* **value** (`string`) + +AvatarUrl is the service account's avatar URL. It allows the frontend to display a picture in front +of the service account. +### fn withId + +```jsonnet +withId(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +ID is the unique identifier of the service account in the database. +### fn withIsDisabled + +```jsonnet +withIsDisabled(value=true) +``` + +PARAMETERS: + +* **value** (`boolean`) + - default value: `true` + +IsDisabled indicates if the service account is disabled. +### fn withLogin + +```jsonnet +withLogin(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Login of the service account. +### fn withName + +```jsonnet +withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of the service account. +### fn withOrgId + +```jsonnet +withOrgId(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +OrgId is the ID of an organisation the service account belongs to. +### fn withRole + +```jsonnet +withRole(value) +``` + +PARAMETERS: + +* **value** (`string`) + - valid values: `"Admin"`, `"Editor"`, `"Viewer"` + +OrgRole is a Grafana Organization Role which can be 'Viewer', 'Editor', 'Admin'. +### fn withTeams + +```jsonnet +withTeams(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Teams is a list of teams the service account belongs to. +### fn withTeamsMixin + +```jsonnet +withTeamsMixin(value) +``` + +PARAMETERS: + +* **value** (`array`) + +Teams is a list of teams the service account belongs to. +### fn withTokens + +```jsonnet +withTokens(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +Tokens is the number of active tokens for the service account. +Tokens are used to authenticate the service account against Grafana. \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/team.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/team.md new file mode 100644 index 0000000000..c15a0cd98a --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/team.md @@ -0,0 +1,105 @@ +# team + +grafonnet.team + +## Index + +* [`fn withAccessControl(value)`](#fn-withaccesscontrol) +* [`fn withAccessControlMixin(value)`](#fn-withaccesscontrolmixin) +* [`fn withAvatarUrl(value)`](#fn-withavatarurl) +* [`fn withEmail(value)`](#fn-withemail) +* [`fn withMemberCount(value)`](#fn-withmembercount) +* [`fn withName(value)`](#fn-withname) +* [`fn withOrgId(value)`](#fn-withorgid) +* [`fn withPermission(value)`](#fn-withpermission) + +## Fields + +### fn withAccessControl + +```jsonnet +withAccessControl(value) +``` + +PARAMETERS: + +* **value** (`object`) + +AccessControl metadata associated with a given resource. +### fn withAccessControlMixin + +```jsonnet +withAccessControlMixin(value) +``` + +PARAMETERS: + +* **value** (`object`) + +AccessControl metadata associated with a given resource. +### fn withAvatarUrl + +```jsonnet +withAvatarUrl(value) +``` + +PARAMETERS: + +* **value** (`string`) + +AvatarUrl is the team's avatar URL. +### fn withEmail + +```jsonnet +withEmail(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Email of the team. +### fn withMemberCount + +```jsonnet +withMemberCount(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +MemberCount is the number of the team members. +### fn withName + +```jsonnet +withName(value) +``` + +PARAMETERS: + +* **value** (`string`) + +Name of the team. +### fn withOrgId + +```jsonnet +withOrgId(value) +``` + +PARAMETERS: + +* **value** (`integer`) + +OrgId is the ID of an organisation the team belongs to. +### fn withPermission + +```jsonnet +withPermission(value) +``` + +PARAMETERS: + +* **value** (`integer`) + - valid values: `0`, `1`, `2`, `4` + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/util.md b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/util.md new file mode 100644 index 0000000000..2e140363fc --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/docs/util.md @@ -0,0 +1,115 @@ +# util + +Helper functions that work well with Grafonnet. + +## Index + +* [`obj dashboard`](#obj-dashboard) + * [`fn getOptionsForCustomQuery(query)`](#fn-dashboardgetoptionsforcustomquery) +* [`obj grid`](#obj-grid) + * [`fn makeGrid(panels, panelWidth, panelHeight, startY)`](#fn-gridmakegrid) + * [`fn wrapPanels(panels, panelWidth, panelHeight, startY)`](#fn-gridwrappanels) +* [`obj panel`](#obj-panel) + * [`fn setPanelIDs(panels)`](#fn-panelsetpanelids) +* [`obj string`](#obj-string) + * [`fn slugify(string)`](#fn-stringslugify) + +## Fields + +### obj dashboard + + +#### fn dashboard.getOptionsForCustomQuery + +```jsonnet +dashboard.getOptionsForCustomQuery(query) +``` + +PARAMETERS: + +* **query** (`string`) + +`getOptionsForCustomQuery` provides values for the `options` and `current` fields. +These are required for template variables of type 'custom'but do not automatically +get populated by Grafana when importing a dashboard from JSON. + +This is a bit of a hack and should always be called on functions that set `type` on +a template variable. Ideally Grafana populates these fields from the `query` value +but this provides a backwards compatible solution. + +### obj grid + + +#### fn grid.makeGrid + +```jsonnet +grid.makeGrid(panels, panelWidth, panelHeight, startY) +``` + +PARAMETERS: + +* **panels** (`array`) +* **panelWidth** (`number`) +* **panelHeight** (`number`) +* **startY** (`number`) + +`makeGrid` returns an array of `panels` organized in a grid with equal `panelWidth` +and `panelHeight`. Row panels are used as "linebreaks", if a Row panel is collapsed, +then all panels below it will be folded into the row. + +This function will use the full grid of 24 columns, setting `panelWidth` to a value +that can divide 24 into equal parts will fill up the page nicely. (1, 2, 3, 4, 6, 8, 12) +Other value for `panelWidth` will leave a gap on the far right. + +Optional `startY` can be provided to place generated grid above or below existing panels. + +#### fn grid.wrapPanels + +```jsonnet +grid.wrapPanels(panels, panelWidth, panelHeight, startY) +``` + +PARAMETERS: + +* **panels** (`array`) +* **panelWidth** (`number`) +* **panelHeight** (`number`) +* **startY** (`number`) + +`wrapPanels` returns an array of `panels` organized in a grid, wrapping up to next 'row' if total width exceeds full grid of 24 columns. +'panelHeight' and 'panelWidth' are used unless panels already have height and width defined. + +### obj panel + + +#### fn panel.setPanelIDs + +```jsonnet +panel.setPanelIDs(panels) +``` + +PARAMETERS: + +* **panels** (`array`) + +`setPanelIDs` ensures that all `panels` have a unique ID, this functions is used in +`dashboard.withPanels` and `dashboard.withPanelsMixin` to provide a consistent +experience. + +used in ../dashboard.libsonnet + +### obj string + + +#### fn string.slugify + +```jsonnet +string.slugify(string) +``` + +PARAMETERS: + +* **string** (`string`) + +`slugify` will create a simple slug from `string`, keeping only alphanumeric +characters and replacing spaces with dashes. diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/jsonnetfile.json b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/jsonnetfile.json new file mode 100644 index 0000000000..8479d5a931 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/jsonnetfile.json @@ -0,0 +1,24 @@ +{ + "dependencies": [ + { + "source": { + "git": { + "remote": "https://github.com/jsonnet-libs/docsonnet.git", + "subdir": "doc-util" + } + }, + "version": "master" + }, + { + "source": { + "git": { + "remote": "https://github.com/jsonnet-libs/xtd.git", + "subdir": "" + } + }, + "version": "master" + } + ], + "legacyImports": true, + "version": 1 +} \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/main.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/main.libsonnet new file mode 100644 index 0000000000..660b0abaed --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/main.libsonnet @@ -0,0 +1,24 @@ +// This file is generated, do not manually edit. +{ + '#': { + filename: 'main.libsonnet', + help: 'Jsonnet library for rendering Grafana resources\n## Install\n\n```\njb install github.com/grafana/grafonnet/gen/grafonnet-v10.0.0@main\n```\n\n## Usage\n\n```jsonnet\nlocal grafonnet = import "github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/main.libsonnet"\n```\n', + 'import': 'github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/main.libsonnet', + installTemplate: '\n## Install\n\n```\njb install %(url)s@%(version)s\n```\n', + name: 'grafonnet', + url: 'github.com/grafana/grafonnet/gen/grafonnet-v10.0.0', + usageTemplate: '\n## Usage\n\n```jsonnet\nlocal %(name)s = import "%(import)s"\n```\n', + version: 'main', + }, + dashboard: import 'clean/dashboard.libsonnet', + librarypanel: import 'raw/librarypanel.libsonnet', + playlist: import 'raw/playlist.libsonnet', + preferences: import 'raw/preferences.libsonnet', + publicdashboard: import 'raw/publicdashboard.libsonnet', + serviceaccount: import 'raw/serviceaccount.libsonnet', + team: import 'raw/team.libsonnet', + panel: import 'panel.libsonnet', + query: import 'query.libsonnet', + util: import 'custom/util/main.libsonnet', + alerting: import 'alerting.libsonnet', +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/panel.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/panel.libsonnet new file mode 100644 index 0000000000..3e3ea3f036 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/panel.libsonnet @@ -0,0 +1,31 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.panel', name: 'panel' }, + candlestick: import 'clean/panel/candlestick.libsonnet', + canvas: import 'clean/panel/canvas.libsonnet', + alertList: import 'clean/panel/alertList.libsonnet', + alertGroups: import 'clean/panel/alertGroups.libsonnet', + annotationsList: import 'clean/panel/annotationsList.libsonnet', + barChart: import 'clean/panel/barChart.libsonnet', + barGauge: import 'clean/panel/barGauge.libsonnet', + dashboardList: import 'clean/panel/dashboardList.libsonnet', + datagrid: import 'clean/panel/datagrid.libsonnet', + debug: import 'clean/panel/debug.libsonnet', + gauge: import 'clean/panel/gauge.libsonnet', + geomap: import 'clean/panel/geomap.libsonnet', + heatmap: import 'clean/panel/heatmap.libsonnet', + histogram: import 'clean/panel/histogram.libsonnet', + logs: import 'clean/panel/logs.libsonnet', + news: import 'clean/panel/news.libsonnet', + nodeGraph: import 'clean/panel/nodeGraph.libsonnet', + pieChart: import 'clean/panel/pieChart.libsonnet', + stat: import 'clean/panel/stat.libsonnet', + stateTimeline: import 'clean/panel/stateTimeline.libsonnet', + statusHistory: import 'clean/panel/statusHistory.libsonnet', + table: import 'clean/panel/table.libsonnet', + text: import 'clean/panel/text.libsonnet', + timeSeries: import 'clean/panel/timeSeries.libsonnet', + trend: import 'clean/panel/trend.libsonnet', + xyChart: import 'clean/panel/xyChart.libsonnet', + row: import 'raw/panel/row.libsonnet', +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/query.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/query.libsonnet new file mode 100644 index 0000000000..fbbe20cf0f --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/query.libsonnet @@ -0,0 +1,13 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.query', name: 'query' }, + azureMonitor: import 'raw/query/azureMonitor.libsonnet', + cloudWatch: import 'raw/query/cloudWatch.libsonnet', + elasticsearch: import 'raw/query/elasticsearch.libsonnet', + loki: import 'clean/query/loki.libsonnet', + parca: import 'raw/query/parca.libsonnet', + grafanaPyroscope: import 'raw/query/grafanaPyroscope.libsonnet', + prometheus: import 'clean/query/prometheus.libsonnet', + tempo: import 'clean/query/tempo.libsonnet', + testData: import 'raw/query/testData.libsonnet', +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/alerting/contactPoint.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/alerting/contactPoint.libsonnet new file mode 100644 index 0000000000..0298dfa68b --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/alerting/contactPoint.libsonnet @@ -0,0 +1,18 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.alerting.contactPoint', name: 'contactPoint' }, + '#withDisableResolveMessage': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withDisableResolveMessage(value=true): { disableResolveMessage: value }, + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Name is used as grouping key in the UI. Contact points with the\nsame name will be grouped in the UI.' } }, + withName(value): { name: value }, + '#withProvenance': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withProvenance(value): { provenance: value }, + '#withSettings': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettings(value): { settings: value }, + '#withSettingsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettingsMixin(value): { settings+: value }, + '#withType': { 'function': { args: [{ default: null, enums: ['alertmanager', ' dingding', ' discord', ' email', ' googlechat', ' kafka', ' line', ' opsgenie', ' pagerduty', ' pushover', ' sensugo', ' slack', ' teams', ' telegram', ' threema', ' victorops', ' webhook', ' wecom'], name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + '#withUid': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'UID is the unique identifier of the contact point. The UID can be\nset by the user.' } }, + withUid(value): { uid: value }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/alerting/messageTemplate.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/alerting/messageTemplate.libsonnet new file mode 100644 index 0000000000..edc2472963 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/alerting/messageTemplate.libsonnet @@ -0,0 +1,10 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.alerting.messageTemplate', name: 'messageTemplate' }, + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withName(value): { name: value }, + '#withProvenance': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withProvenance(value): { provenance: value }, + '#withTemplate': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withTemplate(value): { template: value }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/alerting/muteTiming.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/alerting/muteTiming.libsonnet new file mode 100644 index 0000000000..ced4beb0e9 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/alerting/muteTiming.libsonnet @@ -0,0 +1,68 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.alerting.muteTiming', name: 'muteTiming' }, + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withName(value): { name: value }, + '#withTimeIntervals': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTimeIntervals(value): { time_intervals: (if std.isArray(value) + then value + else [value]) }, + '#withTimeIntervalsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTimeIntervalsMixin(value): { time_intervals+: (if std.isArray(value) + then value + else [value]) }, + time_intervals+: + { + '#': { help: '', name: 'time_intervals' }, + '#withDaysOfMonth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withDaysOfMonth(value): { days_of_month: (if std.isArray(value) + then value + else [value]) }, + '#withDaysOfMonthMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withDaysOfMonthMixin(value): { days_of_month+: (if std.isArray(value) + then value + else [value]) }, + '#withLocation': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withLocation(value): { location: value }, + '#withMonths': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withMonths(value): { months: (if std.isArray(value) + then value + else [value]) }, + '#withMonthsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withMonthsMixin(value): { months+: (if std.isArray(value) + then value + else [value]) }, + '#withTimes': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTimes(value): { times: (if std.isArray(value) + then value + else [value]) }, + '#withTimesMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTimesMixin(value): { times+: (if std.isArray(value) + then value + else [value]) }, + times+: + { + '#': { help: '', name: 'times' }, + '#withFrom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withFrom(value): { from: value }, + '#withTo': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withTo(value): { to: value }, + }, + '#withWeekdays': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withWeekdays(value): { weekdays: (if std.isArray(value) + then value + else [value]) }, + '#withWeekdaysMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withWeekdaysMixin(value): { weekdays+: (if std.isArray(value) + then value + else [value]) }, + '#withYears': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withYears(value): { years: (if std.isArray(value) + then value + else [value]) }, + '#withYearsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withYearsMixin(value): { years+: (if std.isArray(value) + then value + else [value]) }, + }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/alerting/notificationPolicy.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/alerting/notificationPolicy.libsonnet new file mode 100644 index 0000000000..957c104280 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/alerting/notificationPolicy.libsonnet @@ -0,0 +1,84 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.alerting.notificationPolicy', name: 'notificationPolicy' }, + '#withContinue': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withContinue(value=true): { continue: value }, + '#withGroupBy': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withGroupBy(value): { group_by: (if std.isArray(value) + then value + else [value]) }, + '#withGroupByMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withGroupByMixin(value): { group_by+: (if std.isArray(value) + then value + else [value]) }, + '#withGroupInterval': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withGroupInterval(value): { group_interval: value }, + '#withGroupWait': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withGroupWait(value): { group_wait: value }, + '#withMatch': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Deprecated. Remove before v1.0 release.' } }, + withMatch(value): { match: value }, + '#withMatchMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Deprecated. Remove before v1.0 release.' } }, + withMatchMixin(value): { match+: value }, + '#withMatchRe': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'MatchRegexps represents a map of Regexp.' } }, + withMatchRe(value): { match_re: value }, + '#withMatchReMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'MatchRegexps represents a map of Regexp.' } }, + withMatchReMixin(value): { match_re+: value }, + '#withMatchers': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Matchers is a slice of Matchers that is sortable, implements Stringer, and\nprovides a Matches method to match a LabelSet against all Matchers in the\nslice. Note that some users of Matchers might require it to be sorted.' } }, + withMatchers(value): { matchers: (if std.isArray(value) + then value + else [value]) }, + '#withMatchersMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Matchers is a slice of Matchers that is sortable, implements Stringer, and\nprovides a Matches method to match a LabelSet against all Matchers in the\nslice. Note that some users of Matchers might require it to be sorted.' } }, + withMatchersMixin(value): { matchers+: (if std.isArray(value) + then value + else [value]) }, + matchers+: + { + '#': { help: '', name: 'matchers' }, + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withName(value): { Name: value }, + '#withType': { 'function': { args: [{ default: null, enums: ['=', '!=', '=~', '!~'], name: 'value', type: 'string' }], help: 'MatchType is an enum for label matching types.' } }, + withType(value): { Type: value }, + '#withValue': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withValue(value): { Value: value }, + }, + '#withMuteTimeIntervals': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withMuteTimeIntervals(value): { mute_time_intervals: (if std.isArray(value) + then value + else [value]) }, + '#withMuteTimeIntervalsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withMuteTimeIntervalsMixin(value): { mute_time_intervals+: (if std.isArray(value) + then value + else [value]) }, + '#withObjectMatchers': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Matchers is a slice of Matchers that is sortable, implements Stringer, and\nprovides a Matches method to match a LabelSet against all Matchers in the\nslice. Note that some users of Matchers might require it to be sorted.' } }, + withObjectMatchers(value): { object_matchers: (if std.isArray(value) + then value + else [value]) }, + '#withObjectMatchersMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Matchers is a slice of Matchers that is sortable, implements Stringer, and\nprovides a Matches method to match a LabelSet against all Matchers in the\nslice. Note that some users of Matchers might require it to be sorted.' } }, + withObjectMatchersMixin(value): { object_matchers+: (if std.isArray(value) + then value + else [value]) }, + object_matchers+: + { + '#': { help: '', name: 'object_matchers' }, + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withName(value): { Name: value }, + '#withType': { 'function': { args: [{ default: null, enums: ['=', '!=', '=~', '!~'], name: 'value', type: 'string' }], help: 'MatchType is an enum for label matching types.' } }, + withType(value): { Type: value }, + '#withValue': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withValue(value): { Value: value }, + }, + '#withProvenance': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withProvenance(value): { provenance: value }, + '#withReceiver': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withReceiver(value): { receiver: value }, + '#withRepeatInterval': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withRepeatInterval(value): { repeat_interval: value }, + '#withRoutes': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withRoutes(value): { routes: (if std.isArray(value) + then value + else [value]) }, + '#withRoutesMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withRoutesMixin(value): { routes+: (if std.isArray(value) + then value + else [value]) }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/alerting/ruleGroup.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/alerting/ruleGroup.libsonnet new file mode 100644 index 0000000000..e7dced96ae --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/alerting/ruleGroup.libsonnet @@ -0,0 +1,89 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.alerting.ruleGroup', name: 'ruleGroup' }, + '#withFolderUid': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withFolderUid(value): { folderUid: value }, + '#withInterval': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withInterval(value): { interval: value }, + '#withRules': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withRules(value): { rules: (if std.isArray(value) + then value + else [value]) }, + '#withRulesMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withRulesMixin(value): { rules+: (if std.isArray(value) + then value + else [value]) }, + rules+: + { + '#': { help: '', name: 'rules' }, + '#withAnnotations': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withAnnotations(value): { annotations: value }, + '#withAnnotationsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withAnnotationsMixin(value): { annotations+: value }, + '#withCondition': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withCondition(value): { condition: value }, + '#withData': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withData(value): { data: (if std.isArray(value) + then value + else [value]) }, + '#withDataMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withDataMixin(value): { data+: (if std.isArray(value) + then value + else [value]) }, + data+: + { + '#': { help: '', name: 'data' }, + '#withDatasourceUid': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: "Grafana data source unique identifier; it should be '__expr__' for a Server Side Expression operation." } }, + withDatasourceUid(value): { datasourceUid: value }, + '#withModel': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'JSON is the raw JSON query and includes the above properties as well as custom properties.' } }, + withModel(value): { model: value }, + '#withModelMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'JSON is the raw JSON query and includes the above properties as well as custom properties.' } }, + withModelMixin(value): { model+: value }, + '#withQueryType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'QueryType is an optional identifier for the type of query.\nIt can be used to distinguish different types of queries.' } }, + withQueryType(value): { queryType: value }, + '#withRefId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'RefID is the unique identifier of the query, set by the frontend call.' } }, + withRefId(value): { refId: value }, + '#withRelativeTimeRange': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'RelativeTimeRange is the per query start and end time\nfor requests.' } }, + withRelativeTimeRange(value): { relativeTimeRange: value }, + '#withRelativeTimeRangeMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'RelativeTimeRange is the per query start and end time\nfor requests.' } }, + withRelativeTimeRangeMixin(value): { relativeTimeRange+: value }, + relativeTimeRange+: + { + '#withFrom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'A Duration represents the elapsed time between two instants\nas an int64 nanosecond count. The representation limits the\nlargest representable duration to approximately 290 years.' } }, + withFrom(value): { relativeTimeRange+: { from: value } }, + '#withTo': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'A Duration represents the elapsed time between two instants\nas an int64 nanosecond count. The representation limits the\nlargest representable duration to approximately 290 years.' } }, + withTo(value): { relativeTimeRange+: { to: value } }, + }, + }, + '#withExecErrState': { 'function': { args: [{ default: null, enums: ['OK', 'Alerting', 'Error'], name: 'value', type: 'string' }], help: '' } }, + withExecErrState(value): { execErrState: value }, + '#withFolderUID': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withFolderUID(value): { folderUID: value }, + '#withFor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'A Duration represents the elapsed time between two instants\nas an int64 nanosecond count. The representation limits the\nlargest representable duration to approximately 290 years.' } }, + withFor(value): { 'for': value }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withId(value): { id: value }, + '#withIsPaused': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withIsPaused(value=true): { isPaused: value }, + '#withLabels': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withLabels(value): { labels: value }, + '#withLabelsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withLabelsMixin(value): { labels+: value }, + '#withNoDataState': { 'function': { args: [{ default: null, enums: ['Alerting', 'NoData', 'OK'], name: 'value', type: 'string' }], help: '' } }, + withNoDataState(value): { noDataState: value }, + '#withOrgID': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withOrgID(value): { orgID: value }, + '#withProvenance': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withProvenance(value): { provenance: value }, + '#withRuleGroup': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withRuleGroup(value): { ruleGroup: value }, + '#withTitle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withTitle(value): { title: value }, + '#withUid': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withUid(value): { uid: value }, + '#withUpdated': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withUpdated(value): { updated: value }, + }, + '#withTitle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withTitle(value): { title: value }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/dashboard.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/dashboard.libsonnet new file mode 100644 index 0000000000..491bd10d33 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/dashboard.libsonnet @@ -0,0 +1,299 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.dashboard', name: 'dashboard' }, + '#withAnnotations': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO -- should not be a public interface on its own, but required for Veneer' } }, + withAnnotations(value): { annotations: value }, + '#withAnnotationsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO -- should not be a public interface on its own, but required for Veneer' } }, + withAnnotationsMixin(value): { annotations+: value }, + annotations+: + { + '#withList': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withList(value): { annotations+: { list: (if std.isArray(value) + then value + else [value]) } }, + '#withListMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withListMixin(value): { annotations+: { list+: (if std.isArray(value) + then value + else [value]) } }, + list+: + { + '#': { help: '', name: 'list' }, + '#withDatasource': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO: Should be DataSourceRef' } }, + withDatasource(value): { datasource: value }, + '#withDatasourceMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO: Should be DataSourceRef' } }, + withDatasourceMixin(value): { datasource+: value }, + datasource+: + { + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { datasource+: { type: value } }, + '#withUid': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withUid(value): { datasource+: { uid: value } }, + }, + '#withEnable': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'When enabled the annotation query is issued with every dashboard refresh' } }, + withEnable(value=true): { enable: value }, + '#withFilter': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withFilter(value): { filter: value }, + '#withFilterMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withFilterMixin(value): { filter+: value }, + filter+: + { + '#withExclude': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Should the specified panels be included or excluded' } }, + withExclude(value=true): { filter+: { exclude: value } }, + '#withIds': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Panel IDs that should be included or excluded' } }, + withIds(value): { filter+: { ids: (if std.isArray(value) + then value + else [value]) } }, + '#withIdsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Panel IDs that should be included or excluded' } }, + withIdsMixin(value): { filter+: { ids+: (if std.isArray(value) + then value + else [value]) } }, + }, + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Annotation queries can be toggled on or off at the top of the dashboard.\nWhen hide is true, the toggle is not shown in the dashboard.' } }, + withHide(value=true): { hide: value }, + '#withIconColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Color to use for the annotation event markers' } }, + withIconColor(value): { iconColor: value }, + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Name of annotation.' } }, + withName(value): { name: value }, + '#withTarget': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO: this should be a regular DataQuery that depends on the selected dashboard\nthese match the properties of the "grafana" datasouce that is default in most dashboards' } }, + withTarget(value): { target: value }, + '#withTargetMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO: this should be a regular DataQuery that depends on the selected dashboard\nthese match the properties of the "grafana" datasouce that is default in most dashboards' } }, + withTargetMixin(value): { target+: value }, + target+: + { + '#withLimit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'Only required/valid for the grafana datasource...\nbut code+tests is already depending on it so hard to change' } }, + withLimit(value): { target+: { limit: value } }, + '#withMatchAny': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Only required/valid for the grafana datasource...\nbut code+tests is already depending on it so hard to change' } }, + withMatchAny(value=true): { target+: { matchAny: value } }, + '#withTags': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Only required/valid for the grafana datasource...\nbut code+tests is already depending on it so hard to change' } }, + withTags(value): { target+: { tags: (if std.isArray(value) + then value + else [value]) } }, + '#withTagsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Only required/valid for the grafana datasource...\nbut code+tests is already depending on it so hard to change' } }, + withTagsMixin(value): { target+: { tags+: (if std.isArray(value) + then value + else [value]) } }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Only required/valid for the grafana datasource...\nbut code+tests is already depending on it so hard to change' } }, + withType(value): { target+: { type: value } }, + }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'TODO -- this should not exist here, it is based on the --grafana-- datasource' } }, + withType(value): { type: value }, + }, + }, + '#withDescription': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Description of dashboard.' } }, + withDescription(value): { description: value }, + '#withEditable': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Whether a dashboard is editable or not.' } }, + withEditable(value=true): { editable: value }, + '#withFiscalYearStartMonth': { 'function': { args: [{ default: 0, enums: null, name: 'value', type: 'integer' }], help: 'The month that the fiscal year starts on. 0 = January, 11 = December' } }, + withFiscalYearStartMonth(value=0): { fiscalYearStartMonth: value }, + '#withGnetId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'For dashboards imported from the https://grafana.com/grafana/dashboards/ portal' } }, + withGnetId(value): { gnetId: value }, + '#withGraphTooltip': { 'function': { args: [{ default: 0, enums: [0, 1, 2], name: 'value', type: 'integer' }], help: '0 for no shared crosshair or tooltip (default).\n1 for shared crosshair.\n2 for shared crosshair AND shared tooltip.' } }, + withGraphTooltip(value=0): { graphTooltip: value }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'Unique numeric identifier for the dashboard.\nTODO must isolate or remove identifiers local to a Grafana instance...?' } }, + withId(value): { id: value }, + '#withLinks': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'TODO docs' } }, + withLinks(value): { links: (if std.isArray(value) + then value + else [value]) }, + '#withLinksMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'TODO docs' } }, + withLinksMixin(value): { links+: (if std.isArray(value) + then value + else [value]) }, + links+: + { + '#': { help: '', name: 'links' }, + '#withAsDropdown': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAsDropdown(value=true): { asDropdown: value }, + '#withIcon': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withIcon(value): { icon: value }, + '#withIncludeVars': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withIncludeVars(value=true): { includeVars: value }, + '#withKeepTime': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withKeepTime(value=true): { keepTime: value }, + '#withTags': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTags(value): { tags: (if std.isArray(value) + then value + else [value]) }, + '#withTagsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTagsMixin(value): { tags+: (if std.isArray(value) + then value + else [value]) }, + '#withTargetBlank': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withTargetBlank(value=true): { targetBlank: value }, + '#withTitle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withTitle(value): { title: value }, + '#withTooltip': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withTooltip(value): { tooltip: value }, + '#withType': { 'function': { args: [{ default: null, enums: ['link', 'dashboards'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withType(value): { type: value }, + '#withUrl': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withUrl(value): { url: value }, + }, + '#withLiveNow': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'When set to true, the dashboard will redraw panels at an interval matching the pixel width.\nThis will keep data "moving left" regardless of the query refresh rate. This setting helps\navoid dashboards presenting stale live data' } }, + withLiveNow(value=true): { liveNow: value }, + '#withPanels': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withPanels(value): { panels: (if std.isArray(value) + then value + else [value]) }, + '#withPanelsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withPanelsMixin(value): { panels+: (if std.isArray(value) + then value + else [value]) }, + '#withRefresh': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Refresh rate of dashboard. Represented via interval string, e.g. "5s", "1m", "1h", "1d".' } }, + withRefresh(value): { refresh: value }, + '#withRefreshMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Refresh rate of dashboard. Represented via interval string, e.g. "5s", "1m", "1h", "1d".' } }, + withRefreshMixin(value): { refresh+: value }, + '#withRevision': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'This property should only be used in dashboards defined by plugins. It is a quick check\nto see if the version has changed since the last time. Unclear why using the version property\nis insufficient.' } }, + withRevision(value): { revision: value }, + '#withSchemaVersion': { 'function': { args: [{ default: 36, enums: null, name: 'value', type: 'integer' }], help: "Version of the JSON schema, incremented each time a Grafana update brings\nchanges to said schema.\nTODO this is the existing schema numbering system. It will be replaced by Thema's themaVersion" } }, + withSchemaVersion(value=36): { schemaVersion: value }, + '#withSnapshot': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withSnapshot(value): { snapshot: value }, + '#withSnapshotMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withSnapshotMixin(value): { snapshot+: value }, + snapshot+: + { + '#withCreated': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'TODO docs' } }, + withCreated(value): { snapshot+: { created: value } }, + '#withExpires': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'TODO docs' } }, + withExpires(value): { snapshot+: { expires: value } }, + '#withExternal': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'TODO docs' } }, + withExternal(value=true): { snapshot+: { external: value } }, + '#withExternalUrl': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'TODO docs' } }, + withExternalUrl(value): { snapshot+: { externalUrl: value } }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'TODO docs' } }, + withId(value): { snapshot+: { id: value } }, + '#withKey': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'TODO docs' } }, + withKey(value): { snapshot+: { key: value } }, + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'TODO docs' } }, + withName(value): { snapshot+: { name: value } }, + '#withOrgId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'TODO docs' } }, + withOrgId(value): { snapshot+: { orgId: value } }, + '#withUpdated': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'TODO docs' } }, + withUpdated(value): { snapshot+: { updated: value } }, + '#withUrl': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'TODO docs' } }, + withUrl(value): { snapshot+: { url: value } }, + '#withUserId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'TODO docs' } }, + withUserId(value): { snapshot+: { userId: value } }, + }, + '#withStyle': { 'function': { args: [{ default: 'dark', enums: ['dark', 'light'], name: 'value', type: 'string' }], help: 'Theme of dashboard.' } }, + withStyle(value='dark'): { style: value }, + '#withTags': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Tags associated with dashboard.' } }, + withTags(value): { tags: (if std.isArray(value) + then value + else [value]) }, + '#withTagsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Tags associated with dashboard.' } }, + withTagsMixin(value): { tags+: (if std.isArray(value) + then value + else [value]) }, + '#withTemplating': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTemplating(value): { templating: value }, + '#withTemplatingMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTemplatingMixin(value): { templating+: value }, + templating+: + { + '#withList': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withList(value): { templating+: { list: (if std.isArray(value) + then value + else [value]) } }, + '#withListMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withListMixin(value): { templating+: { list+: (if std.isArray(value) + then value + else [value]) } }, + list+: + { + '#': { help: '', name: 'list' }, + '#withDatasource': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Ref to a DataSource instance' } }, + withDatasource(value): { datasource: value }, + '#withDatasourceMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Ref to a DataSource instance' } }, + withDatasourceMixin(value): { datasource+: value }, + datasource+: + { + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The plugin type-id' } }, + withType(value): { datasource+: { type: value } }, + '#withUid': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Specific datasource instance' } }, + withUid(value): { datasource+: { uid: value } }, + }, + '#withDescription': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withDescription(value): { description: value }, + '#withError': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withError(value): { 'error': value }, + '#withErrorMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withErrorMixin(value): { 'error'+: value }, + '#withGlobal': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withGlobal(value=true): { global: value }, + '#withHide': { 'function': { args: [{ default: null, enums: [0, 1, 2], name: 'value', type: 'integer' }], help: '' } }, + withHide(value): { hide: value }, + '#withId': { 'function': { args: [{ default: '00000000-0000-0000-0000-000000000000', enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value='00000000-0000-0000-0000-000000000000'): { id: value }, + '#withIndex': { 'function': { args: [{ default: -1, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withIndex(value=-1): { index: value }, + '#withLabel': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withLabel(value): { label: value }, + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withName(value): { name: value }, + '#withQuery': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'TODO: Move this into a separated QueryVariableModel type' } }, + withQuery(value): { query: value }, + '#withQueryMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'TODO: Move this into a separated QueryVariableModel type' } }, + withQueryMixin(value): { query+: value }, + '#withRootStateKey': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withRootStateKey(value): { rootStateKey: value }, + '#withSkipUrlSync': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withSkipUrlSync(value=true): { skipUrlSync: value }, + '#withState': { 'function': { args: [{ default: null, enums: ['NotStarted', 'Loading', 'Streaming', 'Done', 'Error'], name: 'value', type: 'string' }], help: '' } }, + withState(value): { state: value }, + '#withType': { 'function': { args: [{ default: null, enums: ['query', 'adhoc', 'constant', 'datasource', 'interval', 'textbox', 'custom', 'system'], name: 'value', type: 'string' }], help: 'FROM: packages/grafana-data/src/types/templateVars.ts\nTODO docs\nTODO this implies some wider pattern/discriminated union, probably?' } }, + withType(value): { type: value }, + }, + }, + '#withTime': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Time range for dashboard, e.g. last 6 hours, last 7 days, etc' } }, + withTime(value): { time: value }, + '#withTimeMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Time range for dashboard, e.g. last 6 hours, last 7 days, etc' } }, + withTimeMixin(value): { time+: value }, + time+: + { + '#withFrom': { 'function': { args: [{ default: 'now-6h', enums: null, name: 'value', type: 'string' }], help: '' } }, + withFrom(value='now-6h'): { time+: { from: value } }, + '#withTo': { 'function': { args: [{ default: 'now', enums: null, name: 'value', type: 'string' }], help: '' } }, + withTo(value='now'): { time+: { to: value } }, + }, + '#withTimepicker': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs\nTODO this appears to be spread all over in the frontend. Concepts will likely need tidying in tandem with schema changes' } }, + withTimepicker(value): { timepicker: value }, + '#withTimepickerMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs\nTODO this appears to be spread all over in the frontend. Concepts will likely need tidying in tandem with schema changes' } }, + withTimepickerMixin(value): { timepicker+: value }, + timepicker+: + { + '#withCollapse': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Whether timepicker is collapsed or not.' } }, + withCollapse(value=true): { timepicker+: { collapse: value } }, + '#withEnable': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Whether timepicker is enabled or not.' } }, + withEnable(value=true): { timepicker+: { enable: value } }, + '#withHidden': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Whether timepicker is visible or not.' } }, + withHidden(value=true): { timepicker+: { hidden: value } }, + '#withRefreshIntervals': { 'function': { args: [{ default: ['5s', '10s', '30s', '1m', '5m', '15m', '30m', '1h', '2h', '1d'], enums: null, name: 'value', type: 'array' }], help: 'Selectable intervals for auto-refresh.' } }, + withRefreshIntervals(value): { timepicker+: { refresh_intervals: (if std.isArray(value) + then value + else [value]) } }, + '#withRefreshIntervalsMixin': { 'function': { args: [{ default: ['5s', '10s', '30s', '1m', '5m', '15m', '30m', '1h', '2h', '1d'], enums: null, name: 'value', type: 'array' }], help: 'Selectable intervals for auto-refresh.' } }, + withRefreshIntervalsMixin(value): { timepicker+: { refresh_intervals+: (if std.isArray(value) + then value + else [value]) } }, + '#withTimeOptions': { 'function': { args: [{ default: ['5m', '15m', '1h', '6h', '12h', '24h', '2d', '7d', '30d'], enums: null, name: 'value', type: 'array' }], help: 'TODO docs' } }, + withTimeOptions(value): { timepicker+: { time_options: (if std.isArray(value) + then value + else [value]) } }, + '#withTimeOptionsMixin': { 'function': { args: [{ default: ['5m', '15m', '1h', '6h', '12h', '24h', '2d', '7d', '30d'], enums: null, name: 'value', type: 'array' }], help: 'TODO docs' } }, + withTimeOptionsMixin(value): { timepicker+: { time_options+: (if std.isArray(value) + then value + else [value]) } }, + }, + '#withTimezone': { 'function': { args: [{ default: 'browser', enums: null, name: 'value', type: 'string' }], help: 'Timezone of dashboard. Accepts IANA TZDB zone ID or "browser" or "utc".' } }, + withTimezone(value='browser'): { timezone: value }, + '#withTitle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Title of dashboard.' } }, + withTitle(value): { title: value }, + '#withUid': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Unique dashboard identifier that can be generated by anyone. string (8-40)' } }, + withUid(value): { uid: value }, + '#withVersion': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'Version of the dashboard, incremented each time the dashboard is updated.' } }, + withVersion(value): { version: value }, + '#withWeekStart': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'TODO docs' } }, + withWeekStart(value): { weekStart: value }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/librarypanel.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/librarypanel.libsonnet new file mode 100644 index 0000000000..f3e4255a13 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/librarypanel.libsonnet @@ -0,0 +1,65 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.librarypanel', name: 'librarypanel' }, + '#withDescription': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Panel description' } }, + withDescription(value): { description: value }, + '#withFolderUid': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Folder UID' } }, + withFolderUid(value): { folderUid: value }, + '#withMeta': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withMeta(value): { meta: value }, + '#withMetaMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withMetaMixin(value): { meta+: value }, + meta+: + { + '#withConnectedDashboards': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withConnectedDashboards(value): { meta+: { connectedDashboards: value } }, + '#withCreated': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withCreated(value): { meta+: { created: value } }, + '#withCreatedBy': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withCreatedBy(value): { meta+: { createdBy: value } }, + '#withCreatedByMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withCreatedByMixin(value): { meta+: { createdBy+: value } }, + createdBy+: + { + '#withAvatarUrl': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withAvatarUrl(value): { meta+: { createdBy+: { avatarUrl: value } } }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withId(value): { meta+: { createdBy+: { id: value } } }, + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withName(value): { meta+: { createdBy+: { name: value } } }, + }, + '#withFolderName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withFolderName(value): { meta+: { folderName: value } }, + '#withFolderUid': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withFolderUid(value): { meta+: { folderUid: value } }, + '#withUpdated': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withUpdated(value): { meta+: { updated: value } }, + '#withUpdatedBy': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withUpdatedBy(value): { meta+: { updatedBy: value } }, + '#withUpdatedByMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withUpdatedByMixin(value): { meta+: { updatedBy+: value } }, + updatedBy+: + { + '#withAvatarUrl': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withAvatarUrl(value): { meta+: { updatedBy+: { avatarUrl: value } } }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withId(value): { meta+: { updatedBy+: { id: value } } }, + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withName(value): { meta+: { updatedBy+: { name: value } } }, + }, + }, + '#withModel': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: "TODO: should be the same panel schema defined in dashboard\nTypescript: Omit;" } }, + withModel(value): { model: value }, + '#withModelMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: "TODO: should be the same panel schema defined in dashboard\nTypescript: Omit;" } }, + withModelMixin(value): { model+: value }, + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Panel name (also saved in the model)' } }, + withName(value): { name: value }, + '#withSchemaVersion': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'Dashboard version when this was saved (zero if unknown)' } }, + withSchemaVersion(value): { schemaVersion: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The panel type (from inside the model)' } }, + withType(value): { type: value }, + '#withUid': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Library element UID' } }, + withUid(value): { uid: value }, + '#withVersion': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'panel version, incremented each time the dashboard is updated.' } }, + withVersion(value): { version: value }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel.libsonnet new file mode 100644 index 0000000000..bb87b410e2 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel.libsonnet @@ -0,0 +1,413 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.panel', name: 'panel' }, + '#withDatasource': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'The datasource used in all targets.' } }, + withDatasource(value): { datasource: value }, + '#withDatasourceMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'The datasource used in all targets.' } }, + withDatasourceMixin(value): { datasource+: value }, + datasource+: + { + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { datasource+: { type: value } }, + '#withUid': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withUid(value): { datasource+: { uid: value } }, + }, + '#withDescription': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Description.' } }, + withDescription(value): { description: value }, + '#withFieldConfig': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withFieldConfig(value): { fieldConfig: value }, + '#withFieldConfigMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withFieldConfigMixin(value): { fieldConfig+: value }, + fieldConfig+: + { + '#withDefaults': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withDefaults(value): { fieldConfig+: { defaults: value } }, + '#withDefaultsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withDefaultsMixin(value): { fieldConfig+: { defaults+: value } }, + defaults+: + { + '#withColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withColor(value): { fieldConfig+: { defaults+: { color: value } } }, + '#withColorMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withColorMixin(value): { fieldConfig+: { defaults+: { color+: value } } }, + color+: + { + '#withFixedColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Stores the fixed color value if mode is fixed' } }, + withFixedColor(value): { fieldConfig+: { defaults+: { color+: { fixedColor: value } } } }, + '#withMode': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The main color scheme mode' } }, + withMode(value): { fieldConfig+: { defaults+: { color+: { mode: value } } } }, + '#withSeriesBy': { 'function': { args: [{ default: null, enums: ['min', 'max', 'last'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withSeriesBy(value): { fieldConfig+: { defaults+: { color+: { seriesBy: value } } } }, + }, + '#withCustom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'custom is specified by the PanelFieldConfig field\nin panel plugin schemas.' } }, + withCustom(value): { fieldConfig+: { defaults+: { custom: value } } }, + '#withCustomMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'custom is specified by the PanelFieldConfig field\nin panel plugin schemas.' } }, + withCustomMixin(value): { fieldConfig+: { defaults+: { custom+: value } } }, + '#withDecimals': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Significant digits (for display)' } }, + withDecimals(value): { fieldConfig+: { defaults+: { decimals: value } } }, + '#withDescription': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Human readable field metadata' } }, + withDescription(value): { fieldConfig+: { defaults+: { description: value } } }, + '#withDisplayName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The display value for this field. This supports template variables blank is auto' } }, + withDisplayName(value): { fieldConfig+: { defaults+: { displayName: value } } }, + '#withDisplayNameFromDS': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'This can be used by data sources that return and explicit naming structure for values and labels\nWhen this property is configured, this value is used rather than the default naming strategy.' } }, + withDisplayNameFromDS(value): { fieldConfig+: { defaults+: { displayNameFromDS: value } } }, + '#withFilterable': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'True if data source field supports ad-hoc filters' } }, + withFilterable(value=true): { fieldConfig+: { defaults+: { filterable: value } } }, + '#withLinks': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'The behavior when clicking on a result' } }, + withLinks(value): { fieldConfig+: { defaults+: { links: (if std.isArray(value) + then value + else [value]) } } }, + '#withLinksMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'The behavior when clicking on a result' } }, + withLinksMixin(value): { fieldConfig+: { defaults+: { links+: (if std.isArray(value) + then value + else [value]) } } }, + '#withMappings': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Convert input values into a display string' } }, + withMappings(value): { fieldConfig+: { defaults+: { mappings: (if std.isArray(value) + then value + else [value]) } } }, + '#withMappingsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Convert input values into a display string' } }, + withMappingsMixin(value): { fieldConfig+: { defaults+: { mappings+: (if std.isArray(value) + then value + else [value]) } } }, + mappings+: + { + '#': { help: '', name: 'mappings' }, + ValueMap+: + { + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptions(value): { options: value }, + '#withOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptionsMixin(value): { options+: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + }, + RangeMap+: + { + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptions(value): { options: value }, + '#withOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptionsMixin(value): { options+: value }, + options+: + { + '#withFrom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'to and from are `number | null` in current ts, really not sure what to do' } }, + withFrom(value): { options+: { from: value } }, + '#withResult': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withResult(value): { options+: { result: value } }, + '#withResultMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withResultMixin(value): { options+: { result+: value } }, + result+: + { + '#withColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withColor(value): { options+: { result+: { color: value } } }, + '#withIcon': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withIcon(value): { options+: { result+: { icon: value } } }, + '#withIndex': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withIndex(value): { options+: { result+: { index: value } } }, + '#withText': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withText(value): { options+: { result+: { text: value } } }, + }, + '#withTo': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withTo(value): { options+: { to: value } }, + }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + }, + RegexMap+: + { + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptions(value): { options: value }, + '#withOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptionsMixin(value): { options+: value }, + options+: + { + '#withPattern': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withPattern(value): { options+: { pattern: value } }, + '#withResult': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withResult(value): { options+: { result: value } }, + '#withResultMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withResultMixin(value): { options+: { result+: value } }, + result+: + { + '#withColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withColor(value): { options+: { result+: { color: value } } }, + '#withIcon': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withIcon(value): { options+: { result+: { icon: value } } }, + '#withIndex': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withIndex(value): { options+: { result+: { index: value } } }, + '#withText': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withText(value): { options+: { result+: { text: value } } }, + }, + }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + }, + SpecialValueMap+: + { + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptions(value): { options: value }, + '#withOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptionsMixin(value): { options+: value }, + options+: + { + '#withMatch': { 'function': { args: [{ default: null, enums: ['true', 'false'], name: 'value', type: 'string' }], help: '' } }, + withMatch(value): { options+: { match: value } }, + '#withPattern': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withPattern(value): { options+: { pattern: value } }, + '#withResult': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withResult(value): { options+: { result: value } }, + '#withResultMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withResultMixin(value): { options+: { result+: value } }, + result+: + { + '#withColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withColor(value): { options+: { result+: { color: value } } }, + '#withIcon': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withIcon(value): { options+: { result+: { icon: value } } }, + '#withIndex': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withIndex(value): { options+: { result+: { index: value } } }, + '#withText': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withText(value): { options+: { result+: { text: value } } }, + }, + }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + }, + }, + '#withMax': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withMax(value): { fieldConfig+: { defaults+: { max: value } } }, + '#withMin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withMin(value): { fieldConfig+: { defaults+: { min: value } } }, + '#withNoValue': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Alternative to empty string' } }, + withNoValue(value): { fieldConfig+: { defaults+: { noValue: value } } }, + '#withPath': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'An explicit path to the field in the datasource. When the frame meta includes a path,\nThis will default to `${frame.meta.path}/${field.name}\n\nWhen defined, this value can be used as an identifier within the datasource scope, and\nmay be used to update the results' } }, + withPath(value): { fieldConfig+: { defaults+: { path: value } } }, + '#withThresholds': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withThresholds(value): { fieldConfig+: { defaults+: { thresholds: value } } }, + '#withThresholdsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withThresholdsMixin(value): { fieldConfig+: { defaults+: { thresholds+: value } } }, + thresholds+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['absolute', 'percentage'], name: 'value', type: 'string' }], help: '' } }, + withMode(value): { fieldConfig+: { defaults+: { thresholds+: { mode: value } } } }, + '#withSteps': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: "Must be sorted by 'value', first value is always -Infinity" } }, + withSteps(value): { fieldConfig+: { defaults+: { thresholds+: { steps: (if std.isArray(value) + then value + else [value]) } } } }, + '#withStepsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: "Must be sorted by 'value', first value is always -Infinity" } }, + withStepsMixin(value): { fieldConfig+: { defaults+: { thresholds+: { steps+: (if std.isArray(value) + then value + else [value]) } } } }, + steps+: + { + '#': { help: '', name: 'steps' }, + '#withColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'TODO docs' } }, + withColor(value): { color: value }, + '#withIndex': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'Threshold index, an old property that is not needed an should only appear in older dashboards' } }, + withIndex(value): { index: value }, + '#withState': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'TODO docs\nTODO are the values here enumerable into a disjunction?\nSome seem to be listed in typescript comment' } }, + withState(value): { state: value }, + '#withValue': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'TODO docs\nFIXME the corresponding typescript field is required/non-optional, but nulls currently appear here when serializing -Infinity to JSON' } }, + withValue(value): { value: value }, + }, + }, + '#withUnit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Numeric Options' } }, + withUnit(value): { fieldConfig+: { defaults+: { unit: value } } }, + '#withWriteable': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'True if data source can write a value to the path. Auth/authz are supported separately' } }, + withWriteable(value=true): { fieldConfig+: { defaults+: { writeable: value } } }, + }, + '#withOverrides': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withOverrides(value): { fieldConfig+: { overrides: (if std.isArray(value) + then value + else [value]) } }, + '#withOverridesMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withOverridesMixin(value): { fieldConfig+: { overrides+: (if std.isArray(value) + then value + else [value]) } }, + overrides+: + { + '#': { help: '', name: 'overrides' }, + '#withMatcher': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withMatcher(value): { matcher: value }, + '#withMatcherMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withMatcherMixin(value): { matcher+: value }, + matcher+: + { + '#withId': { 'function': { args: [{ default: '', enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value=''): { matcher+: { id: value } }, + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withOptions(value): { matcher+: { options: value } }, + }, + '#withProperties': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withProperties(value): { properties: (if std.isArray(value) + then value + else [value]) }, + '#withPropertiesMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withPropertiesMixin(value): { properties+: (if std.isArray(value) + then value + else [value]) }, + properties+: + { + '#': { help: '', name: 'properties' }, + '#withId': { 'function': { args: [{ default: '', enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value=''): { id: value }, + '#withValue': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withValue(value): { value: value }, + }, + }, + }, + '#withGridPos': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withGridPos(value): { gridPos: value }, + '#withGridPosMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withGridPosMixin(value): { gridPos+: value }, + gridPos+: + { + '#withH': { 'function': { args: [{ default: 9, enums: null, name: 'value', type: 'integer' }], help: 'Panel' } }, + withH(value=9): { gridPos+: { h: value } }, + '#withStatic': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'true if fixed' } }, + withStatic(value=true): { gridPos+: { static: value } }, + '#withW': { 'function': { args: [{ default: 12, enums: null, name: 'value', type: 'integer' }], help: 'Panel' } }, + withW(value=12): { gridPos+: { w: value } }, + '#withX': { 'function': { args: [{ default: 0, enums: null, name: 'value', type: 'integer' }], help: 'Panel x' } }, + withX(value=0): { gridPos+: { x: value } }, + '#withY': { 'function': { args: [{ default: 0, enums: null, name: 'value', type: 'integer' }], help: 'Panel y' } }, + withY(value=0): { gridPos+: { y: value } }, + }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'TODO docs' } }, + withId(value): { id: value }, + '#withInterval': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'TODO docs\nTODO tighter constraint' } }, + withInterval(value): { interval: value }, + '#withLibraryPanel': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withLibraryPanel(value): { libraryPanel: value }, + '#withLibraryPanelMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withLibraryPanelMixin(value): { libraryPanel+: value }, + libraryPanel+: + { + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withName(value): { libraryPanel+: { name: value } }, + '#withUid': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withUid(value): { libraryPanel+: { uid: value } }, + }, + '#withLinks': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Panel links.\nTODO fill this out - seems there are a couple variants?' } }, + withLinks(value): { links: (if std.isArray(value) + then value + else [value]) }, + '#withLinksMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Panel links.\nTODO fill this out - seems there are a couple variants?' } }, + withLinksMixin(value): { links+: (if std.isArray(value) + then value + else [value]) }, + links+: + { + '#': { help: '', name: 'links' }, + '#withAsDropdown': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAsDropdown(value=true): { asDropdown: value }, + '#withIcon': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withIcon(value): { icon: value }, + '#withIncludeVars': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withIncludeVars(value=true): { includeVars: value }, + '#withKeepTime': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withKeepTime(value=true): { keepTime: value }, + '#withTags': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTags(value): { tags: (if std.isArray(value) + then value + else [value]) }, + '#withTagsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTagsMixin(value): { tags+: (if std.isArray(value) + then value + else [value]) }, + '#withTargetBlank': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withTargetBlank(value=true): { targetBlank: value }, + '#withTitle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withTitle(value): { title: value }, + '#withTooltip': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withTooltip(value): { tooltip: value }, + '#withType': { 'function': { args: [{ default: null, enums: ['link', 'dashboards'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withType(value): { type: value }, + '#withUrl': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withUrl(value): { url: value }, + }, + '#withMaxDataPoints': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'TODO docs' } }, + withMaxDataPoints(value): { maxDataPoints: value }, + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'options is specified by the PanelOptions field in panel\nplugin schemas.' } }, + withOptions(value): { options: value }, + '#withOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'options is specified by the PanelOptions field in panel\nplugin schemas.' } }, + withOptionsMixin(value): { options+: value }, + '#withPluginVersion': { 'function': { args: [], help: '' } }, + withPluginVersion(): { pluginVersion: 'v10.0.0' }, + '#withRepeat': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Name of template variable to repeat for.' } }, + withRepeat(value): { repeat: value }, + '#withRepeatDirection': { 'function': { args: [{ default: 'h', enums: ['h', 'v'], name: 'value', type: 'string' }], help: "Direction to repeat in if 'repeat' is set.\n\"h\" for horizontal, \"v\" for vertical.\nTODO this is probably optional" } }, + withRepeatDirection(value='h'): { repeatDirection: value }, + '#withRepeatPanelId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'Id of the repeating panel.' } }, + withRepeatPanelId(value): { repeatPanelId: value }, + '#withTags': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'TODO docs' } }, + withTags(value): { tags: (if std.isArray(value) + then value + else [value]) }, + '#withTagsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'TODO docs' } }, + withTagsMixin(value): { tags+: (if std.isArray(value) + then value + else [value]) }, + '#withTargets': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'TODO docs' } }, + withTargets(value): { targets: (if std.isArray(value) + then value + else [value]) }, + '#withTargetsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'TODO docs' } }, + withTargetsMixin(value): { targets+: (if std.isArray(value) + then value + else [value]) }, + '#withThresholds': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'TODO docs - seems to be an old field from old dashboard alerts?' } }, + withThresholds(value): { thresholds: (if std.isArray(value) + then value + else [value]) }, + '#withThresholdsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'TODO docs - seems to be an old field from old dashboard alerts?' } }, + withThresholdsMixin(value): { thresholds+: (if std.isArray(value) + then value + else [value]) }, + '#withTimeFrom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'TODO docs\nTODO tighter constraint' } }, + withTimeFrom(value): { timeFrom: value }, + '#withTimeRegions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'TODO docs' } }, + withTimeRegions(value): { timeRegions: (if std.isArray(value) + then value + else [value]) }, + '#withTimeRegionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'TODO docs' } }, + withTimeRegionsMixin(value): { timeRegions+: (if std.isArray(value) + then value + else [value]) }, + '#withTimeShift': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'TODO docs\nTODO tighter constraint' } }, + withTimeShift(value): { timeShift: value }, + '#withTitle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Panel title.' } }, + withTitle(value): { title: value }, + '#withTransformations': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTransformations(value): { transformations: (if std.isArray(value) + then value + else [value]) }, + '#withTransformationsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTransformationsMixin(value): { transformations+: (if std.isArray(value) + then value + else [value]) }, + transformations+: + { + '#': { help: '', name: 'transformations' }, + '#withDisabled': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Disabled transformations are skipped' } }, + withDisabled(value=true): { disabled: value }, + '#withFilter': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withFilter(value): { filter: value }, + '#withFilterMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withFilterMixin(value): { filter+: value }, + filter+: + { + '#withId': { 'function': { args: [{ default: '', enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value=''): { filter+: { id: value } }, + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withOptions(value): { filter+: { options: value } }, + }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Unique identifier of transformer' } }, + withId(value): { id: value }, + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Options to be passed to the transformer\nValid options depend on the transformer id' } }, + withOptions(value): { options: value }, + }, + '#withTransparent': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Whether to display the panel without a background.' } }, + withTransparent(value=true): { transparent: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The panel plugin type id. May not be empty.' } }, + withType(value): { type: value }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/alertGroups.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/alertGroups.libsonnet new file mode 100644 index 0000000000..bbf840bc1a --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/alertGroups.libsonnet @@ -0,0 +1,19 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.panel.alertGroups', name: 'alertGroups' }, + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptions(value): { options: value }, + '#withOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptionsMixin(value): { options+: value }, + options+: + { + '#withAlertmanager': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Name of the alertmanager used as a source for alerts' } }, + withAlertmanager(value): { options+: { alertmanager: value } }, + '#withExpandAll': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Expand all alert groups by default' } }, + withExpandAll(value=true): { options+: { expandAll: value } }, + '#withLabels': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Comma-separated list of values used to filter alert results' } }, + withLabels(value): { options+: { labels: value } }, + }, + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'alertGroups' }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/alertList.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/alertList.libsonnet new file mode 100644 index 0000000000..14b01c54d8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/alertList.libsonnet @@ -0,0 +1,124 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.panel.alertList', name: 'alertList' }, + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withOptions(value): { options: value }, + '#withOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withOptionsMixin(value): { options+: value }, + options+: + { + '#withAlertListOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withAlertListOptions(value): { options+: { AlertListOptions: value } }, + '#withAlertListOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withAlertListOptionsMixin(value): { options+: { AlertListOptions+: value } }, + AlertListOptions+: + { + '#withAlertName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withAlertName(value): { options+: { alertName: value } }, + '#withDashboardAlerts': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withDashboardAlerts(value=true): { options+: { dashboardAlerts: value } }, + '#withDashboardTitle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withDashboardTitle(value): { options+: { dashboardTitle: value } }, + '#withFolderId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withFolderId(value): { options+: { folderId: value } }, + '#withMaxItems': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withMaxItems(value): { options+: { maxItems: value } }, + '#withShowOptions': { 'function': { args: [{ default: null, enums: ['current', 'changes'], name: 'value', type: 'string' }], help: '' } }, + withShowOptions(value): { options+: { showOptions: value } }, + '#withSortOrder': { 'function': { args: [{ default: null, enums: [1, 2, 3, 4, 5], name: 'value', type: 'number' }], help: '' } }, + withSortOrder(value): { options+: { sortOrder: value } }, + '#withStateFilter': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withStateFilter(value): { options+: { stateFilter: value } }, + '#withStateFilterMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withStateFilterMixin(value): { options+: { stateFilter+: value } }, + stateFilter+: + { + '#withAlerting': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAlerting(value=true): { options+: { stateFilter+: { alerting: value } } }, + '#withExecutionError': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withExecutionError(value=true): { options+: { stateFilter+: { execution_error: value } } }, + '#withNoData': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withNoData(value=true): { options+: { stateFilter+: { no_data: value } } }, + '#withOk': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withOk(value=true): { options+: { stateFilter+: { ok: value } } }, + '#withPaused': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withPaused(value=true): { options+: { stateFilter+: { paused: value } } }, + '#withPending': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withPending(value=true): { options+: { stateFilter+: { pending: value } } }, + }, + '#withTags': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTags(value): { options+: { tags: (if std.isArray(value) + then value + else [value]) } }, + '#withTagsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTagsMixin(value): { options+: { tags+: (if std.isArray(value) + then value + else [value]) } }, + }, + '#withUnifiedAlertListOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withUnifiedAlertListOptions(value): { options+: { UnifiedAlertListOptions: value } }, + '#withUnifiedAlertListOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withUnifiedAlertListOptionsMixin(value): { options+: { UnifiedAlertListOptions+: value } }, + UnifiedAlertListOptions+: + { + '#withAlertInstanceLabelFilter': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withAlertInstanceLabelFilter(value): { options+: { alertInstanceLabelFilter: value } }, + '#withAlertName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withAlertName(value): { options+: { alertName: value } }, + '#withDashboardAlerts': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withDashboardAlerts(value=true): { options+: { dashboardAlerts: value } }, + '#withDatasource': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withDatasource(value): { options+: { datasource: value } }, + '#withFolder': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withFolder(value): { options+: { folder: value } }, + '#withFolderMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withFolderMixin(value): { options+: { folder+: value } }, + folder+: + { + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withId(value): { options+: { folder+: { id: value } } }, + '#withTitle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withTitle(value): { options+: { folder+: { title: value } } }, + }, + '#withGroupBy': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withGroupBy(value): { options+: { groupBy: (if std.isArray(value) + then value + else [value]) } }, + '#withGroupByMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withGroupByMixin(value): { options+: { groupBy+: (if std.isArray(value) + then value + else [value]) } }, + '#withGroupMode': { 'function': { args: [{ default: null, enums: ['default', 'custom'], name: 'value', type: 'string' }], help: '' } }, + withGroupMode(value): { options+: { groupMode: value } }, + '#withMaxItems': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withMaxItems(value): { options+: { maxItems: value } }, + '#withShowInstances': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowInstances(value=true): { options+: { showInstances: value } }, + '#withSortOrder': { 'function': { args: [{ default: null, enums: [1, 2, 3, 4, 5], name: 'value', type: 'number' }], help: '' } }, + withSortOrder(value): { options+: { sortOrder: value } }, + '#withStateFilter': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withStateFilter(value): { options+: { stateFilter: value } }, + '#withStateFilterMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withStateFilterMixin(value): { options+: { stateFilter+: value } }, + stateFilter+: + { + '#withError': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withError(value=true): { options+: { stateFilter+: { 'error': value } } }, + '#withFiring': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withFiring(value=true): { options+: { stateFilter+: { firing: value } } }, + '#withInactive': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withInactive(value=true): { options+: { stateFilter+: { inactive: value } } }, + '#withNoData': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withNoData(value=true): { options+: { stateFilter+: { noData: value } } }, + '#withNormal': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withNormal(value=true): { options+: { stateFilter+: { normal: value } } }, + '#withPending': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withPending(value=true): { options+: { stateFilter+: { pending: value } } }, + }, + '#withViewMode': { 'function': { args: [{ default: null, enums: ['list', 'stat'], name: 'value', type: 'string' }], help: '' } }, + withViewMode(value): { options+: { viewMode: value } }, + }, + }, + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'alertlist' }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/annotationsList.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/annotationsList.libsonnet new file mode 100644 index 0000000000..d88a367852 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/annotationsList.libsonnet @@ -0,0 +1,39 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.panel.annotationsList', name: 'annotationsList' }, + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptions(value): { options: value }, + '#withOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptionsMixin(value): { options+: value }, + options+: + { + '#withLimit': { 'function': { args: [{ default: 10, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withLimit(value=10): { options+: { limit: value } }, + '#withNavigateAfter': { 'function': { args: [{ default: '10m', enums: null, name: 'value', type: 'string' }], help: '' } }, + withNavigateAfter(value='10m'): { options+: { navigateAfter: value } }, + '#withNavigateBefore': { 'function': { args: [{ default: '10m', enums: null, name: 'value', type: 'string' }], help: '' } }, + withNavigateBefore(value='10m'): { options+: { navigateBefore: value } }, + '#withNavigateToPanel': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withNavigateToPanel(value=true): { options+: { navigateToPanel: value } }, + '#withOnlyFromThisDashboard': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withOnlyFromThisDashboard(value=true): { options+: { onlyFromThisDashboard: value } }, + '#withOnlyInTimeRange': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withOnlyInTimeRange(value=true): { options+: { onlyInTimeRange: value } }, + '#withShowTags': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowTags(value=true): { options+: { showTags: value } }, + '#withShowTime': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowTime(value=true): { options+: { showTime: value } }, + '#withShowUser': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowUser(value=true): { options+: { showUser: value } }, + '#withTags': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTags(value): { options+: { tags: (if std.isArray(value) + then value + else [value]) } }, + '#withTagsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTagsMixin(value): { options+: { tags+: (if std.isArray(value) + then value + else [value]) } }, + }, + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'annolist' }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/barChart.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/barChart.libsonnet new file mode 100644 index 0000000000..5163d5f33a --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/barChart.libsonnet @@ -0,0 +1,168 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.panel.barChart', name: 'barChart' }, + '#withFieldConfig': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withFieldConfig(value): { fieldConfig: value }, + '#withFieldConfigMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withFieldConfigMixin(value): { fieldConfig+: value }, + fieldConfig+: + { + '#withDefaults': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withDefaults(value): { fieldConfig+: { defaults: value } }, + '#withDefaultsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withDefaultsMixin(value): { fieldConfig+: { defaults+: value } }, + defaults+: + { + '#withCustom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withCustom(value): { fieldConfig+: { defaults+: { custom: value } } }, + '#withCustomMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withCustomMixin(value): { fieldConfig+: { defaults+: { custom+: value } } }, + custom+: + { + '#withAxisCenteredZero': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAxisCenteredZero(value=true): { fieldConfig+: { defaults+: { custom+: { axisCenteredZero: value } } } }, + '#withAxisColorMode': { 'function': { args: [{ default: null, enums: ['text', 'series'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withAxisColorMode(value): { fieldConfig+: { defaults+: { custom+: { axisColorMode: value } } } }, + '#withAxisGridShow': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAxisGridShow(value=true): { fieldConfig+: { defaults+: { custom+: { axisGridShow: value } } } }, + '#withAxisLabel': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withAxisLabel(value): { fieldConfig+: { defaults+: { custom+: { axisLabel: value } } } }, + '#withAxisPlacement': { 'function': { args: [{ default: null, enums: ['auto', 'top', 'right', 'bottom', 'left', 'hidden'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withAxisPlacement(value): { fieldConfig+: { defaults+: { custom+: { axisPlacement: value } } } }, + '#withAxisSoftMax': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisSoftMax(value): { fieldConfig+: { defaults+: { custom+: { axisSoftMax: value } } } }, + '#withAxisSoftMin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisSoftMin(value): { fieldConfig+: { defaults+: { custom+: { axisSoftMin: value } } } }, + '#withAxisWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisWidth(value): { fieldConfig+: { defaults+: { custom+: { axisWidth: value } } } }, + '#withScaleDistribution': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistribution(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution: value } } } }, + '#withScaleDistributionMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistributionMixin(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: value } } } }, + scaleDistribution+: + { + '#withLinearThreshold': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLinearThreshold(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: { linearThreshold: value } } } } }, + '#withLog': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLog(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: { log: value } } } } }, + '#withType': { 'function': { args: [{ default: null, enums: ['linear', 'log', 'ordinal', 'symlog'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withType(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: { type: value } } } } }, + }, + '#withHideFrom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFrom(value): { fieldConfig+: { defaults+: { custom+: { hideFrom: value } } } }, + '#withHideFromMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFromMixin(value): { fieldConfig+: { defaults+: { custom+: { hideFrom+: value } } } }, + hideFrom+: + { + '#withLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withLegend(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { legend: value } } } } }, + '#withTooltip': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withTooltip(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { tooltip: value } } } } }, + '#withViz': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withViz(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { viz: value } } } } }, + }, + '#withFillOpacity': { 'function': { args: [{ default: 80, enums: null, name: 'value', type: 'integer' }], help: 'Controls the fill opacity of the bars.' } }, + withFillOpacity(value=80): { fieldConfig+: { defaults+: { custom+: { fillOpacity: value } } } }, + '#withGradientMode': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Set the mode of the gradient fill. Fill gradient is based on the line color. To change the color, use the standard color scheme field option.\nGradient appearance is influenced by the Fill opacity setting.' } }, + withGradientMode(value): { fieldConfig+: { defaults+: { custom+: { gradientMode: value } } } }, + '#withLineWidth': { 'function': { args: [{ default: 1, enums: null, name: 'value', type: 'integer' }], help: 'Controls line width of the bars.' } }, + withLineWidth(value=1): { fieldConfig+: { defaults+: { custom+: { lineWidth: value } } } }, + '#withThresholdsStyle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withThresholdsStyle(value): { fieldConfig+: { defaults+: { custom+: { thresholdsStyle: value } } } }, + '#withThresholdsStyleMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withThresholdsStyleMixin(value): { fieldConfig+: { defaults+: { custom+: { thresholdsStyle+: value } } } }, + thresholdsStyle+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['off', 'line', 'dashed', 'area', 'line+area', 'dashed+area', 'series'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withMode(value): { fieldConfig+: { defaults+: { custom+: { thresholdsStyle+: { mode: value } } } } }, + }, + }, + }, + }, + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptions(value): { options: value }, + '#withOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptionsMixin(value): { options+: value }, + options+: + { + '#withLegend': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLegend(value): { options+: { legend: value } }, + '#withLegendMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLegendMixin(value): { options+: { legend+: value } }, + legend+: + { + '#withAsTable': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAsTable(value=true): { options+: { legend+: { asTable: value } } }, + '#withCalcs': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withCalcs(value): { options+: { legend+: { calcs: (if std.isArray(value) + then value + else [value]) } } }, + '#withCalcsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withCalcsMixin(value): { options+: { legend+: { calcs+: (if std.isArray(value) + then value + else [value]) } } }, + '#withDisplayMode': { 'function': { args: [{ default: null, enums: ['list', 'table', 'hidden'], name: 'value', type: 'string' }], help: 'TODO docs\nNote: "hidden" needs to remain as an option for plugins compatibility' } }, + withDisplayMode(value): { options+: { legend+: { displayMode: value } } }, + '#withIsVisible': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withIsVisible(value=true): { options+: { legend+: { isVisible: value } } }, + '#withPlacement': { 'function': { args: [{ default: null, enums: ['bottom', 'right'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withPlacement(value): { options+: { legend+: { placement: value } } }, + '#withShowLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowLegend(value=true): { options+: { legend+: { showLegend: value } } }, + '#withSortBy': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withSortBy(value): { options+: { legend+: { sortBy: value } } }, + '#withSortDesc': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withSortDesc(value=true): { options+: { legend+: { sortDesc: value } } }, + '#withWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withWidth(value): { options+: { legend+: { width: value } } }, + }, + '#withTooltip': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTooltip(value): { options+: { tooltip: value } }, + '#withTooltipMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTooltipMixin(value): { options+: { tooltip+: value } }, + tooltip+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['single', 'multi', 'none'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withMode(value): { options+: { tooltip+: { mode: value } } }, + '#withSort': { 'function': { args: [{ default: null, enums: ['asc', 'desc', 'none'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withSort(value): { options+: { tooltip+: { sort: value } } }, + }, + '#withText': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withText(value): { options+: { text: value } }, + '#withTextMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTextMixin(value): { options+: { text+: value } }, + text+: + { + '#withTitleSize': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Explicit title text size' } }, + withTitleSize(value): { options+: { text+: { titleSize: value } } }, + '#withValueSize': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Explicit value text size' } }, + withValueSize(value): { options+: { text+: { valueSize: value } } }, + }, + '#withBarRadius': { 'function': { args: [{ default: 0, enums: null, name: 'value', type: 'number' }], help: 'Controls the radius of each bar.' } }, + withBarRadius(value=0): { options+: { barRadius: value } }, + '#withBarWidth': { 'function': { args: [{ default: 0.96999999999999997, enums: null, name: 'value', type: 'number' }], help: 'Controls the width of bars. 1 = Max width, 0 = Min width.' } }, + withBarWidth(value=0.96999999999999997): { options+: { barWidth: value } }, + '#withColorByField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Use the color value for a sibling field to color each bar value.' } }, + withColorByField(value): { options+: { colorByField: value } }, + '#withFullHighlight': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Enables mode which highlights the entire bar area and shows tooltip when cursor\nhovers over highlighted area' } }, + withFullHighlight(value=true): { options+: { fullHighlight: value } }, + '#withGroupWidth': { 'function': { args: [{ default: 0.69999999999999996, enums: null, name: 'value', type: 'number' }], help: 'Controls the width of groups. 1 = max with, 0 = min width.' } }, + withGroupWidth(value=0.69999999999999996): { options+: { groupWidth: value } }, + '#withOrientation': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Controls the orientation of the bar chart, either vertical or horizontal.' } }, + withOrientation(value): { options+: { orientation: value } }, + '#withShowValue': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'This controls whether values are shown on top or to the left of bars.' } }, + withShowValue(value): { options+: { showValue: value } }, + '#withStacking': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Controls whether bars are stacked or not, either normally or in percent mode.' } }, + withStacking(value): { options+: { stacking: value } }, + '#withXField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Manually select which field from the dataset to represent the x field.' } }, + withXField(value): { options+: { xField: value } }, + '#withXTickLabelMaxLength': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'Sets the max length that a label can have before it is truncated.' } }, + withXTickLabelMaxLength(value): { options+: { xTickLabelMaxLength: value } }, + '#withXTickLabelRotation': { 'function': { args: [{ default: 0, enums: null, name: 'value', type: 'integer' }], help: 'Controls the rotation of the x axis labels.' } }, + withXTickLabelRotation(value=0): { options+: { xTickLabelRotation: value } }, + '#withXTickLabelSpacing': { 'function': { args: [{ default: 0, enums: null, name: 'value', type: 'integer' }], help: 'Controls the spacing between x axis labels.\nnegative values indicate backwards skipping behavior' } }, + withXTickLabelSpacing(value=0): { options+: { xTickLabelSpacing: value } }, + }, + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'barchart' }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/barGauge.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/barGauge.libsonnet new file mode 100644 index 0000000000..094ec96b22 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/barGauge.libsonnet @@ -0,0 +1,57 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.panel.barGauge', name: 'barGauge' }, + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptions(value): { options: value }, + '#withOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptionsMixin(value): { options+: value }, + options+: + { + '#withText': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withText(value): { options+: { text: value } }, + '#withTextMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTextMixin(value): { options+: { text+: value } }, + text+: + { + '#withTitleSize': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Explicit title text size' } }, + withTitleSize(value): { options+: { text+: { titleSize: value } } }, + '#withValueSize': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Explicit value text size' } }, + withValueSize(value): { options+: { text+: { valueSize: value } } }, + }, + '#withOrientation': { 'function': { args: [{ default: null, enums: ['auto', 'vertical', 'horizontal'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withOrientation(value): { options+: { orientation: value } }, + '#withReduceOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withReduceOptions(value): { options+: { reduceOptions: value } }, + '#withReduceOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withReduceOptionsMixin(value): { options+: { reduceOptions+: value } }, + reduceOptions+: + { + '#withCalcs': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'When !values, pick one value for the whole field' } }, + withCalcs(value): { options+: { reduceOptions+: { calcs: (if std.isArray(value) + then value + else [value]) } } }, + '#withCalcsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'When !values, pick one value for the whole field' } }, + withCalcsMixin(value): { options+: { reduceOptions+: { calcs+: (if std.isArray(value) + then value + else [value]) } } }, + '#withFields': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Which fields to show. By default this is only numeric fields' } }, + withFields(value): { options+: { reduceOptions+: { fields: value } } }, + '#withLimit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'if showing all values limit' } }, + withLimit(value): { options+: { reduceOptions+: { limit: value } } }, + '#withValues': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'If true show each row value' } }, + withValues(value=true): { options+: { reduceOptions+: { values: value } } }, + }, + '#withDisplayMode': { 'function': { args: [{ default: null, enums: ['basic', 'lcd', 'gradient'], name: 'value', type: 'string' }], help: 'Enum expressing the possible display modes\nfor the bar gauge component of Grafana UI' } }, + withDisplayMode(value): { options+: { displayMode: value } }, + '#withMinVizHeight': { 'function': { args: [{ default: 10, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withMinVizHeight(value=10): { options+: { minVizHeight: value } }, + '#withMinVizWidth': { 'function': { args: [{ default: 0, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withMinVizWidth(value=0): { options+: { minVizWidth: value } }, + '#withShowUnfilled': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowUnfilled(value=true): { options+: { showUnfilled: value } }, + '#withValueMode': { 'function': { args: [{ default: null, enums: ['color', 'text', 'hidden'], name: 'value', type: 'string' }], help: 'Allows for the table cell gauge display type to set the gauge mode.' } }, + withValueMode(value): { options+: { valueMode: value } }, + }, + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'bargauge' }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/candlestick.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/candlestick.libsonnet new file mode 100644 index 0000000000..5a06bc0c9c --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/candlestick.libsonnet @@ -0,0 +1,6 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.panel.candlestick', name: 'candlestick' }, + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'candlestick' }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/canvas.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/canvas.libsonnet new file mode 100644 index 0000000000..48e4ecabc3 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/canvas.libsonnet @@ -0,0 +1,6 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.panel.canvas', name: 'canvas' }, + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'canvas' }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/dashboardList.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/dashboardList.libsonnet new file mode 100644 index 0000000000..55afdd9e22 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/dashboardList.libsonnet @@ -0,0 +1,39 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.panel.dashboardList', name: 'dashboardList' }, + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptions(value): { options: value }, + '#withOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptionsMixin(value): { options+: value }, + options+: + { + '#withFolderId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withFolderId(value): { options+: { folderId: value } }, + '#withIncludeVars': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withIncludeVars(value=true): { options+: { includeVars: value } }, + '#withKeepTime': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withKeepTime(value=true): { options+: { keepTime: value } }, + '#withMaxItems': { 'function': { args: [{ default: 10, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withMaxItems(value=10): { options+: { maxItems: value } }, + '#withQuery': { 'function': { args: [{ default: '', enums: null, name: 'value', type: 'string' }], help: '' } }, + withQuery(value=''): { options+: { query: value } }, + '#withShowHeadings': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowHeadings(value=true): { options+: { showHeadings: value } }, + '#withShowRecentlyViewed': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowRecentlyViewed(value=true): { options+: { showRecentlyViewed: value } }, + '#withShowSearch': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowSearch(value=true): { options+: { showSearch: value } }, + '#withShowStarred': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowStarred(value=true): { options+: { showStarred: value } }, + '#withTags': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTags(value): { options+: { tags: (if std.isArray(value) + then value + else [value]) } }, + '#withTagsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTagsMixin(value): { options+: { tags+: (if std.isArray(value) + then value + else [value]) } }, + }, + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'dashlist' }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/datagrid.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/datagrid.libsonnet new file mode 100644 index 0000000000..a7eeb44a50 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/datagrid.libsonnet @@ -0,0 +1,15 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.panel.datagrid', name: 'datagrid' }, + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptions(value): { options: value }, + '#withOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptionsMixin(value): { options+: value }, + options+: + { + '#withSelectedSeries': { 'function': { args: [{ default: 0, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withSelectedSeries(value=0): { options+: { selectedSeries: value } }, + }, + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'datagrid' }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/debug.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/debug.libsonnet new file mode 100644 index 0000000000..b3f01fb7a4 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/debug.libsonnet @@ -0,0 +1,43 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.panel.debug', name: 'debug' }, + '#withDebugMode': { 'function': { args: [{ default: null, enums: ['render', 'events', 'cursor', 'State', 'ThrowError'], name: 'value', type: 'string' }], help: '' } }, + withDebugMode(value): { DebugMode: value }, + '#withUpdateConfig': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withUpdateConfig(value): { UpdateConfig: value }, + '#withUpdateConfigMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withUpdateConfigMixin(value): { UpdateConfig+: value }, + UpdateConfig+: + { + '#withDataChanged': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withDataChanged(value=true): { UpdateConfig+: { dataChanged: value } }, + '#withRender': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withRender(value=true): { UpdateConfig+: { render: value } }, + '#withSchemaChanged': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withSchemaChanged(value=true): { UpdateConfig+: { schemaChanged: value } }, + }, + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptions(value): { options: value }, + '#withOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptionsMixin(value): { options+: value }, + options+: + { + '#withCounters': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withCounters(value): { options+: { counters: value } }, + '#withCountersMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withCountersMixin(value): { options+: { counters+: value } }, + counters+: + { + '#withDataChanged': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withDataChanged(value=true): { options+: { counters+: { dataChanged: value } } }, + '#withRender': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withRender(value=true): { options+: { counters+: { render: value } } }, + '#withSchemaChanged': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withSchemaChanged(value=true): { options+: { counters+: { schemaChanged: value } } }, + }, + '#withMode': { 'function': { args: [{ default: null, enums: ['render', 'events', 'cursor', 'State', 'ThrowError'], name: 'value', type: 'string' }], help: '' } }, + withMode(value): { options+: { mode: value } }, + }, + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'debug' }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/gauge.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/gauge.libsonnet new file mode 100644 index 0000000000..8a5d39a60e --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/gauge.libsonnet @@ -0,0 +1,51 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.panel.gauge', name: 'gauge' }, + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptions(value): { options: value }, + '#withOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptionsMixin(value): { options+: value }, + options+: + { + '#withText': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withText(value): { options+: { text: value } }, + '#withTextMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTextMixin(value): { options+: { text+: value } }, + text+: + { + '#withTitleSize': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Explicit title text size' } }, + withTitleSize(value): { options+: { text+: { titleSize: value } } }, + '#withValueSize': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Explicit value text size' } }, + withValueSize(value): { options+: { text+: { valueSize: value } } }, + }, + '#withOrientation': { 'function': { args: [{ default: null, enums: ['auto', 'vertical', 'horizontal'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withOrientation(value): { options+: { orientation: value } }, + '#withReduceOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withReduceOptions(value): { options+: { reduceOptions: value } }, + '#withReduceOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withReduceOptionsMixin(value): { options+: { reduceOptions+: value } }, + reduceOptions+: + { + '#withCalcs': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'When !values, pick one value for the whole field' } }, + withCalcs(value): { options+: { reduceOptions+: { calcs: (if std.isArray(value) + then value + else [value]) } } }, + '#withCalcsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'When !values, pick one value for the whole field' } }, + withCalcsMixin(value): { options+: { reduceOptions+: { calcs+: (if std.isArray(value) + then value + else [value]) } } }, + '#withFields': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Which fields to show. By default this is only numeric fields' } }, + withFields(value): { options+: { reduceOptions+: { fields: value } } }, + '#withLimit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'if showing all values limit' } }, + withLimit(value): { options+: { reduceOptions+: { limit: value } } }, + '#withValues': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'If true show each row value' } }, + withValues(value=true): { options+: { reduceOptions+: { values: value } } }, + }, + '#withShowThresholdLabels': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowThresholdLabels(value=true): { options+: { showThresholdLabels: value } }, + '#withShowThresholdMarkers': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowThresholdMarkers(value=true): { options+: { showThresholdMarkers: value } }, + }, + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'gauge' }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/geomap.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/geomap.libsonnet new file mode 100644 index 0000000000..435856e554 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/geomap.libsonnet @@ -0,0 +1,216 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.panel.geomap', name: 'geomap' }, + '#withControlsOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withControlsOptions(value): { ControlsOptions: value }, + '#withControlsOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withControlsOptionsMixin(value): { ControlsOptions+: value }, + ControlsOptions+: + { + '#withMouseWheelZoom': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'let the mouse wheel zoom' } }, + withMouseWheelZoom(value=true): { ControlsOptions+: { mouseWheelZoom: value } }, + '#withShowAttribution': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Lower right' } }, + withShowAttribution(value=true): { ControlsOptions+: { showAttribution: value } }, + '#withShowDebug': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Show debug' } }, + withShowDebug(value=true): { ControlsOptions+: { showDebug: value } }, + '#withShowMeasure': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Show measure' } }, + withShowMeasure(value=true): { ControlsOptions+: { showMeasure: value } }, + '#withShowScale': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Scale options' } }, + withShowScale(value=true): { ControlsOptions+: { showScale: value } }, + '#withShowZoom': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Zoom (upper left)' } }, + withShowZoom(value=true): { ControlsOptions+: { showZoom: value } }, + }, + '#withMapCenterID': { 'function': { args: [{ default: null, enums: ['zero', 'coords', 'fit'], name: 'value', type: 'string' }], help: '' } }, + withMapCenterID(value): { MapCenterID: value }, + '#withMapViewConfig': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withMapViewConfig(value): { MapViewConfig: value }, + '#withMapViewConfigMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withMapViewConfigMixin(value): { MapViewConfig+: value }, + MapViewConfig+: + { + '#withAllLayers': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAllLayers(value=true): { MapViewConfig+: { allLayers: value } }, + '#withId': { 'function': { args: [{ default: 'zero', enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value='zero'): { MapViewConfig+: { id: value } }, + '#withLastOnly': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withLastOnly(value=true): { MapViewConfig+: { lastOnly: value } }, + '#withLat': { 'function': { args: [{ default: 0, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withLat(value=0): { MapViewConfig+: { lat: value } }, + '#withLayer': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withLayer(value): { MapViewConfig+: { layer: value } }, + '#withLon': { 'function': { args: [{ default: 0, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withLon(value=0): { MapViewConfig+: { lon: value } }, + '#withMaxZoom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withMaxZoom(value): { MapViewConfig+: { maxZoom: value } }, + '#withMinZoom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withMinZoom(value): { MapViewConfig+: { minZoom: value } }, + '#withPadding': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withPadding(value): { MapViewConfig+: { padding: value } }, + '#withShared': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShared(value=true): { MapViewConfig+: { shared: value } }, + '#withZoom': { 'function': { args: [{ default: 1, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withZoom(value=1): { MapViewConfig+: { zoom: value } }, + }, + '#withTooltipMode': { 'function': { args: [{ default: null, enums: ['none', 'details'], name: 'value', type: 'string' }], help: '' } }, + withTooltipMode(value): { TooltipMode: value }, + '#withTooltipOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withTooltipOptions(value): { TooltipOptions: value }, + '#withTooltipOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withTooltipOptionsMixin(value): { TooltipOptions+: value }, + TooltipOptions+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['none', 'details'], name: 'value', type: 'string' }], help: '' } }, + withMode(value): { TooltipOptions+: { mode: value } }, + }, + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptions(value): { options: value }, + '#withOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptionsMixin(value): { options+: value }, + options+: + { + '#withBasemap': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withBasemap(value): { options+: { basemap: value } }, + '#withBasemapMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withBasemapMixin(value): { options+: { basemap+: value } }, + basemap+: + { + '#withConfig': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Custom options depending on the type' } }, + withConfig(value): { options+: { basemap+: { config: value } } }, + '#withFilterData': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Defines a frame MatcherConfig that may filter data for the given layer' } }, + withFilterData(value): { options+: { basemap+: { filterData: value } } }, + '#withLocation': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withLocation(value): { options+: { basemap+: { location: value } } }, + '#withLocationMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withLocationMixin(value): { options+: { basemap+: { location+: value } } }, + location+: + { + '#withGazetteer': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Path to Gazetteer' } }, + withGazetteer(value): { options+: { basemap+: { location+: { gazetteer: value } } } }, + '#withGeohash': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Field mappings' } }, + withGeohash(value): { options+: { basemap+: { location+: { geohash: value } } } }, + '#withLatitude': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withLatitude(value): { options+: { basemap+: { location+: { latitude: value } } } }, + '#withLongitude': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withLongitude(value): { options+: { basemap+: { location+: { longitude: value } } } }, + '#withLookup': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withLookup(value): { options+: { basemap+: { location+: { lookup: value } } } }, + '#withMode': { 'function': { args: [{ default: null, enums: ['auto', 'geohash', 'coords', 'lookup'], name: 'value', type: 'string' }], help: '' } }, + withMode(value): { options+: { basemap+: { location+: { mode: value } } } }, + '#withWkt': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withWkt(value): { options+: { basemap+: { location+: { wkt: value } } } }, + }, + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'configured unique display name' } }, + withName(value): { options+: { basemap+: { name: value } } }, + '#withOpacity': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'Common properties:\nhttps://openlayers.org/en/latest/apidoc/module-ol_layer_Base-BaseLayer.html\nLayer opacity (0-1)' } }, + withOpacity(value): { options+: { basemap+: { opacity: value } } }, + '#withTooltip': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Check tooltip (defaults to true)' } }, + withTooltip(value=true): { options+: { basemap+: { tooltip: value } } }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { options+: { basemap+: { type: value } } }, + }, + '#withControls': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withControls(value): { options+: { controls: value } }, + '#withControlsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withControlsMixin(value): { options+: { controls+: value } }, + controls+: + { + '#withMouseWheelZoom': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'let the mouse wheel zoom' } }, + withMouseWheelZoom(value=true): { options+: { controls+: { mouseWheelZoom: value } } }, + '#withShowAttribution': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Lower right' } }, + withShowAttribution(value=true): { options+: { controls+: { showAttribution: value } } }, + '#withShowDebug': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Show debug' } }, + withShowDebug(value=true): { options+: { controls+: { showDebug: value } } }, + '#withShowMeasure': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Show measure' } }, + withShowMeasure(value=true): { options+: { controls+: { showMeasure: value } } }, + '#withShowScale': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Scale options' } }, + withShowScale(value=true): { options+: { controls+: { showScale: value } } }, + '#withShowZoom': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Zoom (upper left)' } }, + withShowZoom(value=true): { options+: { controls+: { showZoom: value } } }, + }, + '#withLayers': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withLayers(value): { options+: { layers: (if std.isArray(value) + then value + else [value]) } }, + '#withLayersMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withLayersMixin(value): { options+: { layers+: (if std.isArray(value) + then value + else [value]) } }, + layers+: + { + '#': { help: '', name: 'layers' }, + '#withConfig': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Custom options depending on the type' } }, + withConfig(value): { config: value }, + '#withFilterData': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Defines a frame MatcherConfig that may filter data for the given layer' } }, + withFilterData(value): { filterData: value }, + '#withLocation': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withLocation(value): { location: value }, + '#withLocationMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withLocationMixin(value): { location+: value }, + location+: + { + '#withGazetteer': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Path to Gazetteer' } }, + withGazetteer(value): { location+: { gazetteer: value } }, + '#withGeohash': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Field mappings' } }, + withGeohash(value): { location+: { geohash: value } }, + '#withLatitude': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withLatitude(value): { location+: { latitude: value } }, + '#withLongitude': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withLongitude(value): { location+: { longitude: value } }, + '#withLookup': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withLookup(value): { location+: { lookup: value } }, + '#withMode': { 'function': { args: [{ default: null, enums: ['auto', 'geohash', 'coords', 'lookup'], name: 'value', type: 'string' }], help: '' } }, + withMode(value): { location+: { mode: value } }, + '#withWkt': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withWkt(value): { location+: { wkt: value } }, + }, + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'configured unique display name' } }, + withName(value): { name: value }, + '#withOpacity': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'Common properties:\nhttps://openlayers.org/en/latest/apidoc/module-ol_layer_Base-BaseLayer.html\nLayer opacity (0-1)' } }, + withOpacity(value): { opacity: value }, + '#withTooltip': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Check tooltip (defaults to true)' } }, + withTooltip(value=true): { tooltip: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + }, + '#withTooltip': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withTooltip(value): { options+: { tooltip: value } }, + '#withTooltipMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withTooltipMixin(value): { options+: { tooltip+: value } }, + tooltip+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['none', 'details'], name: 'value', type: 'string' }], help: '' } }, + withMode(value): { options+: { tooltip+: { mode: value } } }, + }, + '#withView': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withView(value): { options+: { view: value } }, + '#withViewMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withViewMixin(value): { options+: { view+: value } }, + view+: + { + '#withAllLayers': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAllLayers(value=true): { options+: { view+: { allLayers: value } } }, + '#withId': { 'function': { args: [{ default: 'zero', enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value='zero'): { options+: { view+: { id: value } } }, + '#withLastOnly': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withLastOnly(value=true): { options+: { view+: { lastOnly: value } } }, + '#withLat': { 'function': { args: [{ default: 0, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withLat(value=0): { options+: { view+: { lat: value } } }, + '#withLayer': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withLayer(value): { options+: { view+: { layer: value } } }, + '#withLon': { 'function': { args: [{ default: 0, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withLon(value=0): { options+: { view+: { lon: value } } }, + '#withMaxZoom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withMaxZoom(value): { options+: { view+: { maxZoom: value } } }, + '#withMinZoom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withMinZoom(value): { options+: { view+: { minZoom: value } } }, + '#withPadding': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withPadding(value): { options+: { view+: { padding: value } } }, + '#withShared': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShared(value=true): { options+: { view+: { shared: value } } }, + '#withZoom': { 'function': { args: [{ default: 1, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withZoom(value=1): { options+: { view+: { zoom: value } } }, + }, + }, + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'geomap' }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/heatmap.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/heatmap.libsonnet new file mode 100644 index 0000000000..89dceafbb2 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/heatmap.libsonnet @@ -0,0 +1,414 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.panel.heatmap', name: 'heatmap' }, + '#withCellValues': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls cell value options' } }, + withCellValues(value): { CellValues: value }, + '#withCellValuesMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls cell value options' } }, + withCellValuesMixin(value): { CellValues+: value }, + CellValues+: + { + '#withDecimals': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Controls the number of decimals for cell values' } }, + withDecimals(value): { CellValues+: { decimals: value } }, + '#withUnit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Controls the cell value unit' } }, + withUnit(value): { CellValues+: { unit: value } }, + }, + '#withExemplarConfig': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls exemplar options' } }, + withExemplarConfig(value): { ExemplarConfig: value }, + '#withExemplarConfigMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls exemplar options' } }, + withExemplarConfigMixin(value): { ExemplarConfig+: value }, + ExemplarConfig+: + { + '#withColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Sets the color of the exemplar markers' } }, + withColor(value): { ExemplarConfig+: { color: value } }, + }, + '#withFilterValueRange': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls the value filter range' } }, + withFilterValueRange(value): { FilterValueRange: value }, + '#withFilterValueRangeMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls the value filter range' } }, + withFilterValueRangeMixin(value): { FilterValueRange+: value }, + FilterValueRange+: + { + '#withGe': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Sets the filter range to values greater than or equal to the given value' } }, + withGe(value): { FilterValueRange+: { ge: value } }, + '#withLe': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Sets the filter range to values less than or equal to the given value' } }, + withLe(value): { FilterValueRange+: { le: value } }, + }, + '#withHeatmapColorMode': { 'function': { args: [{ default: null, enums: ['opacity', 'scheme'], name: 'value', type: 'string' }], help: 'Controls the color mode of the heatmap' } }, + withHeatmapColorMode(value): { HeatmapColorMode: value }, + '#withHeatmapColorOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls various color options' } }, + withHeatmapColorOptions(value): { HeatmapColorOptions: value }, + '#withHeatmapColorOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls various color options' } }, + withHeatmapColorOptionsMixin(value): { HeatmapColorOptions+: value }, + HeatmapColorOptions+: + { + '#withExponent': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Controls the exponent when scale is set to exponential' } }, + withExponent(value): { HeatmapColorOptions+: { exponent: value } }, + '#withFill': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Controls the color fill when in opacity mode' } }, + withFill(value): { HeatmapColorOptions+: { fill: value } }, + '#withMax': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Sets the maximum value for the color scale' } }, + withMax(value): { HeatmapColorOptions+: { max: value } }, + '#withMin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Sets the minimum value for the color scale' } }, + withMin(value): { HeatmapColorOptions+: { min: value } }, + '#withMode': { 'function': { args: [{ default: null, enums: ['opacity', 'scheme'], name: 'value', type: 'string' }], help: 'Controls the color mode of the heatmap' } }, + withMode(value): { HeatmapColorOptions+: { mode: value } }, + '#withReverse': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Reverses the color scheme' } }, + withReverse(value=true): { HeatmapColorOptions+: { reverse: value } }, + '#withScale': { 'function': { args: [{ default: null, enums: ['linear', 'exponential'], name: 'value', type: 'string' }], help: 'Controls the color scale of the heatmap' } }, + withScale(value): { HeatmapColorOptions+: { scale: value } }, + '#withScheme': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Controls the color scheme used' } }, + withScheme(value): { HeatmapColorOptions+: { scheme: value } }, + '#withSteps': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'Controls the number of color steps' } }, + withSteps(value): { HeatmapColorOptions+: { steps: value } }, + }, + '#withHeatmapColorScale': { 'function': { args: [{ default: null, enums: ['linear', 'exponential'], name: 'value', type: 'string' }], help: 'Controls the color scale of the heatmap' } }, + withHeatmapColorScale(value): { HeatmapColorScale: value }, + '#withHeatmapLegend': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls legend options' } }, + withHeatmapLegend(value): { HeatmapLegend: value }, + '#withHeatmapLegendMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls legend options' } }, + withHeatmapLegendMixin(value): { HeatmapLegend+: value }, + HeatmapLegend+: + { + '#withShow': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Controls if the legend is shown' } }, + withShow(value=true): { HeatmapLegend+: { show: value } }, + }, + '#withHeatmapTooltip': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls tooltip options' } }, + withHeatmapTooltip(value): { HeatmapTooltip: value }, + '#withHeatmapTooltipMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls tooltip options' } }, + withHeatmapTooltipMixin(value): { HeatmapTooltip+: value }, + HeatmapTooltip+: + { + '#withShow': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Controls if the tooltip is shown' } }, + withShow(value=true): { HeatmapTooltip+: { show: value } }, + '#withYHistogram': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Controls if the tooltip shows a histogram of the y-axis values' } }, + withYHistogram(value=true): { HeatmapTooltip+: { yHistogram: value } }, + }, + '#withRowsHeatmapOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls frame rows options' } }, + withRowsHeatmapOptions(value): { RowsHeatmapOptions: value }, + '#withRowsHeatmapOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls frame rows options' } }, + withRowsHeatmapOptionsMixin(value): { RowsHeatmapOptions+: value }, + RowsHeatmapOptions+: + { + '#withLayout': { 'function': { args: [{ default: null, enums: ['le', 'ge', 'unknown', 'auto'], name: 'value', type: 'string' }], help: '' } }, + withLayout(value): { RowsHeatmapOptions+: { layout: value } }, + '#withValue': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Sets the name of the cell when not calculating from data' } }, + withValue(value): { RowsHeatmapOptions+: { value: value } }, + }, + '#withYAxisConfig': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Configuration options for the yAxis' } }, + withYAxisConfig(value): { YAxisConfig: value }, + '#withYAxisConfigMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Configuration options for the yAxis' } }, + withYAxisConfigMixin(value): { YAxisConfig+: value }, + YAxisConfig+: + { + '#withAxisCenteredZero': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAxisCenteredZero(value=true): { YAxisConfig+: { axisCenteredZero: value } }, + '#withAxisColorMode': { 'function': { args: [{ default: null, enums: ['text', 'series'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withAxisColorMode(value): { YAxisConfig+: { axisColorMode: value } }, + '#withAxisGridShow': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAxisGridShow(value=true): { YAxisConfig+: { axisGridShow: value } }, + '#withAxisLabel': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withAxisLabel(value): { YAxisConfig+: { axisLabel: value } }, + '#withAxisPlacement': { 'function': { args: [{ default: null, enums: ['auto', 'top', 'right', 'bottom', 'left', 'hidden'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withAxisPlacement(value): { YAxisConfig+: { axisPlacement: value } }, + '#withAxisSoftMax': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisSoftMax(value): { YAxisConfig+: { axisSoftMax: value } }, + '#withAxisSoftMin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisSoftMin(value): { YAxisConfig+: { axisSoftMin: value } }, + '#withAxisWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisWidth(value): { YAxisConfig+: { axisWidth: value } }, + '#withScaleDistribution': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistribution(value): { YAxisConfig+: { scaleDistribution: value } }, + '#withScaleDistributionMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistributionMixin(value): { YAxisConfig+: { scaleDistribution+: value } }, + scaleDistribution+: + { + '#withLinearThreshold': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLinearThreshold(value): { YAxisConfig+: { scaleDistribution+: { linearThreshold: value } } }, + '#withLog': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLog(value): { YAxisConfig+: { scaleDistribution+: { log: value } } }, + '#withType': { 'function': { args: [{ default: null, enums: ['linear', 'log', 'ordinal', 'symlog'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withType(value): { YAxisConfig+: { scaleDistribution+: { type: value } } }, + }, + '#withDecimals': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Controls the number of decimals for yAxis values' } }, + withDecimals(value): { YAxisConfig+: { decimals: value } }, + '#withMax': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Sets the maximum value for the yAxis' } }, + withMax(value): { YAxisConfig+: { max: value } }, + '#withMin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Sets the minimum value for the yAxis' } }, + withMin(value): { YAxisConfig+: { min: value } }, + '#withReverse': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Reverses the yAxis' } }, + withReverse(value=true): { YAxisConfig+: { reverse: value } }, + '#withUnit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Sets the yAxis unit' } }, + withUnit(value): { YAxisConfig+: { unit: value } }, + }, + '#withFieldConfig': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withFieldConfig(value): { fieldConfig: value }, + '#withFieldConfigMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withFieldConfigMixin(value): { fieldConfig+: value }, + fieldConfig+: + { + '#withDefaults': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withDefaults(value): { fieldConfig+: { defaults: value } }, + '#withDefaultsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withDefaultsMixin(value): { fieldConfig+: { defaults+: value } }, + defaults+: + { + '#withCustom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withCustom(value): { fieldConfig+: { defaults+: { custom: value } } }, + '#withCustomMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withCustomMixin(value): { fieldConfig+: { defaults+: { custom+: value } } }, + custom+: + { + '#withHideFrom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFrom(value): { fieldConfig+: { defaults+: { custom+: { hideFrom: value } } } }, + '#withHideFromMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFromMixin(value): { fieldConfig+: { defaults+: { custom+: { hideFrom+: value } } } }, + hideFrom+: + { + '#withLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withLegend(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { legend: value } } } } }, + '#withTooltip': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withTooltip(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { tooltip: value } } } } }, + '#withViz': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withViz(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { viz: value } } } } }, + }, + '#withScaleDistribution': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistribution(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution: value } } } }, + '#withScaleDistributionMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistributionMixin(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: value } } } }, + scaleDistribution+: + { + '#withLinearThreshold': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLinearThreshold(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: { linearThreshold: value } } } } }, + '#withLog': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLog(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: { log: value } } } } }, + '#withType': { 'function': { args: [{ default: null, enums: ['linear', 'log', 'ordinal', 'symlog'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withType(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: { type: value } } } } }, + }, + }, + }, + }, + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptions(value): { options: value }, + '#withOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptionsMixin(value): { options+: value }, + options+: + { + '#withCalculate': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Controls if the heatmap should be calculated from data' } }, + withCalculate(value=true): { options+: { calculate: value } }, + '#withCalculation': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withCalculation(value): { options+: { calculation: value } }, + '#withCalculationMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withCalculationMixin(value): { options+: { calculation+: value } }, + calculation+: + { + '#withXBuckets': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withXBuckets(value): { options+: { calculation+: { xBuckets: value } } }, + '#withXBucketsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withXBucketsMixin(value): { options+: { calculation+: { xBuckets+: value } } }, + xBuckets+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['size', 'count'], name: 'value', type: 'string' }], help: '' } }, + withMode(value): { options+: { calculation+: { xBuckets+: { mode: value } } } }, + '#withScale': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScale(value): { options+: { calculation+: { xBuckets+: { scale: value } } } }, + '#withScaleMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleMixin(value): { options+: { calculation+: { xBuckets+: { scale+: value } } } }, + scale+: + { + '#withLinearThreshold': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLinearThreshold(value): { options+: { calculation+: { xBuckets+: { scale+: { linearThreshold: value } } } } }, + '#withLog': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLog(value): { options+: { calculation+: { xBuckets+: { scale+: { log: value } } } } }, + '#withType': { 'function': { args: [{ default: null, enums: ['linear', 'log', 'ordinal', 'symlog'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withType(value): { options+: { calculation+: { xBuckets+: { scale+: { type: value } } } } }, + }, + '#withValue': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The number of buckets to use for the axis in the heatmap' } }, + withValue(value): { options+: { calculation+: { xBuckets+: { value: value } } } }, + }, + '#withYBuckets': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withYBuckets(value): { options+: { calculation+: { yBuckets: value } } }, + '#withYBucketsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withYBucketsMixin(value): { options+: { calculation+: { yBuckets+: value } } }, + yBuckets+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['size', 'count'], name: 'value', type: 'string' }], help: '' } }, + withMode(value): { options+: { calculation+: { yBuckets+: { mode: value } } } }, + '#withScale': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScale(value): { options+: { calculation+: { yBuckets+: { scale: value } } } }, + '#withScaleMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleMixin(value): { options+: { calculation+: { yBuckets+: { scale+: value } } } }, + scale+: + { + '#withLinearThreshold': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLinearThreshold(value): { options+: { calculation+: { yBuckets+: { scale+: { linearThreshold: value } } } } }, + '#withLog': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLog(value): { options+: { calculation+: { yBuckets+: { scale+: { log: value } } } } }, + '#withType': { 'function': { args: [{ default: null, enums: ['linear', 'log', 'ordinal', 'symlog'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withType(value): { options+: { calculation+: { yBuckets+: { scale+: { type: value } } } } }, + }, + '#withValue': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The number of buckets to use for the axis in the heatmap' } }, + withValue(value): { options+: { calculation+: { yBuckets+: { value: value } } } }, + }, + }, + '#withCellGap': { 'function': { args: [{ default: 1, enums: null, name: 'value', type: 'integer' }], help: 'Controls gap between cells' } }, + withCellGap(value=1): { options+: { cellGap: value } }, + '#withCellRadius': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Controls cell radius' } }, + withCellRadius(value): { options+: { cellRadius: value } }, + '#withCellValues': { 'function': { args: [{ default: {}, enums: null, name: 'value', type: 'object' }], help: 'Controls cell value unit' } }, + withCellValues(value={}): { options+: { cellValues: value } }, + '#withCellValuesMixin': { 'function': { args: [{ default: {}, enums: null, name: 'value', type: 'object' }], help: 'Controls cell value unit' } }, + withCellValuesMixin(value): { options+: { cellValues+: value } }, + cellValues+: + { + '#withCellValues': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls cell value options' } }, + withCellValues(value): { options+: { cellValues+: { CellValues: value } } }, + '#withCellValuesMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls cell value options' } }, + withCellValuesMixin(value): { options+: { cellValues+: { CellValues+: value } } }, + CellValues+: + { + '#withDecimals': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Controls the number of decimals for cell values' } }, + withDecimals(value): { options+: { cellValues+: { decimals: value } } }, + '#withUnit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Controls the cell value unit' } }, + withUnit(value): { options+: { cellValues+: { unit: value } } }, + }, + }, + '#withColor': { 'function': { args: [{ default: { exponent: 0.5, fill: 'dark-orange', reverse: false, scheme: 'Oranges', steps: 64 }, enums: null, name: 'value', type: 'object' }], help: 'Controls the color options' } }, + withColor(value={ exponent: 0.5, fill: 'dark-orange', reverse: false, scheme: 'Oranges', steps: 64 }): { options+: { color: value } }, + '#withColorMixin': { 'function': { args: [{ default: { exponent: 0.5, fill: 'dark-orange', reverse: false, scheme: 'Oranges', steps: 64 }, enums: null, name: 'value', type: 'object' }], help: 'Controls the color options' } }, + withColorMixin(value): { options+: { color+: value } }, + color+: + { + '#withHeatmapColorOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls various color options' } }, + withHeatmapColorOptions(value): { options+: { color+: { HeatmapColorOptions: value } } }, + '#withHeatmapColorOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls various color options' } }, + withHeatmapColorOptionsMixin(value): { options+: { color+: { HeatmapColorOptions+: value } } }, + HeatmapColorOptions+: + { + '#withExponent': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Controls the exponent when scale is set to exponential' } }, + withExponent(value): { options+: { color+: { exponent: value } } }, + '#withFill': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Controls the color fill when in opacity mode' } }, + withFill(value): { options+: { color+: { fill: value } } }, + '#withMax': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Sets the maximum value for the color scale' } }, + withMax(value): { options+: { color+: { max: value } } }, + '#withMin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Sets the minimum value for the color scale' } }, + withMin(value): { options+: { color+: { min: value } } }, + '#withMode': { 'function': { args: [{ default: null, enums: ['opacity', 'scheme'], name: 'value', type: 'string' }], help: 'Controls the color mode of the heatmap' } }, + withMode(value): { options+: { color+: { mode: value } } }, + '#withReverse': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Reverses the color scheme' } }, + withReverse(value=true): { options+: { color+: { reverse: value } } }, + '#withScale': { 'function': { args: [{ default: null, enums: ['linear', 'exponential'], name: 'value', type: 'string' }], help: 'Controls the color scale of the heatmap' } }, + withScale(value): { options+: { color+: { scale: value } } }, + '#withScheme': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Controls the color scheme used' } }, + withScheme(value): { options+: { color+: { scheme: value } } }, + '#withSteps': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'Controls the number of color steps' } }, + withSteps(value): { options+: { color+: { steps: value } } }, + }, + }, + '#withExemplars': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls exemplar options' } }, + withExemplars(value): { options+: { exemplars: value } }, + '#withExemplarsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls exemplar options' } }, + withExemplarsMixin(value): { options+: { exemplars+: value } }, + exemplars+: + { + '#withColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Sets the color of the exemplar markers' } }, + withColor(value): { options+: { exemplars+: { color: value } } }, + }, + '#withFilterValues': { 'function': { args: [{ default: { le: 1.0000000000000001e-09 }, enums: null, name: 'value', type: 'object' }], help: 'Filters values between a given range' } }, + withFilterValues(value={ le: 1.0000000000000001e-09 }): { options+: { filterValues: value } }, + '#withFilterValuesMixin': { 'function': { args: [{ default: { le: 1.0000000000000001e-09 }, enums: null, name: 'value', type: 'object' }], help: 'Filters values between a given range' } }, + withFilterValuesMixin(value): { options+: { filterValues+: value } }, + filterValues+: + { + '#withFilterValueRange': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls the value filter range' } }, + withFilterValueRange(value): { options+: { filterValues+: { FilterValueRange: value } } }, + '#withFilterValueRangeMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls the value filter range' } }, + withFilterValueRangeMixin(value): { options+: { filterValues+: { FilterValueRange+: value } } }, + FilterValueRange+: + { + '#withGe': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Sets the filter range to values greater than or equal to the given value' } }, + withGe(value): { options+: { filterValues+: { ge: value } } }, + '#withLe': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Sets the filter range to values less than or equal to the given value' } }, + withLe(value): { options+: { filterValues+: { le: value } } }, + }, + }, + '#withLegend': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls legend options' } }, + withLegend(value): { options+: { legend: value } }, + '#withLegendMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls legend options' } }, + withLegendMixin(value): { options+: { legend+: value } }, + legend+: + { + '#withShow': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Controls if the legend is shown' } }, + withShow(value=true): { options+: { legend+: { show: value } } }, + }, + '#withRowsFrame': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls frame rows options' } }, + withRowsFrame(value): { options+: { rowsFrame: value } }, + '#withRowsFrameMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls frame rows options' } }, + withRowsFrameMixin(value): { options+: { rowsFrame+: value } }, + rowsFrame+: + { + '#withLayout': { 'function': { args: [{ default: null, enums: ['le', 'ge', 'unknown', 'auto'], name: 'value', type: 'string' }], help: '' } }, + withLayout(value): { options+: { rowsFrame+: { layout: value } } }, + '#withValue': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Sets the name of the cell when not calculating from data' } }, + withValue(value): { options+: { rowsFrame+: { value: value } } }, + }, + '#withShowValue': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '| *{\n\tlayout: ui.HeatmapCellLayout & "auto" // TODO: fix after remove when https://github.com/grafana/cuetsy/issues/74 is fixed\n}\nControls the display of the value in the cell' } }, + withShowValue(value): { options+: { showValue: value } }, + '#withTooltip': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls tooltip options' } }, + withTooltip(value): { options+: { tooltip: value } }, + '#withTooltipMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Controls tooltip options' } }, + withTooltipMixin(value): { options+: { tooltip+: value } }, + tooltip+: + { + '#withShow': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Controls if the tooltip is shown' } }, + withShow(value=true): { options+: { tooltip+: { show: value } } }, + '#withYHistogram': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Controls if the tooltip shows a histogram of the y-axis values' } }, + withYHistogram(value=true): { options+: { tooltip+: { yHistogram: value } } }, + }, + '#withYAxis': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Configuration options for the yAxis' } }, + withYAxis(value): { options+: { yAxis: value } }, + '#withYAxisMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Configuration options for the yAxis' } }, + withYAxisMixin(value): { options+: { yAxis+: value } }, + yAxis+: + { + '#withAxisCenteredZero': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAxisCenteredZero(value=true): { options+: { yAxis+: { axisCenteredZero: value } } }, + '#withAxisColorMode': { 'function': { args: [{ default: null, enums: ['text', 'series'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withAxisColorMode(value): { options+: { yAxis+: { axisColorMode: value } } }, + '#withAxisGridShow': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAxisGridShow(value=true): { options+: { yAxis+: { axisGridShow: value } } }, + '#withAxisLabel': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withAxisLabel(value): { options+: { yAxis+: { axisLabel: value } } }, + '#withAxisPlacement': { 'function': { args: [{ default: null, enums: ['auto', 'top', 'right', 'bottom', 'left', 'hidden'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withAxisPlacement(value): { options+: { yAxis+: { axisPlacement: value } } }, + '#withAxisSoftMax': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisSoftMax(value): { options+: { yAxis+: { axisSoftMax: value } } }, + '#withAxisSoftMin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisSoftMin(value): { options+: { yAxis+: { axisSoftMin: value } } }, + '#withAxisWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisWidth(value): { options+: { yAxis+: { axisWidth: value } } }, + '#withScaleDistribution': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistribution(value): { options+: { yAxis+: { scaleDistribution: value } } }, + '#withScaleDistributionMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistributionMixin(value): { options+: { yAxis+: { scaleDistribution+: value } } }, + scaleDistribution+: + { + '#withLinearThreshold': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLinearThreshold(value): { options+: { yAxis+: { scaleDistribution+: { linearThreshold: value } } } }, + '#withLog': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLog(value): { options+: { yAxis+: { scaleDistribution+: { log: value } } } }, + '#withType': { 'function': { args: [{ default: null, enums: ['linear', 'log', 'ordinal', 'symlog'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withType(value): { options+: { yAxis+: { scaleDistribution+: { type: value } } } }, + }, + '#withDecimals': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Controls the number of decimals for yAxis values' } }, + withDecimals(value): { options+: { yAxis+: { decimals: value } } }, + '#withMax': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Sets the maximum value for the yAxis' } }, + withMax(value): { options+: { yAxis+: { max: value } } }, + '#withMin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Sets the minimum value for the yAxis' } }, + withMin(value): { options+: { yAxis+: { min: value } } }, + '#withReverse': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Reverses the yAxis' } }, + withReverse(value=true): { options+: { yAxis+: { reverse: value } } }, + '#withUnit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Sets the yAxis unit' } }, + withUnit(value): { options+: { yAxis+: { unit: value } } }, + }, + }, + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'heatmap' }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/histogram.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/histogram.libsonnet new file mode 100644 index 0000000000..42215d692f --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/histogram.libsonnet @@ -0,0 +1,130 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.panel.histogram', name: 'histogram' }, + '#withFieldConfig': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withFieldConfig(value): { fieldConfig: value }, + '#withFieldConfigMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withFieldConfigMixin(value): { fieldConfig+: value }, + fieldConfig+: + { + '#withDefaults': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withDefaults(value): { fieldConfig+: { defaults: value } }, + '#withDefaultsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withDefaultsMixin(value): { fieldConfig+: { defaults+: value } }, + defaults+: + { + '#withCustom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withCustom(value): { fieldConfig+: { defaults+: { custom: value } } }, + '#withCustomMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withCustomMixin(value): { fieldConfig+: { defaults+: { custom+: value } } }, + custom+: + { + '#withAxisCenteredZero': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAxisCenteredZero(value=true): { fieldConfig+: { defaults+: { custom+: { axisCenteredZero: value } } } }, + '#withAxisColorMode': { 'function': { args: [{ default: null, enums: ['text', 'series'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withAxisColorMode(value): { fieldConfig+: { defaults+: { custom+: { axisColorMode: value } } } }, + '#withAxisGridShow': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAxisGridShow(value=true): { fieldConfig+: { defaults+: { custom+: { axisGridShow: value } } } }, + '#withAxisLabel': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withAxisLabel(value): { fieldConfig+: { defaults+: { custom+: { axisLabel: value } } } }, + '#withAxisPlacement': { 'function': { args: [{ default: null, enums: ['auto', 'top', 'right', 'bottom', 'left', 'hidden'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withAxisPlacement(value): { fieldConfig+: { defaults+: { custom+: { axisPlacement: value } } } }, + '#withAxisSoftMax': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisSoftMax(value): { fieldConfig+: { defaults+: { custom+: { axisSoftMax: value } } } }, + '#withAxisSoftMin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisSoftMin(value): { fieldConfig+: { defaults+: { custom+: { axisSoftMin: value } } } }, + '#withAxisWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisWidth(value): { fieldConfig+: { defaults+: { custom+: { axisWidth: value } } } }, + '#withScaleDistribution': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistribution(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution: value } } } }, + '#withScaleDistributionMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistributionMixin(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: value } } } }, + scaleDistribution+: + { + '#withLinearThreshold': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLinearThreshold(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: { linearThreshold: value } } } } }, + '#withLog': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLog(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: { log: value } } } } }, + '#withType': { 'function': { args: [{ default: null, enums: ['linear', 'log', 'ordinal', 'symlog'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withType(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: { type: value } } } } }, + }, + '#withHideFrom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFrom(value): { fieldConfig+: { defaults+: { custom+: { hideFrom: value } } } }, + '#withHideFromMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFromMixin(value): { fieldConfig+: { defaults+: { custom+: { hideFrom+: value } } } }, + hideFrom+: + { + '#withLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withLegend(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { legend: value } } } } }, + '#withTooltip': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withTooltip(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { tooltip: value } } } } }, + '#withViz': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withViz(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { viz: value } } } } }, + }, + '#withFillOpacity': { 'function': { args: [{ default: 80, enums: null, name: 'value', type: 'integer' }], help: 'Controls the fill opacity of the bars.' } }, + withFillOpacity(value=80): { fieldConfig+: { defaults+: { custom+: { fillOpacity: value } } } }, + '#withGradientMode': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Set the mode of the gradient fill. Fill gradient is based on the line color. To change the color, use the standard color scheme field option.\nGradient appearance is influenced by the Fill opacity setting.' } }, + withGradientMode(value): { fieldConfig+: { defaults+: { custom+: { gradientMode: value } } } }, + '#withLineWidth': { 'function': { args: [{ default: 1, enums: null, name: 'value', type: 'integer' }], help: 'Controls line width of the bars.' } }, + withLineWidth(value=1): { fieldConfig+: { defaults+: { custom+: { lineWidth: value } } } }, + }, + }, + }, + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptions(value): { options: value }, + '#withOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptionsMixin(value): { options+: value }, + options+: + { + '#withLegend': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLegend(value): { options+: { legend: value } }, + '#withLegendMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLegendMixin(value): { options+: { legend+: value } }, + legend+: + { + '#withAsTable': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAsTable(value=true): { options+: { legend+: { asTable: value } } }, + '#withCalcs': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withCalcs(value): { options+: { legend+: { calcs: (if std.isArray(value) + then value + else [value]) } } }, + '#withCalcsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withCalcsMixin(value): { options+: { legend+: { calcs+: (if std.isArray(value) + then value + else [value]) } } }, + '#withDisplayMode': { 'function': { args: [{ default: null, enums: ['list', 'table', 'hidden'], name: 'value', type: 'string' }], help: 'TODO docs\nNote: "hidden" needs to remain as an option for plugins compatibility' } }, + withDisplayMode(value): { options+: { legend+: { displayMode: value } } }, + '#withIsVisible': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withIsVisible(value=true): { options+: { legend+: { isVisible: value } } }, + '#withPlacement': { 'function': { args: [{ default: null, enums: ['bottom', 'right'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withPlacement(value): { options+: { legend+: { placement: value } } }, + '#withShowLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowLegend(value=true): { options+: { legend+: { showLegend: value } } }, + '#withSortBy': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withSortBy(value): { options+: { legend+: { sortBy: value } } }, + '#withSortDesc': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withSortDesc(value=true): { options+: { legend+: { sortDesc: value } } }, + '#withWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withWidth(value): { options+: { legend+: { width: value } } }, + }, + '#withTooltip': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTooltip(value): { options+: { tooltip: value } }, + '#withTooltipMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTooltipMixin(value): { options+: { tooltip+: value } }, + tooltip+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['single', 'multi', 'none'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withMode(value): { options+: { tooltip+: { mode: value } } }, + '#withSort': { 'function': { args: [{ default: null, enums: ['asc', 'desc', 'none'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withSort(value): { options+: { tooltip+: { sort: value } } }, + }, + '#withBucketOffset': { 'function': { args: [{ default: 0, enums: null, name: 'value', type: 'integer' }], help: 'Offset buckets by this amount' } }, + withBucketOffset(value=0): { options+: { bucketOffset: value } }, + '#withBucketSize': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'Size of each bucket' } }, + withBucketSize(value): { options+: { bucketSize: value } }, + '#withCombine': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Combines multiple series into a single histogram' } }, + withCombine(value=true): { options+: { combine: value } }, + }, + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'histogram' }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/logs.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/logs.libsonnet new file mode 100644 index 0000000000..e140795146 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/logs.libsonnet @@ -0,0 +1,29 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.panel.logs', name: 'logs' }, + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptions(value): { options: value }, + '#withOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptionsMixin(value): { options+: value }, + options+: + { + '#withDedupStrategy': { 'function': { args: [{ default: null, enums: ['none', 'exact', 'numbers', 'signature'], name: 'value', type: 'string' }], help: '' } }, + withDedupStrategy(value): { options+: { dedupStrategy: value } }, + '#withEnableLogDetails': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withEnableLogDetails(value=true): { options+: { enableLogDetails: value } }, + '#withPrettifyLogMessage': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withPrettifyLogMessage(value=true): { options+: { prettifyLogMessage: value } }, + '#withShowCommonLabels': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowCommonLabels(value=true): { options+: { showCommonLabels: value } }, + '#withShowLabels': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowLabels(value=true): { options+: { showLabels: value } }, + '#withShowTime': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowTime(value=true): { options+: { showTime: value } }, + '#withSortOrder': { 'function': { args: [{ default: null, enums: ['Descending', 'Ascending'], name: 'value', type: 'string' }], help: '' } }, + withSortOrder(value): { options+: { sortOrder: value } }, + '#withWrapLogMessage': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withWrapLogMessage(value=true): { options+: { wrapLogMessage: value } }, + }, + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'logs' }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/news.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/news.libsonnet new file mode 100644 index 0000000000..34e5618bc8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/news.libsonnet @@ -0,0 +1,17 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.panel.news', name: 'news' }, + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptions(value): { options: value }, + '#withOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptionsMixin(value): { options+: value }, + options+: + { + '#withFeedUrl': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'empty/missing will default to grafana blog' } }, + withFeedUrl(value): { options+: { feedUrl: value } }, + '#withShowImage': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowImage(value=true): { options+: { showImage: value } }, + }, + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'news' }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/nodeGraph.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/nodeGraph.libsonnet new file mode 100644 index 0000000000..54977a1be8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/nodeGraph.libsonnet @@ -0,0 +1,100 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.panel.nodeGraph', name: 'nodeGraph' }, + '#withArcOption': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withArcOption(value): { ArcOption: value }, + '#withArcOptionMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withArcOptionMixin(value): { ArcOption+: value }, + ArcOption+: + { + '#withColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The color of the arc.' } }, + withColor(value): { ArcOption+: { color: value } }, + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Field from which to get the value. Values should be less than 1, representing fraction of a circle.' } }, + withField(value): { ArcOption+: { field: value } }, + }, + '#withEdgeOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withEdgeOptions(value): { EdgeOptions: value }, + '#withEdgeOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withEdgeOptionsMixin(value): { EdgeOptions+: value }, + EdgeOptions+: + { + '#withMainStatUnit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Unit for the main stat to override what ever is set in the data frame.' } }, + withMainStatUnit(value): { EdgeOptions+: { mainStatUnit: value } }, + '#withSecondaryStatUnit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Unit for the secondary stat to override what ever is set in the data frame.' } }, + withSecondaryStatUnit(value): { EdgeOptions+: { secondaryStatUnit: value } }, + }, + '#withNodeOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withNodeOptions(value): { NodeOptions: value }, + '#withNodeOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withNodeOptionsMixin(value): { NodeOptions+: value }, + NodeOptions+: + { + '#withArcs': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Define which fields are shown as part of the node arc (colored circle around the node).' } }, + withArcs(value): { NodeOptions+: { arcs: (if std.isArray(value) + then value + else [value]) } }, + '#withArcsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Define which fields are shown as part of the node arc (colored circle around the node).' } }, + withArcsMixin(value): { NodeOptions+: { arcs+: (if std.isArray(value) + then value + else [value]) } }, + arcs+: + { + '#': { help: '', name: 'arcs' }, + '#withColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The color of the arc.' } }, + withColor(value): { color: value }, + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Field from which to get the value. Values should be less than 1, representing fraction of a circle.' } }, + withField(value): { field: value }, + }, + '#withMainStatUnit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Unit for the main stat to override what ever is set in the data frame.' } }, + withMainStatUnit(value): { NodeOptions+: { mainStatUnit: value } }, + '#withSecondaryStatUnit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Unit for the secondary stat to override what ever is set in the data frame.' } }, + withSecondaryStatUnit(value): { NodeOptions+: { secondaryStatUnit: value } }, + }, + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptions(value): { options: value }, + '#withOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptionsMixin(value): { options+: value }, + options+: + { + '#withEdges': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withEdges(value): { options+: { edges: value } }, + '#withEdgesMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withEdgesMixin(value): { options+: { edges+: value } }, + edges+: + { + '#withMainStatUnit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Unit for the main stat to override what ever is set in the data frame.' } }, + withMainStatUnit(value): { options+: { edges+: { mainStatUnit: value } } }, + '#withSecondaryStatUnit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Unit for the secondary stat to override what ever is set in the data frame.' } }, + withSecondaryStatUnit(value): { options+: { edges+: { secondaryStatUnit: value } } }, + }, + '#withNodes': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withNodes(value): { options+: { nodes: value } }, + '#withNodesMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withNodesMixin(value): { options+: { nodes+: value } }, + nodes+: + { + '#withArcs': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Define which fields are shown as part of the node arc (colored circle around the node).' } }, + withArcs(value): { options+: { nodes+: { arcs: (if std.isArray(value) + then value + else [value]) } } }, + '#withArcsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Define which fields are shown as part of the node arc (colored circle around the node).' } }, + withArcsMixin(value): { options+: { nodes+: { arcs+: (if std.isArray(value) + then value + else [value]) } } }, + arcs+: + { + '#': { help: '', name: 'arcs' }, + '#withColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The color of the arc.' } }, + withColor(value): { color: value }, + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Field from which to get the value. Values should be less than 1, representing fraction of a circle.' } }, + withField(value): { field: value }, + }, + '#withMainStatUnit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Unit for the main stat to override what ever is set in the data frame.' } }, + withMainStatUnit(value): { options+: { nodes+: { mainStatUnit: value } } }, + '#withSecondaryStatUnit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Unit for the secondary stat to override what ever is set in the data frame.' } }, + withSecondaryStatUnit(value): { options+: { nodes+: { secondaryStatUnit: value } } }, + }, + }, + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'nodeGraph' }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/pieChart.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/pieChart.libsonnet new file mode 100644 index 0000000000..cb4be75fd8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/pieChart.libsonnet @@ -0,0 +1,186 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.panel.pieChart', name: 'pieChart' }, + '#withPieChartLabels': { 'function': { args: [{ default: null, enums: ['name', 'value', 'percent'], name: 'value', type: 'string' }], help: 'Select labels to display on the pie chart.\n - Name - The series or field name.\n - Percent - The percentage of the whole.\n - Value - The raw numerical value.' } }, + withPieChartLabels(value): { PieChartLabels: value }, + '#withPieChartLegendOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withPieChartLegendOptions(value): { PieChartLegendOptions: value }, + '#withPieChartLegendOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withPieChartLegendOptionsMixin(value): { PieChartLegendOptions+: value }, + PieChartLegendOptions+: + { + '#withAsTable': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAsTable(value=true): { PieChartLegendOptions+: { asTable: value } }, + '#withCalcs': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withCalcs(value): { PieChartLegendOptions+: { calcs: (if std.isArray(value) + then value + else [value]) } }, + '#withCalcsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withCalcsMixin(value): { PieChartLegendOptions+: { calcs+: (if std.isArray(value) + then value + else [value]) } }, + '#withDisplayMode': { 'function': { args: [{ default: null, enums: ['list', 'table', 'hidden'], name: 'value', type: 'string' }], help: 'TODO docs\nNote: "hidden" needs to remain as an option for plugins compatibility' } }, + withDisplayMode(value): { PieChartLegendOptions+: { displayMode: value } }, + '#withIsVisible': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withIsVisible(value=true): { PieChartLegendOptions+: { isVisible: value } }, + '#withPlacement': { 'function': { args: [{ default: null, enums: ['bottom', 'right'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withPlacement(value): { PieChartLegendOptions+: { placement: value } }, + '#withShowLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowLegend(value=true): { PieChartLegendOptions+: { showLegend: value } }, + '#withSortBy': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withSortBy(value): { PieChartLegendOptions+: { sortBy: value } }, + '#withSortDesc': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withSortDesc(value=true): { PieChartLegendOptions+: { sortDesc: value } }, + '#withWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withWidth(value): { PieChartLegendOptions+: { width: value } }, + '#withValues': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withValues(value): { PieChartLegendOptions+: { values: (if std.isArray(value) + then value + else [value]) } }, + '#withValuesMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withValuesMixin(value): { PieChartLegendOptions+: { values+: (if std.isArray(value) + then value + else [value]) } }, + }, + '#withPieChartLegendValues': { 'function': { args: [{ default: null, enums: ['value', 'percent'], name: 'value', type: 'string' }], help: 'Select values to display in the legend.\n - Percent: The percentage of the whole.\n - Value: The raw numerical value.' } }, + withPieChartLegendValues(value): { PieChartLegendValues: value }, + '#withPieChartType': { 'function': { args: [{ default: null, enums: ['pie', 'donut'], name: 'value', type: 'string' }], help: 'Select the pie chart display style.' } }, + withPieChartType(value): { PieChartType: value }, + '#withFieldConfig': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withFieldConfig(value): { fieldConfig: value }, + '#withFieldConfigMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withFieldConfigMixin(value): { fieldConfig+: value }, + fieldConfig+: + { + '#withDefaults': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withDefaults(value): { fieldConfig+: { defaults: value } }, + '#withDefaultsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withDefaultsMixin(value): { fieldConfig+: { defaults+: value } }, + defaults+: + { + '#withCustom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withCustom(value): { fieldConfig+: { defaults+: { custom: value } } }, + '#withCustomMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withCustomMixin(value): { fieldConfig+: { defaults+: { custom+: value } } }, + custom+: + { + '#withHideFrom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFrom(value): { fieldConfig+: { defaults+: { custom+: { hideFrom: value } } } }, + '#withHideFromMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFromMixin(value): { fieldConfig+: { defaults+: { custom+: { hideFrom+: value } } } }, + hideFrom+: + { + '#withLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withLegend(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { legend: value } } } } }, + '#withTooltip': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withTooltip(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { tooltip: value } } } } }, + '#withViz': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withViz(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { viz: value } } } } }, + }, + }, + }, + }, + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptions(value): { options: value }, + '#withOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptionsMixin(value): { options+: value }, + options+: + { + '#withTooltip': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTooltip(value): { options+: { tooltip: value } }, + '#withTooltipMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTooltipMixin(value): { options+: { tooltip+: value } }, + tooltip+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['single', 'multi', 'none'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withMode(value): { options+: { tooltip+: { mode: value } } }, + '#withSort': { 'function': { args: [{ default: null, enums: ['asc', 'desc', 'none'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withSort(value): { options+: { tooltip+: { sort: value } } }, + }, + '#withText': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withText(value): { options+: { text: value } }, + '#withTextMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTextMixin(value): { options+: { text+: value } }, + text+: + { + '#withTitleSize': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Explicit title text size' } }, + withTitleSize(value): { options+: { text+: { titleSize: value } } }, + '#withValueSize': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Explicit value text size' } }, + withValueSize(value): { options+: { text+: { valueSize: value } } }, + }, + '#withOrientation': { 'function': { args: [{ default: null, enums: ['auto', 'vertical', 'horizontal'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withOrientation(value): { options+: { orientation: value } }, + '#withReduceOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withReduceOptions(value): { options+: { reduceOptions: value } }, + '#withReduceOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withReduceOptionsMixin(value): { options+: { reduceOptions+: value } }, + reduceOptions+: + { + '#withCalcs': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'When !values, pick one value for the whole field' } }, + withCalcs(value): { options+: { reduceOptions+: { calcs: (if std.isArray(value) + then value + else [value]) } } }, + '#withCalcsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'When !values, pick one value for the whole field' } }, + withCalcsMixin(value): { options+: { reduceOptions+: { calcs+: (if std.isArray(value) + then value + else [value]) } } }, + '#withFields': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Which fields to show. By default this is only numeric fields' } }, + withFields(value): { options+: { reduceOptions+: { fields: value } } }, + '#withLimit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'if showing all values limit' } }, + withLimit(value): { options+: { reduceOptions+: { limit: value } } }, + '#withValues': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'If true show each row value' } }, + withValues(value=true): { options+: { reduceOptions+: { values: value } } }, + }, + '#withDisplayLabels': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withDisplayLabels(value): { options+: { displayLabels: (if std.isArray(value) + then value + else [value]) } }, + '#withDisplayLabelsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withDisplayLabelsMixin(value): { options+: { displayLabels+: (if std.isArray(value) + then value + else [value]) } }, + '#withLegend': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withLegend(value): { options+: { legend: value } }, + '#withLegendMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withLegendMixin(value): { options+: { legend+: value } }, + legend+: + { + '#withAsTable': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAsTable(value=true): { options+: { legend+: { asTable: value } } }, + '#withCalcs': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withCalcs(value): { options+: { legend+: { calcs: (if std.isArray(value) + then value + else [value]) } } }, + '#withCalcsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withCalcsMixin(value): { options+: { legend+: { calcs+: (if std.isArray(value) + then value + else [value]) } } }, + '#withDisplayMode': { 'function': { args: [{ default: null, enums: ['list', 'table', 'hidden'], name: 'value', type: 'string' }], help: 'TODO docs\nNote: "hidden" needs to remain as an option for plugins compatibility' } }, + withDisplayMode(value): { options+: { legend+: { displayMode: value } } }, + '#withIsVisible': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withIsVisible(value=true): { options+: { legend+: { isVisible: value } } }, + '#withPlacement': { 'function': { args: [{ default: null, enums: ['bottom', 'right'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withPlacement(value): { options+: { legend+: { placement: value } } }, + '#withShowLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowLegend(value=true): { options+: { legend+: { showLegend: value } } }, + '#withSortBy': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withSortBy(value): { options+: { legend+: { sortBy: value } } }, + '#withSortDesc': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withSortDesc(value=true): { options+: { legend+: { sortDesc: value } } }, + '#withWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withWidth(value): { options+: { legend+: { width: value } } }, + '#withValues': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withValues(value): { options+: { legend+: { values: (if std.isArray(value) + then value + else [value]) } } }, + '#withValuesMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withValuesMixin(value): { options+: { legend+: { values+: (if std.isArray(value) + then value + else [value]) } } }, + }, + '#withPieType': { 'function': { args: [{ default: null, enums: ['pie', 'donut'], name: 'value', type: 'string' }], help: 'Select the pie chart display style.' } }, + withPieType(value): { options+: { pieType: value } }, + }, + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'piechart' }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/row.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/row.libsonnet new file mode 100644 index 0000000000..8855b79225 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/row.libsonnet @@ -0,0 +1,51 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.panel.row', name: 'row' }, + '#withCollapsed': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withCollapsed(value=true): { collapsed: value }, + '#withDatasource': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Name of default datasource.' } }, + withDatasource(value): { datasource: value }, + '#withDatasourceMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Name of default datasource.' } }, + withDatasourceMixin(value): { datasource+: value }, + datasource+: + { + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { datasource+: { type: value } }, + '#withUid': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withUid(value): { datasource+: { uid: value } }, + }, + '#withGridPos': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withGridPos(value): { gridPos: value }, + '#withGridPosMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withGridPosMixin(value): { gridPos+: value }, + gridPos+: + { + '#withH': { 'function': { args: [{ default: 9, enums: null, name: 'value', type: 'integer' }], help: 'Panel' } }, + withH(value=9): { gridPos+: { h: value } }, + '#withStatic': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'true if fixed' } }, + withStatic(value=true): { gridPos+: { static: value } }, + '#withW': { 'function': { args: [{ default: 12, enums: null, name: 'value', type: 'integer' }], help: 'Panel' } }, + withW(value=12): { gridPos+: { w: value } }, + '#withX': { 'function': { args: [{ default: 0, enums: null, name: 'value', type: 'integer' }], help: 'Panel x' } }, + withX(value=0): { gridPos+: { x: value } }, + '#withY': { 'function': { args: [{ default: 0, enums: null, name: 'value', type: 'integer' }], help: 'Panel y' } }, + withY(value=0): { gridPos+: { y: value } }, + }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withId(value): { id: value }, + '#withPanels': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withPanels(value): { panels: (if std.isArray(value) + then value + else [value]) }, + '#withPanelsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withPanelsMixin(value): { panels+: (if std.isArray(value) + then value + else [value]) }, + '#withRepeat': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Name of template variable to repeat for.' } }, + withRepeat(value): { repeat: value }, + '#withTitle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withTitle(value): { title: value }, + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'row' }, +} ++ (import '../../custom/row.libsonnet') diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/stat.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/stat.libsonnet new file mode 100644 index 0000000000..5011674691 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/stat.libsonnet @@ -0,0 +1,55 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.panel.stat', name: 'stat' }, + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptions(value): { options: value }, + '#withOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptionsMixin(value): { options+: value }, + options+: + { + '#withText': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withText(value): { options+: { text: value } }, + '#withTextMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTextMixin(value): { options+: { text+: value } }, + text+: + { + '#withTitleSize': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Explicit title text size' } }, + withTitleSize(value): { options+: { text+: { titleSize: value } } }, + '#withValueSize': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'Explicit value text size' } }, + withValueSize(value): { options+: { text+: { valueSize: value } } }, + }, + '#withOrientation': { 'function': { args: [{ default: null, enums: ['auto', 'vertical', 'horizontal'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withOrientation(value): { options+: { orientation: value } }, + '#withReduceOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withReduceOptions(value): { options+: { reduceOptions: value } }, + '#withReduceOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withReduceOptionsMixin(value): { options+: { reduceOptions+: value } }, + reduceOptions+: + { + '#withCalcs': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'When !values, pick one value for the whole field' } }, + withCalcs(value): { options+: { reduceOptions+: { calcs: (if std.isArray(value) + then value + else [value]) } } }, + '#withCalcsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'When !values, pick one value for the whole field' } }, + withCalcsMixin(value): { options+: { reduceOptions+: { calcs+: (if std.isArray(value) + then value + else [value]) } } }, + '#withFields': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Which fields to show. By default this is only numeric fields' } }, + withFields(value): { options+: { reduceOptions+: { fields: value } } }, + '#withLimit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: 'if showing all values limit' } }, + withLimit(value): { options+: { reduceOptions+: { limit: value } } }, + '#withValues': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'If true show each row value' } }, + withValues(value=true): { options+: { reduceOptions+: { values: value } } }, + }, + '#withColorMode': { 'function': { args: [{ default: null, enums: ['value', 'background', 'background_solid', 'none'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withColorMode(value): { options+: { colorMode: value } }, + '#withGraphMode': { 'function': { args: [{ default: null, enums: ['none', 'line', 'area'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withGraphMode(value): { options+: { graphMode: value } }, + '#withJustifyMode': { 'function': { args: [{ default: null, enums: ['auto', 'center'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withJustifyMode(value): { options+: { justifyMode: value } }, + '#withTextMode': { 'function': { args: [{ default: null, enums: ['auto', 'value', 'value_and_name', 'name', 'none'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withTextMode(value): { options+: { textMode: value } }, + }, + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'stat' }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/stateTimeline.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/stateTimeline.libsonnet new file mode 100644 index 0000000000..3fa3ca8c92 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/stateTimeline.libsonnet @@ -0,0 +1,109 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.panel.stateTimeline', name: 'stateTimeline' }, + '#withFieldConfig': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withFieldConfig(value): { fieldConfig: value }, + '#withFieldConfigMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withFieldConfigMixin(value): { fieldConfig+: value }, + fieldConfig+: + { + '#withDefaults': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withDefaults(value): { fieldConfig+: { defaults: value } }, + '#withDefaultsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withDefaultsMixin(value): { fieldConfig+: { defaults+: value } }, + defaults+: + { + '#withCustom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withCustom(value): { fieldConfig+: { defaults+: { custom: value } } }, + '#withCustomMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withCustomMixin(value): { fieldConfig+: { defaults+: { custom+: value } } }, + custom+: + { + '#withHideFrom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFrom(value): { fieldConfig+: { defaults+: { custom+: { hideFrom: value } } } }, + '#withHideFromMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFromMixin(value): { fieldConfig+: { defaults+: { custom+: { hideFrom+: value } } } }, + hideFrom+: + { + '#withLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withLegend(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { legend: value } } } } }, + '#withTooltip': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withTooltip(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { tooltip: value } } } } }, + '#withViz': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withViz(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { viz: value } } } } }, + }, + '#withFillOpacity': { 'function': { args: [{ default: 70, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withFillOpacity(value=70): { fieldConfig+: { defaults+: { custom+: { fillOpacity: value } } } }, + '#withLineWidth': { 'function': { args: [{ default: 0, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withLineWidth(value=0): { fieldConfig+: { defaults+: { custom+: { lineWidth: value } } } }, + }, + }, + }, + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptions(value): { options: value }, + '#withOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptionsMixin(value): { options+: value }, + options+: + { + '#withLegend': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLegend(value): { options+: { legend: value } }, + '#withLegendMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLegendMixin(value): { options+: { legend+: value } }, + legend+: + { + '#withAsTable': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAsTable(value=true): { options+: { legend+: { asTable: value } } }, + '#withCalcs': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withCalcs(value): { options+: { legend+: { calcs: (if std.isArray(value) + then value + else [value]) } } }, + '#withCalcsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withCalcsMixin(value): { options+: { legend+: { calcs+: (if std.isArray(value) + then value + else [value]) } } }, + '#withDisplayMode': { 'function': { args: [{ default: null, enums: ['list', 'table', 'hidden'], name: 'value', type: 'string' }], help: 'TODO docs\nNote: "hidden" needs to remain as an option for plugins compatibility' } }, + withDisplayMode(value): { options+: { legend+: { displayMode: value } } }, + '#withIsVisible': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withIsVisible(value=true): { options+: { legend+: { isVisible: value } } }, + '#withPlacement': { 'function': { args: [{ default: null, enums: ['bottom', 'right'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withPlacement(value): { options+: { legend+: { placement: value } } }, + '#withShowLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowLegend(value=true): { options+: { legend+: { showLegend: value } } }, + '#withSortBy': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withSortBy(value): { options+: { legend+: { sortBy: value } } }, + '#withSortDesc': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withSortDesc(value=true): { options+: { legend+: { sortDesc: value } } }, + '#withWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withWidth(value): { options+: { legend+: { width: value } } }, + }, + '#withTooltip': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTooltip(value): { options+: { tooltip: value } }, + '#withTooltipMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTooltipMixin(value): { options+: { tooltip+: value } }, + tooltip+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['single', 'multi', 'none'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withMode(value): { options+: { tooltip+: { mode: value } } }, + '#withSort': { 'function': { args: [{ default: null, enums: ['asc', 'desc', 'none'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withSort(value): { options+: { tooltip+: { sort: value } } }, + }, + '#withTimezone': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTimezone(value): { options+: { timezone: (if std.isArray(value) + then value + else [value]) } }, + '#withTimezoneMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTimezoneMixin(value): { options+: { timezone+: (if std.isArray(value) + then value + else [value]) } }, + '#withAlignValue': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Controls value alignment on the timelines' } }, + withAlignValue(value): { options+: { alignValue: value } }, + '#withMergeValues': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Merge equal consecutive values' } }, + withMergeValues(value=true): { options+: { mergeValues: value } }, + '#withRowHeight': { 'function': { args: [{ default: 0.90000000000000002, enums: null, name: 'value', type: 'number' }], help: 'Controls the row height' } }, + withRowHeight(value=0.90000000000000002): { options+: { rowHeight: value } }, + '#withShowValue': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Show timeline values on chart' } }, + withShowValue(value): { options+: { showValue: value } }, + }, + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'state-timeline' }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/statusHistory.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/statusHistory.libsonnet new file mode 100644 index 0000000000..2dbbf8aad9 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/statusHistory.libsonnet @@ -0,0 +1,107 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.panel.statusHistory', name: 'statusHistory' }, + '#withFieldConfig': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withFieldConfig(value): { fieldConfig: value }, + '#withFieldConfigMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withFieldConfigMixin(value): { fieldConfig+: value }, + fieldConfig+: + { + '#withDefaults': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withDefaults(value): { fieldConfig+: { defaults: value } }, + '#withDefaultsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withDefaultsMixin(value): { fieldConfig+: { defaults+: value } }, + defaults+: + { + '#withCustom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withCustom(value): { fieldConfig+: { defaults+: { custom: value } } }, + '#withCustomMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withCustomMixin(value): { fieldConfig+: { defaults+: { custom+: value } } }, + custom+: + { + '#withHideFrom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFrom(value): { fieldConfig+: { defaults+: { custom+: { hideFrom: value } } } }, + '#withHideFromMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFromMixin(value): { fieldConfig+: { defaults+: { custom+: { hideFrom+: value } } } }, + hideFrom+: + { + '#withLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withLegend(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { legend: value } } } } }, + '#withTooltip': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withTooltip(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { tooltip: value } } } } }, + '#withViz': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withViz(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { viz: value } } } } }, + }, + '#withFillOpacity': { 'function': { args: [{ default: 70, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withFillOpacity(value=70): { fieldConfig+: { defaults+: { custom+: { fillOpacity: value } } } }, + '#withLineWidth': { 'function': { args: [{ default: 1, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withLineWidth(value=1): { fieldConfig+: { defaults+: { custom+: { lineWidth: value } } } }, + }, + }, + }, + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptions(value): { options: value }, + '#withOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptionsMixin(value): { options+: value }, + options+: + { + '#withLegend': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLegend(value): { options+: { legend: value } }, + '#withLegendMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLegendMixin(value): { options+: { legend+: value } }, + legend+: + { + '#withAsTable': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAsTable(value=true): { options+: { legend+: { asTable: value } } }, + '#withCalcs': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withCalcs(value): { options+: { legend+: { calcs: (if std.isArray(value) + then value + else [value]) } } }, + '#withCalcsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withCalcsMixin(value): { options+: { legend+: { calcs+: (if std.isArray(value) + then value + else [value]) } } }, + '#withDisplayMode': { 'function': { args: [{ default: null, enums: ['list', 'table', 'hidden'], name: 'value', type: 'string' }], help: 'TODO docs\nNote: "hidden" needs to remain as an option for plugins compatibility' } }, + withDisplayMode(value): { options+: { legend+: { displayMode: value } } }, + '#withIsVisible': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withIsVisible(value=true): { options+: { legend+: { isVisible: value } } }, + '#withPlacement': { 'function': { args: [{ default: null, enums: ['bottom', 'right'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withPlacement(value): { options+: { legend+: { placement: value } } }, + '#withShowLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowLegend(value=true): { options+: { legend+: { showLegend: value } } }, + '#withSortBy': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withSortBy(value): { options+: { legend+: { sortBy: value } } }, + '#withSortDesc': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withSortDesc(value=true): { options+: { legend+: { sortDesc: value } } }, + '#withWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withWidth(value): { options+: { legend+: { width: value } } }, + }, + '#withTooltip': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTooltip(value): { options+: { tooltip: value } }, + '#withTooltipMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTooltipMixin(value): { options+: { tooltip+: value } }, + tooltip+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['single', 'multi', 'none'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withMode(value): { options+: { tooltip+: { mode: value } } }, + '#withSort': { 'function': { args: [{ default: null, enums: ['asc', 'desc', 'none'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withSort(value): { options+: { tooltip+: { sort: value } } }, + }, + '#withTimezone': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTimezone(value): { options+: { timezone: (if std.isArray(value) + then value + else [value]) } }, + '#withTimezoneMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTimezoneMixin(value): { options+: { timezone+: (if std.isArray(value) + then value + else [value]) } }, + '#withColWidth': { 'function': { args: [{ default: 0.90000000000000002, enums: null, name: 'value', type: 'number' }], help: 'Controls the column width' } }, + withColWidth(value=0.90000000000000002): { options+: { colWidth: value } }, + '#withRowHeight': { 'function': { args: [{ default: 0.90000000000000002, enums: null, name: 'value', type: 'number' }], help: 'Set the height of the rows' } }, + withRowHeight(value=0.90000000000000002): { options+: { rowHeight: value } }, + '#withShowValue': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Show values on the columns' } }, + withShowValue(value): { options+: { showValue: value } }, + }, + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'status-history' }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/table.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/table.libsonnet new file mode 100644 index 0000000000..6ebe122a85 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/table.libsonnet @@ -0,0 +1,299 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.panel.table', name: 'table' }, + '#withFieldConfig': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withFieldConfig(value): { fieldConfig: value }, + '#withFieldConfigMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withFieldConfigMixin(value): { fieldConfig+: value }, + fieldConfig+: + { + '#withDefaults': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withDefaults(value): { fieldConfig+: { defaults: value } }, + '#withDefaultsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withDefaultsMixin(value): { fieldConfig+: { defaults+: value } }, + defaults+: + { + '#withCustom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Field options for each field within a table (e.g 10, "The String", 64.20, etc.) Generally defines alignment, filtering capabilties, display options, etc.' } }, + withCustom(value): { fieldConfig+: { defaults+: { custom: value } } }, + '#withCustomMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Field options for each field within a table (e.g 10, "The String", 64.20, etc.) Generally defines alignment, filtering capabilties, display options, etc.' } }, + withCustomMixin(value): { fieldConfig+: { defaults+: { custom+: value } } }, + custom+: + { + '#withAlign': { 'function': { args: [{ default: null, enums: ['auto', 'left', 'right', 'center'], name: 'value', type: 'string' }], help: 'TODO -- should not be table specific! TODO docs' } }, + withAlign(value): { fieldConfig+: { defaults+: { custom+: { align: value } } } }, + '#withCellOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Table cell options. Each cell has a display mode and other potential options for that display.' } }, + withCellOptions(value): { fieldConfig+: { defaults+: { custom+: { cellOptions: value } } } }, + '#withCellOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Table cell options. Each cell has a display mode and other potential options for that display.' } }, + withCellOptionsMixin(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: value } } } }, + cellOptions+: + { + '#withTableAutoCellOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Auto mode table cell options' } }, + withTableAutoCellOptions(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { TableAutoCellOptions: value } } } } }, + '#withTableAutoCellOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Auto mode table cell options' } }, + withTableAutoCellOptionsMixin(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { TableAutoCellOptions+: value } } } } }, + TableAutoCellOptions+: + { + '#withType': { 'function': { args: [], help: '' } }, + withType(): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { type: 'auto' } } } } }, + }, + '#withTableSparklineCellOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Sparkline cell options' } }, + withTableSparklineCellOptions(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { TableSparklineCellOptions: value } } } } }, + '#withTableSparklineCellOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Sparkline cell options' } }, + withTableSparklineCellOptionsMixin(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { TableSparklineCellOptions+: value } } } } }, + TableSparklineCellOptions+: + { + '#withAxisCenteredZero': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAxisCenteredZero(value=true): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { axisCenteredZero: value } } } } }, + '#withAxisColorMode': { 'function': { args: [{ default: null, enums: ['series', 'text'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withAxisColorMode(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { axisColorMode: value } } } } }, + '#withAxisGridShow': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAxisGridShow(value=true): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { axisGridShow: value } } } } }, + '#withAxisLabel': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withAxisLabel(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { axisLabel: value } } } } }, + '#withAxisPlacement': { 'function': { args: [{ default: null, enums: ['auto', 'bottom', 'hidden', 'left', 'right', 'top'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withAxisPlacement(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { axisPlacement: value } } } } }, + '#withAxisSoftMax': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisSoftMax(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { axisSoftMax: value } } } } }, + '#withAxisSoftMin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisSoftMin(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { axisSoftMin: value } } } } }, + '#withAxisWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisWidth(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { axisWidth: value } } } } }, + '#withBarAlignment': { 'function': { args: [{ default: null, enums: [1, -1, 0], name: 'value', type: 'number' }], help: 'TODO docs' } }, + withBarAlignment(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { barAlignment: value } } } } }, + '#withBarMaxWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withBarMaxWidth(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { barMaxWidth: value } } } } }, + '#withBarWidthFactor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withBarWidthFactor(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { barWidthFactor: value } } } } }, + '#withDrawStyle': { 'function': { args: [{ default: null, enums: ['bars', 'line', 'points'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withDrawStyle(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { drawStyle: value } } } } }, + '#withFillBelowTo': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withFillBelowTo(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { fillBelowTo: value } } } } }, + '#withFillColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withFillColor(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { fillColor: value } } } } }, + '#withFillOpacity': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withFillOpacity(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { fillOpacity: value } } } } }, + '#withGradientMode': { 'function': { args: [{ default: null, enums: ['hue', 'none', 'opacity', 'scheme'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withGradientMode(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { gradientMode: value } } } } }, + '#withHideFrom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFrom(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { hideFrom: value } } } } }, + '#withHideFromMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFromMixin(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { hideFrom+: value } } } } }, + hideFrom+: + { + '#withLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withLegend(value=true): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { hideFrom+: { legend: value } } } } } }, + '#withTooltip': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withTooltip(value=true): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { hideFrom+: { tooltip: value } } } } } }, + '#withViz': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withViz(value=true): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { hideFrom+: { viz: value } } } } } }, + }, + '#withLineColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withLineColor(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { lineColor: value } } } } }, + '#withLineInterpolation': { 'function': { args: [{ default: null, enums: ['linear', 'smooth', 'stepAfter', 'stepBefore'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withLineInterpolation(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { lineInterpolation: value } } } } }, + '#withLineStyle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLineStyle(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { lineStyle: value } } } } }, + '#withLineStyleMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLineStyleMixin(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { lineStyle+: value } } } } }, + lineStyle+: + { + '#withDash': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withDash(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { lineStyle+: { dash: (if std.isArray(value) + then value + else [value]) } } } } } }, + '#withDashMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withDashMixin(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { lineStyle+: { dash+: (if std.isArray(value) + then value + else [value]) } } } } } }, + '#withFill': { 'function': { args: [{ default: null, enums: ['solid', 'dash', 'dot', 'square'], name: 'value', type: 'string' }], help: '' } }, + withFill(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { lineStyle+: { fill: value } } } } } }, + }, + '#withLineWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLineWidth(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { lineWidth: value } } } } }, + '#withPointColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withPointColor(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { pointColor: value } } } } }, + '#withPointSize': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withPointSize(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { pointSize: value } } } } }, + '#withPointSymbol': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withPointSymbol(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { pointSymbol: value } } } } }, + '#withScaleDistribution': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistribution(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { scaleDistribution: value } } } } }, + '#withScaleDistributionMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistributionMixin(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { scaleDistribution+: value } } } } }, + scaleDistribution+: + { + '#withLinearThreshold': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLinearThreshold(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { scaleDistribution+: { linearThreshold: value } } } } } }, + '#withLog': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLog(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { scaleDistribution+: { log: value } } } } } }, + '#withType': { 'function': { args: [{ default: null, enums: ['linear', 'log', 'ordinal', 'symlog'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withType(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { scaleDistribution+: { type: value } } } } } }, + }, + '#withShowPoints': { 'function': { args: [{ default: null, enums: ['always', 'auto', 'never'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withShowPoints(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { showPoints: value } } } } }, + '#withSpanNulls': { 'function': { args: [{ default: null, enums: null, name: 'value', type: ['boolean', 'number'] }], help: 'Indicate if null values should be treated as gaps or connected. When the value is a number, it represents the maximum delta in the X axis that should be considered connected. For timeseries, this is milliseconds' } }, + withSpanNulls(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { spanNulls: value } } } } }, + '#withStacking': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withStacking(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { stacking: value } } } } }, + '#withStackingMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withStackingMixin(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { stacking+: value } } } } }, + stacking+: + { + '#withGroup': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withGroup(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { stacking+: { group: value } } } } } }, + '#withMode': { 'function': { args: [{ default: null, enums: ['none', 'normal', 'percent'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withMode(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { stacking+: { mode: value } } } } } }, + }, + '#withThresholdsStyle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withThresholdsStyle(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { thresholdsStyle: value } } } } }, + '#withThresholdsStyleMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withThresholdsStyleMixin(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { thresholdsStyle+: value } } } } }, + thresholdsStyle+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['area', 'dashed', 'dashed+area', 'line', 'line+area', 'off', 'series'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withMode(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { thresholdsStyle+: { mode: value } } } } } }, + }, + '#withTransform': { 'function': { args: [{ default: null, enums: ['constant', 'negative-Y'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withTransform(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { transform: value } } } } }, + '#withType': { 'function': { args: [], help: '' } }, + withType(): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { type: 'sparkline' } } } } }, + }, + '#withTableBarGaugeCellOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Gauge cell options' } }, + withTableBarGaugeCellOptions(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { TableBarGaugeCellOptions: value } } } } }, + '#withTableBarGaugeCellOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Gauge cell options' } }, + withTableBarGaugeCellOptionsMixin(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { TableBarGaugeCellOptions+: value } } } } }, + TableBarGaugeCellOptions+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['basic', 'gradient', 'lcd'], name: 'value', type: 'string' }], help: 'Enum expressing the possible display modes for the bar gauge component of Grafana UI' } }, + withMode(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { mode: value } } } } }, + '#withType': { 'function': { args: [], help: '' } }, + withType(): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { type: 'gauge' } } } } }, + '#withValueDisplayMode': { 'function': { args: [{ default: null, enums: ['color', 'hidden', 'text'], name: 'value', type: 'string' }], help: 'Allows for the table cell gauge display type to set the gauge mode.' } }, + withValueDisplayMode(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { valueDisplayMode: value } } } } }, + }, + '#withTableColoredBackgroundCellOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Colored background cell options' } }, + withTableColoredBackgroundCellOptions(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { TableColoredBackgroundCellOptions: value } } } } }, + '#withTableColoredBackgroundCellOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Colored background cell options' } }, + withTableColoredBackgroundCellOptionsMixin(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { TableColoredBackgroundCellOptions+: value } } } } }, + TableColoredBackgroundCellOptions+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['basic', 'gradient'], name: 'value', type: 'string' }], help: 'Display mode to the "Colored Background" display mode for table cells. Either displays a solid color (basic mode) or a gradient.' } }, + withMode(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { mode: value } } } } }, + '#withType': { 'function': { args: [], help: '' } }, + withType(): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { type: 'color-background' } } } } }, + }, + '#withTableColorTextCellOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Colored text cell options' } }, + withTableColorTextCellOptions(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { TableColorTextCellOptions: value } } } } }, + '#withTableColorTextCellOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Colored text cell options' } }, + withTableColorTextCellOptionsMixin(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { TableColorTextCellOptions+: value } } } } }, + TableColorTextCellOptions+: + { + '#withType': { 'function': { args: [], help: '' } }, + withType(): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { type: 'color-text' } } } } }, + }, + '#withTableImageCellOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Json view cell options' } }, + withTableImageCellOptions(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { TableImageCellOptions: value } } } } }, + '#withTableImageCellOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Json view cell options' } }, + withTableImageCellOptionsMixin(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { TableImageCellOptions+: value } } } } }, + TableImageCellOptions+: + { + '#withType': { 'function': { args: [], help: '' } }, + withType(): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { type: 'image' } } } } }, + }, + '#withTableJsonViewCellOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Json view cell options' } }, + withTableJsonViewCellOptions(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { TableJsonViewCellOptions: value } } } } }, + '#withTableJsonViewCellOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Json view cell options' } }, + withTableJsonViewCellOptionsMixin(value): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { TableJsonViewCellOptions+: value } } } } }, + TableJsonViewCellOptions+: + { + '#withType': { 'function': { args: [], help: '' } }, + withType(): { fieldConfig+: { defaults+: { custom+: { cellOptions+: { type: 'json-view' } } } } }, + }, + }, + '#withDisplayMode': { 'function': { args: [{ default: null, enums: ['auto', 'basic', 'color-background', 'color-background-solid', 'color-text', 'custom', 'gauge', 'gradient-gauge', 'image', 'json-view', 'lcd-gauge', 'sparkline'], name: 'value', type: 'string' }], help: "Internally, this is the \"type\" of cell that's being displayed in the table such as colored text, JSON, gauge, etc. The color-background-solid, gradient-gauge, and lcd-gauge modes are deprecated in favor of new cell subOptions" } }, + withDisplayMode(value): { fieldConfig+: { defaults+: { custom+: { displayMode: value } } } }, + '#withFilterable': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withFilterable(value=true): { fieldConfig+: { defaults+: { custom+: { filterable: value } } } }, + '#withHidden': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withHidden(value=true): { fieldConfig+: { defaults+: { custom+: { hidden: value } } } }, + '#withHideHeader': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Hides any header for a column, usefull for columns that show some static content or buttons.' } }, + withHideHeader(value=true): { fieldConfig+: { defaults+: { custom+: { hideHeader: value } } } }, + '#withInspect': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withInspect(value=true): { fieldConfig+: { defaults+: { custom+: { inspect: value } } } }, + '#withMinWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withMinWidth(value): { fieldConfig+: { defaults+: { custom+: { minWidth: value } } } }, + '#withWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withWidth(value): { fieldConfig+: { defaults+: { custom+: { width: value } } } }, + }, + }, + }, + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptions(value): { options: value }, + '#withOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptionsMixin(value): { options+: value }, + options+: + { + '#withCellHeight': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Controls the height of the rows' } }, + withCellHeight(value): { options+: { cellHeight: value } }, + '#withFooter': { 'function': { args: [{ default: { countRows: false, reducer: [], show: false }, enums: null, name: 'value', type: 'object' }], help: 'Controls footer options' } }, + withFooter(value={ countRows: false, reducer: [], show: false }): { options+: { footer: value } }, + '#withFooterMixin': { 'function': { args: [{ default: { countRows: false, reducer: [], show: false }, enums: null, name: 'value', type: 'object' }], help: 'Controls footer options' } }, + withFooterMixin(value): { options+: { footer+: value } }, + footer+: + { + '#withTableFooterOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Footer options' } }, + withTableFooterOptions(value): { options+: { footer+: { TableFooterOptions: value } } }, + '#withTableFooterOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Footer options' } }, + withTableFooterOptionsMixin(value): { options+: { footer+: { TableFooterOptions+: value } } }, + TableFooterOptions+: + { + '#withCountRows': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withCountRows(value=true): { options+: { footer+: { countRows: value } } }, + '#withEnablePagination': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withEnablePagination(value=true): { options+: { footer+: { enablePagination: value } } }, + '#withFields': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withFields(value): { options+: { footer+: { fields: (if std.isArray(value) + then value + else [value]) } } }, + '#withFieldsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withFieldsMixin(value): { options+: { footer+: { fields+: (if std.isArray(value) + then value + else [value]) } } }, + '#withReducer': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withReducer(value): { options+: { footer+: { reducer: (if std.isArray(value) + then value + else [value]) } } }, + '#withReducerMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withReducerMixin(value): { options+: { footer+: { reducer+: (if std.isArray(value) + then value + else [value]) } } }, + '#withShow': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShow(value=true): { options+: { footer+: { show: value } } }, + }, + }, + '#withFrameIndex': { 'function': { args: [{ default: 0, enums: null, name: 'value', type: 'number' }], help: 'Represents the index of the selected frame' } }, + withFrameIndex(value=0): { options+: { frameIndex: value } }, + '#withShowHeader': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Controls whether the panel should show the header' } }, + withShowHeader(value=true): { options+: { showHeader: value } }, + '#withShowTypeIcons': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Controls whether the header should show icons for the column types' } }, + withShowTypeIcons(value=true): { options+: { showTypeIcons: value } }, + '#withSortBy': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Used to control row sorting' } }, + withSortBy(value): { options+: { sortBy: (if std.isArray(value) + then value + else [value]) } }, + '#withSortByMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Used to control row sorting' } }, + withSortByMixin(value): { options+: { sortBy+: (if std.isArray(value) + then value + else [value]) } }, + sortBy+: + { + '#': { help: '', name: 'sortBy' }, + '#withDesc': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Flag used to indicate descending sort order' } }, + withDesc(value=true): { desc: value }, + '#withDisplayName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Sets the display name of the field to sort by' } }, + withDisplayName(value): { displayName: value }, + }, + }, + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'table' }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/text.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/text.libsonnet new file mode 100644 index 0000000000..9e2dffb1f2 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/text.libsonnet @@ -0,0 +1,47 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.panel.text', name: 'text' }, + '#withCodeLanguage': { 'function': { args: [{ default: 'plaintext', enums: ['plaintext', 'yaml', 'xml', 'typescript', 'sql', 'go', 'markdown', 'html', 'json'], name: 'value', type: 'string' }], help: '' } }, + withCodeLanguage(value='plaintext'): { CodeLanguage: value }, + '#withCodeOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withCodeOptions(value): { CodeOptions: value }, + '#withCodeOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withCodeOptionsMixin(value): { CodeOptions+: value }, + CodeOptions+: + { + '#withLanguage': { 'function': { args: [{ default: 'plaintext', enums: ['plaintext', 'yaml', 'xml', 'typescript', 'sql', 'go', 'markdown', 'html', 'json'], name: 'value', type: 'string' }], help: '' } }, + withLanguage(value='plaintext'): { CodeOptions+: { language: value } }, + '#withShowLineNumbers': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowLineNumbers(value=true): { CodeOptions+: { showLineNumbers: value } }, + '#withShowMiniMap': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowMiniMap(value=true): { CodeOptions+: { showMiniMap: value } }, + }, + '#withTextMode': { 'function': { args: [{ default: null, enums: ['html', 'markdown', 'code'], name: 'value', type: 'string' }], help: '' } }, + withTextMode(value): { TextMode: value }, + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptions(value): { options: value }, + '#withOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptionsMixin(value): { options+: value }, + options+: + { + '#withCode': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withCode(value): { options+: { code: value } }, + '#withCodeMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withCodeMixin(value): { options+: { code+: value } }, + code+: + { + '#withLanguage': { 'function': { args: [{ default: 'plaintext', enums: ['plaintext', 'yaml', 'xml', 'typescript', 'sql', 'go', 'markdown', 'html', 'json'], name: 'value', type: 'string' }], help: '' } }, + withLanguage(value='plaintext'): { options+: { code+: { language: value } } }, + '#withShowLineNumbers': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowLineNumbers(value=true): { options+: { code+: { showLineNumbers: value } } }, + '#withShowMiniMap': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowMiniMap(value=true): { options+: { code+: { showMiniMap: value } } }, + }, + '#withContent': { 'function': { args: [{ default: '# Title\n\nFor markdown syntax help: [commonmark.org/help](https://commonmark.org/help/)', enums: null, name: 'value', type: 'string' }], help: '' } }, + withContent(value='# Title\n\nFor markdown syntax help: [commonmark.org/help](https://commonmark.org/help/)'): { options+: { content: value } }, + '#withMode': { 'function': { args: [{ default: null, enums: ['html', 'markdown', 'code'], name: 'value', type: 'string' }], help: '' } }, + withMode(value): { options+: { mode: value } }, + }, + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'text' }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/timeSeries.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/timeSeries.libsonnet new file mode 100644 index 0000000000..25f726b0d0 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/timeSeries.libsonnet @@ -0,0 +1,199 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.panel.timeSeries', name: 'timeSeries' }, + '#withFieldConfig': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withFieldConfig(value): { fieldConfig: value }, + '#withFieldConfigMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withFieldConfigMixin(value): { fieldConfig+: value }, + fieldConfig+: + { + '#withDefaults': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withDefaults(value): { fieldConfig+: { defaults: value } }, + '#withDefaultsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withDefaultsMixin(value): { fieldConfig+: { defaults+: value } }, + defaults+: + { + '#withCustom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withCustom(value): { fieldConfig+: { defaults+: { custom: value } } }, + '#withCustomMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withCustomMixin(value): { fieldConfig+: { defaults+: { custom+: value } } }, + custom+: + { + '#withLineColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withLineColor(value): { fieldConfig+: { defaults+: { custom+: { lineColor: value } } } }, + '#withLineInterpolation': { 'function': { args: [{ default: null, enums: ['linear', 'smooth', 'stepBefore', 'stepAfter'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withLineInterpolation(value): { fieldConfig+: { defaults+: { custom+: { lineInterpolation: value } } } }, + '#withLineStyle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLineStyle(value): { fieldConfig+: { defaults+: { custom+: { lineStyle: value } } } }, + '#withLineStyleMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLineStyleMixin(value): { fieldConfig+: { defaults+: { custom+: { lineStyle+: value } } } }, + lineStyle+: + { + '#withDash': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withDash(value): { fieldConfig+: { defaults+: { custom+: { lineStyle+: { dash: (if std.isArray(value) + then value + else [value]) } } } } }, + '#withDashMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withDashMixin(value): { fieldConfig+: { defaults+: { custom+: { lineStyle+: { dash+: (if std.isArray(value) + then value + else [value]) } } } } }, + '#withFill': { 'function': { args: [{ default: null, enums: ['solid', 'dash', 'dot', 'square'], name: 'value', type: 'string' }], help: '' } }, + withFill(value): { fieldConfig+: { defaults+: { custom+: { lineStyle+: { fill: value } } } } }, + }, + '#withLineWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLineWidth(value): { fieldConfig+: { defaults+: { custom+: { lineWidth: value } } } }, + '#withSpanNulls': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Indicate if null values should be treated as gaps or connected.\nWhen the value is a number, it represents the maximum delta in the\nX axis that should be considered connected. For timeseries, this is milliseconds' } }, + withSpanNulls(value): { fieldConfig+: { defaults+: { custom+: { spanNulls: value } } } }, + '#withSpanNullsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Indicate if null values should be treated as gaps or connected.\nWhen the value is a number, it represents the maximum delta in the\nX axis that should be considered connected. For timeseries, this is milliseconds' } }, + withSpanNullsMixin(value): { fieldConfig+: { defaults+: { custom+: { spanNulls+: value } } } }, + '#withFillBelowTo': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withFillBelowTo(value): { fieldConfig+: { defaults+: { custom+: { fillBelowTo: value } } } }, + '#withFillColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withFillColor(value): { fieldConfig+: { defaults+: { custom+: { fillColor: value } } } }, + '#withFillOpacity': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withFillOpacity(value): { fieldConfig+: { defaults+: { custom+: { fillOpacity: value } } } }, + '#withPointColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withPointColor(value): { fieldConfig+: { defaults+: { custom+: { pointColor: value } } } }, + '#withPointSize': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withPointSize(value): { fieldConfig+: { defaults+: { custom+: { pointSize: value } } } }, + '#withPointSymbol': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withPointSymbol(value): { fieldConfig+: { defaults+: { custom+: { pointSymbol: value } } } }, + '#withShowPoints': { 'function': { args: [{ default: null, enums: ['auto', 'never', 'always'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withShowPoints(value): { fieldConfig+: { defaults+: { custom+: { showPoints: value } } } }, + '#withAxisCenteredZero': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAxisCenteredZero(value=true): { fieldConfig+: { defaults+: { custom+: { axisCenteredZero: value } } } }, + '#withAxisColorMode': { 'function': { args: [{ default: null, enums: ['text', 'series'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withAxisColorMode(value): { fieldConfig+: { defaults+: { custom+: { axisColorMode: value } } } }, + '#withAxisGridShow': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAxisGridShow(value=true): { fieldConfig+: { defaults+: { custom+: { axisGridShow: value } } } }, + '#withAxisLabel': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withAxisLabel(value): { fieldConfig+: { defaults+: { custom+: { axisLabel: value } } } }, + '#withAxisPlacement': { 'function': { args: [{ default: null, enums: ['auto', 'top', 'right', 'bottom', 'left', 'hidden'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withAxisPlacement(value): { fieldConfig+: { defaults+: { custom+: { axisPlacement: value } } } }, + '#withAxisSoftMax': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisSoftMax(value): { fieldConfig+: { defaults+: { custom+: { axisSoftMax: value } } } }, + '#withAxisSoftMin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisSoftMin(value): { fieldConfig+: { defaults+: { custom+: { axisSoftMin: value } } } }, + '#withAxisWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisWidth(value): { fieldConfig+: { defaults+: { custom+: { axisWidth: value } } } }, + '#withScaleDistribution': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistribution(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution: value } } } }, + '#withScaleDistributionMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistributionMixin(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: value } } } }, + scaleDistribution+: + { + '#withLinearThreshold': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLinearThreshold(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: { linearThreshold: value } } } } }, + '#withLog': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLog(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: { log: value } } } } }, + '#withType': { 'function': { args: [{ default: null, enums: ['linear', 'log', 'ordinal', 'symlog'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withType(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: { type: value } } } } }, + }, + '#withBarAlignment': { 'function': { args: [{ default: null, enums: [-1, 0, 1], name: 'value', type: 'integer' }], help: 'TODO docs' } }, + withBarAlignment(value): { fieldConfig+: { defaults+: { custom+: { barAlignment: value } } } }, + '#withBarMaxWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withBarMaxWidth(value): { fieldConfig+: { defaults+: { custom+: { barMaxWidth: value } } } }, + '#withBarWidthFactor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withBarWidthFactor(value): { fieldConfig+: { defaults+: { custom+: { barWidthFactor: value } } } }, + '#withStacking': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withStacking(value): { fieldConfig+: { defaults+: { custom+: { stacking: value } } } }, + '#withStackingMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withStackingMixin(value): { fieldConfig+: { defaults+: { custom+: { stacking+: value } } } }, + stacking+: + { + '#withGroup': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withGroup(value): { fieldConfig+: { defaults+: { custom+: { stacking+: { group: value } } } } }, + '#withMode': { 'function': { args: [{ default: null, enums: ['none', 'normal', 'percent'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withMode(value): { fieldConfig+: { defaults+: { custom+: { stacking+: { mode: value } } } } }, + }, + '#withHideFrom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFrom(value): { fieldConfig+: { defaults+: { custom+: { hideFrom: value } } } }, + '#withHideFromMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFromMixin(value): { fieldConfig+: { defaults+: { custom+: { hideFrom+: value } } } }, + hideFrom+: + { + '#withLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withLegend(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { legend: value } } } } }, + '#withTooltip': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withTooltip(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { tooltip: value } } } } }, + '#withViz': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withViz(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { viz: value } } } } }, + }, + '#withDrawStyle': { 'function': { args: [{ default: null, enums: ['line', 'bars', 'points'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withDrawStyle(value): { fieldConfig+: { defaults+: { custom+: { drawStyle: value } } } }, + '#withGradientMode': { 'function': { args: [{ default: null, enums: ['none', 'opacity', 'hue', 'scheme'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withGradientMode(value): { fieldConfig+: { defaults+: { custom+: { gradientMode: value } } } }, + '#withThresholdsStyle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withThresholdsStyle(value): { fieldConfig+: { defaults+: { custom+: { thresholdsStyle: value } } } }, + '#withThresholdsStyleMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withThresholdsStyleMixin(value): { fieldConfig+: { defaults+: { custom+: { thresholdsStyle+: value } } } }, + thresholdsStyle+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['off', 'line', 'dashed', 'area', 'line+area', 'dashed+area', 'series'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withMode(value): { fieldConfig+: { defaults+: { custom+: { thresholdsStyle+: { mode: value } } } } }, + }, + '#withTransform': { 'function': { args: [{ default: null, enums: ['constant', 'negative-Y'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withTransform(value): { fieldConfig+: { defaults+: { custom+: { transform: value } } } }, + }, + }, + }, + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptions(value): { options: value }, + '#withOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptionsMixin(value): { options+: value }, + options+: + { + '#withTimezone': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTimezone(value): { options+: { timezone: (if std.isArray(value) + then value + else [value]) } }, + '#withTimezoneMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withTimezoneMixin(value): { options+: { timezone+: (if std.isArray(value) + then value + else [value]) } }, + '#withLegend': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLegend(value): { options+: { legend: value } }, + '#withLegendMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLegendMixin(value): { options+: { legend+: value } }, + legend+: + { + '#withAsTable': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAsTable(value=true): { options+: { legend+: { asTable: value } } }, + '#withCalcs': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withCalcs(value): { options+: { legend+: { calcs: (if std.isArray(value) + then value + else [value]) } } }, + '#withCalcsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withCalcsMixin(value): { options+: { legend+: { calcs+: (if std.isArray(value) + then value + else [value]) } } }, + '#withDisplayMode': { 'function': { args: [{ default: null, enums: ['list', 'table', 'hidden'], name: 'value', type: 'string' }], help: 'TODO docs\nNote: "hidden" needs to remain as an option for plugins compatibility' } }, + withDisplayMode(value): { options+: { legend+: { displayMode: value } } }, + '#withIsVisible': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withIsVisible(value=true): { options+: { legend+: { isVisible: value } } }, + '#withPlacement': { 'function': { args: [{ default: null, enums: ['bottom', 'right'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withPlacement(value): { options+: { legend+: { placement: value } } }, + '#withShowLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowLegend(value=true): { options+: { legend+: { showLegend: value } } }, + '#withSortBy': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withSortBy(value): { options+: { legend+: { sortBy: value } } }, + '#withSortDesc': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withSortDesc(value=true): { options+: { legend+: { sortDesc: value } } }, + '#withWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withWidth(value): { options+: { legend+: { width: value } } }, + }, + '#withTooltip': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTooltip(value): { options+: { tooltip: value } }, + '#withTooltipMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTooltipMixin(value): { options+: { tooltip+: value } }, + tooltip+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['single', 'multi', 'none'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withMode(value): { options+: { tooltip+: { mode: value } } }, + '#withSort': { 'function': { args: [{ default: null, enums: ['asc', 'desc', 'none'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withSort(value): { options+: { tooltip+: { sort: value } } }, + }, + }, + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'timeseries' }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/trend.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/trend.libsonnet new file mode 100644 index 0000000000..d9c32f55a3 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/trend.libsonnet @@ -0,0 +1,193 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.panel.trend', name: 'trend' }, + '#withFieldConfig': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withFieldConfig(value): { fieldConfig: value }, + '#withFieldConfigMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withFieldConfigMixin(value): { fieldConfig+: value }, + fieldConfig+: + { + '#withDefaults': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withDefaults(value): { fieldConfig+: { defaults: value } }, + '#withDefaultsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withDefaultsMixin(value): { fieldConfig+: { defaults+: value } }, + defaults+: + { + '#withCustom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withCustom(value): { fieldConfig+: { defaults+: { custom: value } } }, + '#withCustomMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withCustomMixin(value): { fieldConfig+: { defaults+: { custom+: value } } }, + custom+: + { + '#withLineColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withLineColor(value): { fieldConfig+: { defaults+: { custom+: { lineColor: value } } } }, + '#withLineInterpolation': { 'function': { args: [{ default: null, enums: ['linear', 'smooth', 'stepBefore', 'stepAfter'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withLineInterpolation(value): { fieldConfig+: { defaults+: { custom+: { lineInterpolation: value } } } }, + '#withLineStyle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLineStyle(value): { fieldConfig+: { defaults+: { custom+: { lineStyle: value } } } }, + '#withLineStyleMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLineStyleMixin(value): { fieldConfig+: { defaults+: { custom+: { lineStyle+: value } } } }, + lineStyle+: + { + '#withDash': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withDash(value): { fieldConfig+: { defaults+: { custom+: { lineStyle+: { dash: (if std.isArray(value) + then value + else [value]) } } } } }, + '#withDashMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withDashMixin(value): { fieldConfig+: { defaults+: { custom+: { lineStyle+: { dash+: (if std.isArray(value) + then value + else [value]) } } } } }, + '#withFill': { 'function': { args: [{ default: null, enums: ['solid', 'dash', 'dot', 'square'], name: 'value', type: 'string' }], help: '' } }, + withFill(value): { fieldConfig+: { defaults+: { custom+: { lineStyle+: { fill: value } } } } }, + }, + '#withLineWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLineWidth(value): { fieldConfig+: { defaults+: { custom+: { lineWidth: value } } } }, + '#withSpanNulls': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Indicate if null values should be treated as gaps or connected.\nWhen the value is a number, it represents the maximum delta in the\nX axis that should be considered connected. For timeseries, this is milliseconds' } }, + withSpanNulls(value): { fieldConfig+: { defaults+: { custom+: { spanNulls: value } } } }, + '#withSpanNullsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Indicate if null values should be treated as gaps or connected.\nWhen the value is a number, it represents the maximum delta in the\nX axis that should be considered connected. For timeseries, this is milliseconds' } }, + withSpanNullsMixin(value): { fieldConfig+: { defaults+: { custom+: { spanNulls+: value } } } }, + '#withFillBelowTo': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withFillBelowTo(value): { fieldConfig+: { defaults+: { custom+: { fillBelowTo: value } } } }, + '#withFillColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withFillColor(value): { fieldConfig+: { defaults+: { custom+: { fillColor: value } } } }, + '#withFillOpacity': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withFillOpacity(value): { fieldConfig+: { defaults+: { custom+: { fillOpacity: value } } } }, + '#withPointColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withPointColor(value): { fieldConfig+: { defaults+: { custom+: { pointColor: value } } } }, + '#withPointSize': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withPointSize(value): { fieldConfig+: { defaults+: { custom+: { pointSize: value } } } }, + '#withPointSymbol': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withPointSymbol(value): { fieldConfig+: { defaults+: { custom+: { pointSymbol: value } } } }, + '#withShowPoints': { 'function': { args: [{ default: null, enums: ['auto', 'never', 'always'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withShowPoints(value): { fieldConfig+: { defaults+: { custom+: { showPoints: value } } } }, + '#withAxisCenteredZero': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAxisCenteredZero(value=true): { fieldConfig+: { defaults+: { custom+: { axisCenteredZero: value } } } }, + '#withAxisColorMode': { 'function': { args: [{ default: null, enums: ['text', 'series'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withAxisColorMode(value): { fieldConfig+: { defaults+: { custom+: { axisColorMode: value } } } }, + '#withAxisGridShow': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAxisGridShow(value=true): { fieldConfig+: { defaults+: { custom+: { axisGridShow: value } } } }, + '#withAxisLabel': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withAxisLabel(value): { fieldConfig+: { defaults+: { custom+: { axisLabel: value } } } }, + '#withAxisPlacement': { 'function': { args: [{ default: null, enums: ['auto', 'top', 'right', 'bottom', 'left', 'hidden'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withAxisPlacement(value): { fieldConfig+: { defaults+: { custom+: { axisPlacement: value } } } }, + '#withAxisSoftMax': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisSoftMax(value): { fieldConfig+: { defaults+: { custom+: { axisSoftMax: value } } } }, + '#withAxisSoftMin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisSoftMin(value): { fieldConfig+: { defaults+: { custom+: { axisSoftMin: value } } } }, + '#withAxisWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisWidth(value): { fieldConfig+: { defaults+: { custom+: { axisWidth: value } } } }, + '#withScaleDistribution': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistribution(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution: value } } } }, + '#withScaleDistributionMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistributionMixin(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: value } } } }, + scaleDistribution+: + { + '#withLinearThreshold': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLinearThreshold(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: { linearThreshold: value } } } } }, + '#withLog': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLog(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: { log: value } } } } }, + '#withType': { 'function': { args: [{ default: null, enums: ['linear', 'log', 'ordinal', 'symlog'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withType(value): { fieldConfig+: { defaults+: { custom+: { scaleDistribution+: { type: value } } } } }, + }, + '#withBarAlignment': { 'function': { args: [{ default: null, enums: [-1, 0, 1], name: 'value', type: 'integer' }], help: 'TODO docs' } }, + withBarAlignment(value): { fieldConfig+: { defaults+: { custom+: { barAlignment: value } } } }, + '#withBarMaxWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withBarMaxWidth(value): { fieldConfig+: { defaults+: { custom+: { barMaxWidth: value } } } }, + '#withBarWidthFactor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withBarWidthFactor(value): { fieldConfig+: { defaults+: { custom+: { barWidthFactor: value } } } }, + '#withStacking': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withStacking(value): { fieldConfig+: { defaults+: { custom+: { stacking: value } } } }, + '#withStackingMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withStackingMixin(value): { fieldConfig+: { defaults+: { custom+: { stacking+: value } } } }, + stacking+: + { + '#withGroup': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withGroup(value): { fieldConfig+: { defaults+: { custom+: { stacking+: { group: value } } } } }, + '#withMode': { 'function': { args: [{ default: null, enums: ['none', 'normal', 'percent'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withMode(value): { fieldConfig+: { defaults+: { custom+: { stacking+: { mode: value } } } } }, + }, + '#withHideFrom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFrom(value): { fieldConfig+: { defaults+: { custom+: { hideFrom: value } } } }, + '#withHideFromMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFromMixin(value): { fieldConfig+: { defaults+: { custom+: { hideFrom+: value } } } }, + hideFrom+: + { + '#withLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withLegend(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { legend: value } } } } }, + '#withTooltip': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withTooltip(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { tooltip: value } } } } }, + '#withViz': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withViz(value=true): { fieldConfig+: { defaults+: { custom+: { hideFrom+: { viz: value } } } } }, + }, + '#withDrawStyle': { 'function': { args: [{ default: null, enums: ['line', 'bars', 'points'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withDrawStyle(value): { fieldConfig+: { defaults+: { custom+: { drawStyle: value } } } }, + '#withGradientMode': { 'function': { args: [{ default: null, enums: ['none', 'opacity', 'hue', 'scheme'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withGradientMode(value): { fieldConfig+: { defaults+: { custom+: { gradientMode: value } } } }, + '#withThresholdsStyle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withThresholdsStyle(value): { fieldConfig+: { defaults+: { custom+: { thresholdsStyle: value } } } }, + '#withThresholdsStyleMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withThresholdsStyleMixin(value): { fieldConfig+: { defaults+: { custom+: { thresholdsStyle+: value } } } }, + thresholdsStyle+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['off', 'line', 'dashed', 'area', 'line+area', 'dashed+area', 'series'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withMode(value): { fieldConfig+: { defaults+: { custom+: { thresholdsStyle+: { mode: value } } } } }, + }, + '#withTransform': { 'function': { args: [{ default: null, enums: ['constant', 'negative-Y'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withTransform(value): { fieldConfig+: { defaults+: { custom+: { transform: value } } } }, + }, + }, + }, + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Identical to timeseries... except it does not have timezone settings' } }, + withOptions(value): { options: value }, + '#withOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Identical to timeseries... except it does not have timezone settings' } }, + withOptionsMixin(value): { options+: value }, + options+: + { + '#withLegend': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLegend(value): { options+: { legend: value } }, + '#withLegendMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLegendMixin(value): { options+: { legend+: value } }, + legend+: + { + '#withAsTable': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAsTable(value=true): { options+: { legend+: { asTable: value } } }, + '#withCalcs': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withCalcs(value): { options+: { legend+: { calcs: (if std.isArray(value) + then value + else [value]) } } }, + '#withCalcsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withCalcsMixin(value): { options+: { legend+: { calcs+: (if std.isArray(value) + then value + else [value]) } } }, + '#withDisplayMode': { 'function': { args: [{ default: null, enums: ['list', 'table', 'hidden'], name: 'value', type: 'string' }], help: 'TODO docs\nNote: "hidden" needs to remain as an option for plugins compatibility' } }, + withDisplayMode(value): { options+: { legend+: { displayMode: value } } }, + '#withIsVisible': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withIsVisible(value=true): { options+: { legend+: { isVisible: value } } }, + '#withPlacement': { 'function': { args: [{ default: null, enums: ['bottom', 'right'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withPlacement(value): { options+: { legend+: { placement: value } } }, + '#withShowLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowLegend(value=true): { options+: { legend+: { showLegend: value } } }, + '#withSortBy': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withSortBy(value): { options+: { legend+: { sortBy: value } } }, + '#withSortDesc': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withSortDesc(value=true): { options+: { legend+: { sortDesc: value } } }, + '#withWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withWidth(value): { options+: { legend+: { width: value } } }, + }, + '#withTooltip': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTooltip(value): { options+: { tooltip: value } }, + '#withTooltipMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTooltipMixin(value): { options+: { tooltip+: value } }, + tooltip+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['single', 'multi', 'none'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withMode(value): { options+: { tooltip+: { mode: value } } }, + '#withSort': { 'function': { args: [{ default: null, enums: ['asc', 'desc', 'none'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withSort(value): { options+: { tooltip+: { sort: value } } }, + }, + '#withXField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Name of the x field to use (defaults to first number)' } }, + withXField(value): { options+: { xField: value } }, + }, + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'trend' }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/xyChart.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/xyChart.libsonnet new file mode 100644 index 0000000000..28a6ed9b08 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/panel/xyChart.libsonnet @@ -0,0 +1,488 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.panel.xyChart', name: 'xyChart' }, + '#withScatterFieldConfig': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withScatterFieldConfig(value): { ScatterFieldConfig: value }, + '#withScatterFieldConfigMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withScatterFieldConfigMixin(value): { ScatterFieldConfig+: value }, + ScatterFieldConfig+: + { + '#withHideFrom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFrom(value): { ScatterFieldConfig+: { hideFrom: value } }, + '#withHideFromMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFromMixin(value): { ScatterFieldConfig+: { hideFrom+: value } }, + hideFrom+: + { + '#withLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withLegend(value=true): { ScatterFieldConfig+: { hideFrom+: { legend: value } } }, + '#withTooltip': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withTooltip(value=true): { ScatterFieldConfig+: { hideFrom+: { tooltip: value } } }, + '#withViz': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withViz(value=true): { ScatterFieldConfig+: { hideFrom+: { viz: value } } }, + }, + '#withAxisCenteredZero': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAxisCenteredZero(value=true): { ScatterFieldConfig+: { axisCenteredZero: value } }, + '#withAxisColorMode': { 'function': { args: [{ default: null, enums: ['text', 'series'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withAxisColorMode(value): { ScatterFieldConfig+: { axisColorMode: value } }, + '#withAxisGridShow': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAxisGridShow(value=true): { ScatterFieldConfig+: { axisGridShow: value } }, + '#withAxisLabel': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withAxisLabel(value): { ScatterFieldConfig+: { axisLabel: value } }, + '#withAxisPlacement': { 'function': { args: [{ default: null, enums: ['auto', 'top', 'right', 'bottom', 'left', 'hidden'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withAxisPlacement(value): { ScatterFieldConfig+: { axisPlacement: value } }, + '#withAxisSoftMax': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisSoftMax(value): { ScatterFieldConfig+: { axisSoftMax: value } }, + '#withAxisSoftMin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisSoftMin(value): { ScatterFieldConfig+: { axisSoftMin: value } }, + '#withAxisWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisWidth(value): { ScatterFieldConfig+: { axisWidth: value } }, + '#withScaleDistribution': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistribution(value): { ScatterFieldConfig+: { scaleDistribution: value } }, + '#withScaleDistributionMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistributionMixin(value): { ScatterFieldConfig+: { scaleDistribution+: value } }, + scaleDistribution+: + { + '#withLinearThreshold': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLinearThreshold(value): { ScatterFieldConfig+: { scaleDistribution+: { linearThreshold: value } } }, + '#withLog': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLog(value): { ScatterFieldConfig+: { scaleDistribution+: { log: value } } }, + '#withType': { 'function': { args: [{ default: null, enums: ['linear', 'log', 'ordinal', 'symlog'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withType(value): { ScatterFieldConfig+: { scaleDistribution+: { type: value } } }, + }, + '#withLabel': { 'function': { args: [{ default: null, enums: ['auto', 'never', 'always'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withLabel(value): { ScatterFieldConfig+: { label: value } }, + '#withLabelValue': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withLabelValue(value): { ScatterFieldConfig+: { labelValue: value } }, + '#withLabelValueMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withLabelValueMixin(value): { ScatterFieldConfig+: { labelValue+: value } }, + labelValue+: + { + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'fixed: T -- will be added by each element' } }, + withField(value): { ScatterFieldConfig+: { labelValue+: { field: value } } }, + '#withFixed': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withFixed(value): { ScatterFieldConfig+: { labelValue+: { fixed: value } } }, + '#withMode': { 'function': { args: [{ default: null, enums: ['fixed', 'field', 'template'], name: 'value', type: 'string' }], help: '' } }, + withMode(value): { ScatterFieldConfig+: { labelValue+: { mode: value } } }, + }, + '#withLineColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withLineColor(value): { ScatterFieldConfig+: { lineColor: value } }, + '#withLineColorMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withLineColorMixin(value): { ScatterFieldConfig+: { lineColor+: value } }, + lineColor+: + { + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'fixed: T -- will be added by each element' } }, + withField(value): { ScatterFieldConfig+: { lineColor+: { field: value } } }, + '#withFixed': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withFixed(value): { ScatterFieldConfig+: { lineColor+: { fixed: value } } }, + }, + '#withLineStyle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLineStyle(value): { ScatterFieldConfig+: { lineStyle: value } }, + '#withLineStyleMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLineStyleMixin(value): { ScatterFieldConfig+: { lineStyle+: value } }, + lineStyle+: + { + '#withDash': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withDash(value): { ScatterFieldConfig+: { lineStyle+: { dash: (if std.isArray(value) + then value + else [value]) } } }, + '#withDashMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withDashMixin(value): { ScatterFieldConfig+: { lineStyle+: { dash+: (if std.isArray(value) + then value + else [value]) } } }, + '#withFill': { 'function': { args: [{ default: null, enums: ['solid', 'dash', 'dot', 'square'], name: 'value', type: 'string' }], help: '' } }, + withFill(value): { ScatterFieldConfig+: { lineStyle+: { fill: value } } }, + }, + '#withLineWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withLineWidth(value): { ScatterFieldConfig+: { lineWidth: value } }, + '#withPointColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withPointColor(value): { ScatterFieldConfig+: { pointColor: value } }, + '#withPointColorMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withPointColorMixin(value): { ScatterFieldConfig+: { pointColor+: value } }, + pointColor+: + { + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'fixed: T -- will be added by each element' } }, + withField(value): { ScatterFieldConfig+: { pointColor+: { field: value } } }, + '#withFixed': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withFixed(value): { ScatterFieldConfig+: { pointColor+: { fixed: value } } }, + }, + '#withPointSize': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withPointSize(value): { ScatterFieldConfig+: { pointSize: value } }, + '#withPointSizeMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withPointSizeMixin(value): { ScatterFieldConfig+: { pointSize+: value } }, + pointSize+: + { + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'fixed: T -- will be added by each element' } }, + withField(value): { ScatterFieldConfig+: { pointSize+: { field: value } } }, + '#withFixed': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withFixed(value): { ScatterFieldConfig+: { pointSize+: { fixed: value } } }, + '#withMax': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withMax(value): { ScatterFieldConfig+: { pointSize+: { max: value } } }, + '#withMin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withMin(value): { ScatterFieldConfig+: { pointSize+: { min: value } } }, + '#withMode': { 'function': { args: [{ default: null, enums: ['linear', 'quad'], name: 'value', type: 'string' }], help: '' } }, + withMode(value): { ScatterFieldConfig+: { pointSize+: { mode: value } } }, + }, + '#withShow': { 'function': { args: [{ default: null, enums: ['points', 'lines', 'points+lines'], name: 'value', type: 'string' }], help: '' } }, + withShow(value): { ScatterFieldConfig+: { show: value } }, + }, + '#withScatterSeriesConfig': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withScatterSeriesConfig(value): { ScatterSeriesConfig: value }, + '#withScatterSeriesConfigMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withScatterSeriesConfigMixin(value): { ScatterSeriesConfig+: value }, + ScatterSeriesConfig+: + { + '#withHideFrom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFrom(value): { ScatterSeriesConfig+: { hideFrom: value } }, + '#withHideFromMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFromMixin(value): { ScatterSeriesConfig+: { hideFrom+: value } }, + hideFrom+: + { + '#withLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withLegend(value=true): { ScatterSeriesConfig+: { hideFrom+: { legend: value } } }, + '#withTooltip': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withTooltip(value=true): { ScatterSeriesConfig+: { hideFrom+: { tooltip: value } } }, + '#withViz': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withViz(value=true): { ScatterSeriesConfig+: { hideFrom+: { viz: value } } }, + }, + '#withAxisCenteredZero': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAxisCenteredZero(value=true): { ScatterSeriesConfig+: { axisCenteredZero: value } }, + '#withAxisColorMode': { 'function': { args: [{ default: null, enums: ['text', 'series'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withAxisColorMode(value): { ScatterSeriesConfig+: { axisColorMode: value } }, + '#withAxisGridShow': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAxisGridShow(value=true): { ScatterSeriesConfig+: { axisGridShow: value } }, + '#withAxisLabel': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withAxisLabel(value): { ScatterSeriesConfig+: { axisLabel: value } }, + '#withAxisPlacement': { 'function': { args: [{ default: null, enums: ['auto', 'top', 'right', 'bottom', 'left', 'hidden'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withAxisPlacement(value): { ScatterSeriesConfig+: { axisPlacement: value } }, + '#withAxisSoftMax': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisSoftMax(value): { ScatterSeriesConfig+: { axisSoftMax: value } }, + '#withAxisSoftMin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisSoftMin(value): { ScatterSeriesConfig+: { axisSoftMin: value } }, + '#withAxisWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisWidth(value): { ScatterSeriesConfig+: { axisWidth: value } }, + '#withScaleDistribution': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistribution(value): { ScatterSeriesConfig+: { scaleDistribution: value } }, + '#withScaleDistributionMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistributionMixin(value): { ScatterSeriesConfig+: { scaleDistribution+: value } }, + scaleDistribution+: + { + '#withLinearThreshold': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLinearThreshold(value): { ScatterSeriesConfig+: { scaleDistribution+: { linearThreshold: value } } }, + '#withLog': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLog(value): { ScatterSeriesConfig+: { scaleDistribution+: { log: value } } }, + '#withType': { 'function': { args: [{ default: null, enums: ['linear', 'log', 'ordinal', 'symlog'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withType(value): { ScatterSeriesConfig+: { scaleDistribution+: { type: value } } }, + }, + '#withLabel': { 'function': { args: [{ default: null, enums: ['auto', 'never', 'always'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withLabel(value): { ScatterSeriesConfig+: { label: value } }, + '#withLabelValue': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withLabelValue(value): { ScatterSeriesConfig+: { labelValue: value } }, + '#withLabelValueMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withLabelValueMixin(value): { ScatterSeriesConfig+: { labelValue+: value } }, + labelValue+: + { + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'fixed: T -- will be added by each element' } }, + withField(value): { ScatterSeriesConfig+: { labelValue+: { field: value } } }, + '#withFixed': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withFixed(value): { ScatterSeriesConfig+: { labelValue+: { fixed: value } } }, + '#withMode': { 'function': { args: [{ default: null, enums: ['fixed', 'field', 'template'], name: 'value', type: 'string' }], help: '' } }, + withMode(value): { ScatterSeriesConfig+: { labelValue+: { mode: value } } }, + }, + '#withLineColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withLineColor(value): { ScatterSeriesConfig+: { lineColor: value } }, + '#withLineColorMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withLineColorMixin(value): { ScatterSeriesConfig+: { lineColor+: value } }, + lineColor+: + { + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'fixed: T -- will be added by each element' } }, + withField(value): { ScatterSeriesConfig+: { lineColor+: { field: value } } }, + '#withFixed': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withFixed(value): { ScatterSeriesConfig+: { lineColor+: { fixed: value } } }, + }, + '#withLineStyle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLineStyle(value): { ScatterSeriesConfig+: { lineStyle: value } }, + '#withLineStyleMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLineStyleMixin(value): { ScatterSeriesConfig+: { lineStyle+: value } }, + lineStyle+: + { + '#withDash': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withDash(value): { ScatterSeriesConfig+: { lineStyle+: { dash: (if std.isArray(value) + then value + else [value]) } } }, + '#withDashMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withDashMixin(value): { ScatterSeriesConfig+: { lineStyle+: { dash+: (if std.isArray(value) + then value + else [value]) } } }, + '#withFill': { 'function': { args: [{ default: null, enums: ['solid', 'dash', 'dot', 'square'], name: 'value', type: 'string' }], help: '' } }, + withFill(value): { ScatterSeriesConfig+: { lineStyle+: { fill: value } } }, + }, + '#withLineWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withLineWidth(value): { ScatterSeriesConfig+: { lineWidth: value } }, + '#withPointColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withPointColor(value): { ScatterSeriesConfig+: { pointColor: value } }, + '#withPointColorMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withPointColorMixin(value): { ScatterSeriesConfig+: { pointColor+: value } }, + pointColor+: + { + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'fixed: T -- will be added by each element' } }, + withField(value): { ScatterSeriesConfig+: { pointColor+: { field: value } } }, + '#withFixed': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withFixed(value): { ScatterSeriesConfig+: { pointColor+: { fixed: value } } }, + }, + '#withPointSize': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withPointSize(value): { ScatterSeriesConfig+: { pointSize: value } }, + '#withPointSizeMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withPointSizeMixin(value): { ScatterSeriesConfig+: { pointSize+: value } }, + pointSize+: + { + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'fixed: T -- will be added by each element' } }, + withField(value): { ScatterSeriesConfig+: { pointSize+: { field: value } } }, + '#withFixed': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withFixed(value): { ScatterSeriesConfig+: { pointSize+: { fixed: value } } }, + '#withMax': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withMax(value): { ScatterSeriesConfig+: { pointSize+: { max: value } } }, + '#withMin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withMin(value): { ScatterSeriesConfig+: { pointSize+: { min: value } } }, + '#withMode': { 'function': { args: [{ default: null, enums: ['linear', 'quad'], name: 'value', type: 'string' }], help: '' } }, + withMode(value): { ScatterSeriesConfig+: { pointSize+: { mode: value } } }, + }, + '#withShow': { 'function': { args: [{ default: null, enums: ['points', 'lines', 'points+lines'], name: 'value', type: 'string' }], help: '' } }, + withShow(value): { ScatterSeriesConfig+: { show: value } }, + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withName(value): { ScatterSeriesConfig+: { name: value } }, + '#withX': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withX(value): { ScatterSeriesConfig+: { x: value } }, + '#withY': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withY(value): { ScatterSeriesConfig+: { y: value } }, + }, + '#withScatterShow': { 'function': { args: [{ default: null, enums: ['points', 'lines', 'points+lines'], name: 'value', type: 'string' }], help: '' } }, + withScatterShow(value): { ScatterShow: value }, + '#withSeriesMapping': { 'function': { args: [{ default: null, enums: ['auto', 'manual'], name: 'value', type: 'string' }], help: '' } }, + withSeriesMapping(value): { SeriesMapping: value }, + '#withXYDimensionConfig': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withXYDimensionConfig(value): { XYDimensionConfig: value }, + '#withXYDimensionConfigMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withXYDimensionConfigMixin(value): { XYDimensionConfig+: value }, + XYDimensionConfig+: + { + '#withExclude': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withExclude(value): { XYDimensionConfig+: { exclude: (if std.isArray(value) + then value + else [value]) } }, + '#withExcludeMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withExcludeMixin(value): { XYDimensionConfig+: { exclude+: (if std.isArray(value) + then value + else [value]) } }, + '#withFrame': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withFrame(value): { XYDimensionConfig+: { frame: value } }, + '#withX': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withX(value): { XYDimensionConfig+: { x: value } }, + }, + '#withOptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptions(value): { options: value }, + '#withOptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOptionsMixin(value): { options+: value }, + options+: + { + '#withLegend': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLegend(value): { options+: { legend: value } }, + '#withLegendMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLegendMixin(value): { options+: { legend+: value } }, + legend+: + { + '#withAsTable': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAsTable(value=true): { options+: { legend+: { asTable: value } } }, + '#withCalcs': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withCalcs(value): { options+: { legend+: { calcs: (if std.isArray(value) + then value + else [value]) } } }, + '#withCalcsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withCalcsMixin(value): { options+: { legend+: { calcs+: (if std.isArray(value) + then value + else [value]) } } }, + '#withDisplayMode': { 'function': { args: [{ default: null, enums: ['list', 'table', 'hidden'], name: 'value', type: 'string' }], help: 'TODO docs\nNote: "hidden" needs to remain as an option for plugins compatibility' } }, + withDisplayMode(value): { options+: { legend+: { displayMode: value } } }, + '#withIsVisible': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withIsVisible(value=true): { options+: { legend+: { isVisible: value } } }, + '#withPlacement': { 'function': { args: [{ default: null, enums: ['bottom', 'right'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withPlacement(value): { options+: { legend+: { placement: value } } }, + '#withShowLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withShowLegend(value=true): { options+: { legend+: { showLegend: value } } }, + '#withSortBy': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withSortBy(value): { options+: { legend+: { sortBy: value } } }, + '#withSortDesc': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withSortDesc(value=true): { options+: { legend+: { sortDesc: value } } }, + '#withWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withWidth(value): { options+: { legend+: { width: value } } }, + }, + '#withTooltip': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTooltip(value): { options+: { tooltip: value } }, + '#withTooltipMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withTooltipMixin(value): { options+: { tooltip+: value } }, + tooltip+: + { + '#withMode': { 'function': { args: [{ default: null, enums: ['single', 'multi', 'none'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withMode(value): { options+: { tooltip+: { mode: value } } }, + '#withSort': { 'function': { args: [{ default: null, enums: ['asc', 'desc', 'none'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withSort(value): { options+: { tooltip+: { sort: value } } }, + }, + '#withDims': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withDims(value): { options+: { dims: value } }, + '#withDimsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withDimsMixin(value): { options+: { dims+: value } }, + dims+: + { + '#withExclude': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withExclude(value): { options+: { dims+: { exclude: (if std.isArray(value) + then value + else [value]) } } }, + '#withExcludeMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withExcludeMixin(value): { options+: { dims+: { exclude+: (if std.isArray(value) + then value + else [value]) } } }, + '#withFrame': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withFrame(value): { options+: { dims+: { frame: value } } }, + '#withX': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withX(value): { options+: { dims+: { x: value } } }, + }, + '#withSeries': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withSeries(value): { options+: { series: (if std.isArray(value) + then value + else [value]) } }, + '#withSeriesMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withSeriesMixin(value): { options+: { series+: (if std.isArray(value) + then value + else [value]) } }, + series+: + { + '#': { help: '', name: 'series' }, + '#withHideFrom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFrom(value): { hideFrom: value }, + '#withHideFromMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withHideFromMixin(value): { hideFrom+: value }, + hideFrom+: + { + '#withLegend': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withLegend(value=true): { hideFrom+: { legend: value } }, + '#withTooltip': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withTooltip(value=true): { hideFrom+: { tooltip: value } }, + '#withViz': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withViz(value=true): { hideFrom+: { viz: value } }, + }, + '#withAxisCenteredZero': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAxisCenteredZero(value=true): { axisCenteredZero: value }, + '#withAxisColorMode': { 'function': { args: [{ default: null, enums: ['text', 'series'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withAxisColorMode(value): { axisColorMode: value }, + '#withAxisGridShow': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withAxisGridShow(value=true): { axisGridShow: value }, + '#withAxisLabel': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withAxisLabel(value): { axisLabel: value }, + '#withAxisPlacement': { 'function': { args: [{ default: null, enums: ['auto', 'top', 'right', 'bottom', 'left', 'hidden'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withAxisPlacement(value): { axisPlacement: value }, + '#withAxisSoftMax': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisSoftMax(value): { axisSoftMax: value }, + '#withAxisSoftMin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisSoftMin(value): { axisSoftMin: value }, + '#withAxisWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withAxisWidth(value): { axisWidth: value }, + '#withScaleDistribution': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistribution(value): { scaleDistribution: value }, + '#withScaleDistributionMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withScaleDistributionMixin(value): { scaleDistribution+: value }, + scaleDistribution+: + { + '#withLinearThreshold': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLinearThreshold(value): { scaleDistribution+: { linearThreshold: value } }, + '#withLog': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withLog(value): { scaleDistribution+: { log: value } }, + '#withType': { 'function': { args: [{ default: null, enums: ['linear', 'log', 'ordinal', 'symlog'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withType(value): { scaleDistribution+: { type: value } }, + }, + '#withLabel': { 'function': { args: [{ default: null, enums: ['auto', 'never', 'always'], name: 'value', type: 'string' }], help: 'TODO docs' } }, + withLabel(value): { label: value }, + '#withLabelValue': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withLabelValue(value): { labelValue: value }, + '#withLabelValueMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withLabelValueMixin(value): { labelValue+: value }, + labelValue+: + { + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'fixed: T -- will be added by each element' } }, + withField(value): { labelValue+: { field: value } }, + '#withFixed': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withFixed(value): { labelValue+: { fixed: value } }, + '#withMode': { 'function': { args: [{ default: null, enums: ['fixed', 'field', 'template'], name: 'value', type: 'string' }], help: '' } }, + withMode(value): { labelValue+: { mode: value } }, + }, + '#withLineColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withLineColor(value): { lineColor: value }, + '#withLineColorMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withLineColorMixin(value): { lineColor+: value }, + lineColor+: + { + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'fixed: T -- will be added by each element' } }, + withField(value): { lineColor+: { field: value } }, + '#withFixed': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withFixed(value): { lineColor+: { fixed: value } }, + }, + '#withLineStyle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLineStyle(value): { lineStyle: value }, + '#withLineStyleMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'TODO docs' } }, + withLineStyleMixin(value): { lineStyle+: value }, + lineStyle+: + { + '#withDash': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withDash(value): { lineStyle+: { dash: (if std.isArray(value) + then value + else [value]) } }, + '#withDashMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withDashMixin(value): { lineStyle+: { dash+: (if std.isArray(value) + then value + else [value]) } }, + '#withFill': { 'function': { args: [{ default: null, enums: ['solid', 'dash', 'dot', 'square'], name: 'value', type: 'string' }], help: '' } }, + withFill(value): { lineStyle+: { fill: value } }, + }, + '#withLineWidth': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withLineWidth(value): { lineWidth: value }, + '#withPointColor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withPointColor(value): { pointColor: value }, + '#withPointColorMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withPointColorMixin(value): { pointColor+: value }, + pointColor+: + { + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'fixed: T -- will be added by each element' } }, + withField(value): { pointColor+: { field: value } }, + '#withFixed': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withFixed(value): { pointColor+: { fixed: value } }, + }, + '#withPointSize': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withPointSize(value): { pointSize: value }, + '#withPointSizeMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withPointSizeMixin(value): { pointSize+: value }, + pointSize+: + { + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'fixed: T -- will be added by each element' } }, + withField(value): { pointSize+: { field: value } }, + '#withFixed': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withFixed(value): { pointSize+: { fixed: value } }, + '#withMax': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withMax(value): { pointSize+: { max: value } }, + '#withMin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withMin(value): { pointSize+: { min: value } }, + '#withMode': { 'function': { args: [{ default: null, enums: ['linear', 'quad'], name: 'value', type: 'string' }], help: '' } }, + withMode(value): { pointSize+: { mode: value } }, + }, + '#withShow': { 'function': { args: [{ default: null, enums: ['points', 'lines', 'points+lines'], name: 'value', type: 'string' }], help: '' } }, + withShow(value): { show: value }, + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withName(value): { name: value }, + '#withX': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withX(value): { x: value }, + '#withY': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withY(value): { y: value }, + }, + '#withSeriesMapping': { 'function': { args: [{ default: null, enums: ['auto', 'manual'], name: 'value', type: 'string' }], help: '' } }, + withSeriesMapping(value): { options+: { seriesMapping: value } }, + }, + '#withType': { 'function': { args: [], help: '' } }, + withType(): { type: 'xychart' }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/playlist.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/playlist.libsonnet new file mode 100644 index 0000000000..b0a8ececaa --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/playlist.libsonnet @@ -0,0 +1,28 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.playlist', name: 'playlist' }, + '#withInterval': { 'function': { args: [{ default: '5m', enums: null, name: 'value', type: 'string' }], help: 'Interval sets the time between switching views in a playlist.\nFIXME: Is this based on a standardized format or what options are available? Can datemath be used?' } }, + withInterval(value='5m'): { interval: value }, + '#withItems': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'The ordered list of items that the playlist will iterate over.\nFIXME! This should not be optional, but changing it makes the godegen awkward' } }, + withItems(value): { items: (if std.isArray(value) + then value + else [value]) }, + '#withItemsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'The ordered list of items that the playlist will iterate over.\nFIXME! This should not be optional, but changing it makes the godegen awkward' } }, + withItemsMixin(value): { items+: (if std.isArray(value) + then value + else [value]) }, + items+: + { + '#': { help: '', name: 'items' }, + '#withTitle': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Title is an unused property -- it will be removed in the future' } }, + withTitle(value): { title: value }, + '#withType': { 'function': { args: [{ default: null, enums: ['dashboard_by_uid', 'dashboard_by_id', 'dashboard_by_tag'], name: 'value', type: 'string' }], help: 'Type of the item.' } }, + withType(value): { type: value }, + '#withValue': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Value depends on type and describes the playlist item.\n\n - dashboard_by_id: The value is an internal numerical identifier set by Grafana. This\n is not portable as the numerical identifier is non-deterministic between different instances.\n Will be replaced by dashboard_by_uid in the future. (deprecated)\n - dashboard_by_tag: The value is a tag which is set on any number of dashboards. All\n dashboards behind the tag will be added to the playlist.\n - dashboard_by_uid: The value is the dashboard UID' } }, + withValue(value): { value: value }, + }, + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Name of the playlist.' } }, + withName(value): { name: value }, + '#withUid': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Unique playlist identifier. Generated on creation, either by the\ncreator of the playlist of by the application.' } }, + withUid(value): { uid: value }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/preferences.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/preferences.libsonnet new file mode 100644 index 0000000000..5aeea39205 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/preferences.libsonnet @@ -0,0 +1,23 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.preferences', name: 'preferences' }, + '#withHomeDashboardUID': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'UID for the home dashboard' } }, + withHomeDashboardUID(value): { homeDashboardUID: value }, + '#withLanguage': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Selected language (beta)' } }, + withLanguage(value): { language: value }, + '#withQueryHistory': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withQueryHistory(value): { queryHistory: value }, + '#withQueryHistoryMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withQueryHistoryMixin(value): { queryHistory+: value }, + queryHistory+: + { + '#withHomeTab': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: "one of: '' | 'query' | 'starred';" } }, + withHomeTab(value): { queryHistory+: { homeTab: value } }, + }, + '#withTheme': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'light, dark, empty is default' } }, + withTheme(value): { theme: value }, + '#withTimezone': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The timezone selection\nTODO: this should use the timezone defined in common' } }, + withTimezone(value): { timezone: value }, + '#withWeekStart': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'day of the week (sunday, monday, etc)' } }, + withWeekStart(value): { weekStart: value }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/publicdashboard.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/publicdashboard.libsonnet new file mode 100644 index 0000000000..4e3e1b683b --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/publicdashboard.libsonnet @@ -0,0 +1,16 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.publicdashboard', name: 'publicdashboard' }, + '#withAccessToken': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Unique public access token' } }, + withAccessToken(value): { accessToken: value }, + '#withAnnotationsEnabled': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Flag that indicates if annotations are enabled' } }, + withAnnotationsEnabled(value=true): { annotationsEnabled: value }, + '#withDashboardUid': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Dashboard unique identifier referenced by this public dashboard' } }, + withDashboardUid(value): { dashboardUid: value }, + '#withIsEnabled': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Flag that indicates if the public dashboard is enabled' } }, + withIsEnabled(value=true): { isEnabled: value }, + '#withTimeSelectionEnabled': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Flag that indicates if the time range picker is enabled' } }, + withTimeSelectionEnabled(value=true): { timeSelectionEnabled: value }, + '#withUid': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Unique public dashboard identifier' } }, + withUid(value): { uid: value }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/query/azureMonitor.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/query/azureMonitor.libsonnet new file mode 100644 index 0000000000..e6c1982259 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/query/azureMonitor.libsonnet @@ -0,0 +1,363 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.query.azureMonitor', name: 'azureMonitor' }, + '#withDatasource': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: "For mixed data sources the selected datasource is on the query level.\nFor non mixed scenarios this is undefined.\nTODO find a better way to do this ^ that's friendly to schema\nTODO this shouldn't be unknown but DataSourceRef | null" } }, + withDatasource(value): { datasource: value }, + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'true if query is disabled (ie should not be returned to the dashboard)\nNote this does not always imply that the query should not be executed since\nthe results from a hidden query may be used as the input to other queries (SSE etc)' } }, + withHide(value=true): { hide: value }, + '#withQueryType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Specify the query flavor\nTODO make this required and give it a default' } }, + withQueryType(value): { queryType: value }, + '#withRefId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'A unique identifier for the query within the list of targets.\nIn server side expressions, the refId is used as a variable name to identify results.\nBy default, the UI will assign A->Z; however setting meaningful names may be useful.' } }, + withRefId(value): { refId: value }, + '#withAzureLogAnalytics': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Azure Monitor Logs sub-query properties' } }, + withAzureLogAnalytics(value): { azureLogAnalytics: value }, + '#withAzureLogAnalyticsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Azure Monitor Logs sub-query properties' } }, + withAzureLogAnalyticsMixin(value): { azureLogAnalytics+: value }, + azureLogAnalytics+: + { + '#withQuery': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'KQL query to be executed.' } }, + withQuery(value): { azureLogAnalytics+: { query: value } }, + '#withResource': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '@deprecated Use resources instead' } }, + withResource(value): { azureLogAnalytics+: { resource: value } }, + '#withResources': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Array of resource URIs to be queried.' } }, + withResources(value): { azureLogAnalytics+: { resources: (if std.isArray(value) + then value + else [value]) } }, + '#withResourcesMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Array of resource URIs to be queried.' } }, + withResourcesMixin(value): { azureLogAnalytics+: { resources+: (if std.isArray(value) + then value + else [value]) } }, + '#withResultFormat': { 'function': { args: [{ default: null, enums: ['table', 'time_series', 'trace'], name: 'value', type: 'string' }], help: '' } }, + withResultFormat(value): { azureLogAnalytics+: { resultFormat: value } }, + '#withWorkspace': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Workspace ID. This was removed in Grafana 8, but remains for backwards compat' } }, + withWorkspace(value): { azureLogAnalytics+: { workspace: value } }, + }, + '#withAzureMonitor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withAzureMonitor(value): { azureMonitor: value }, + '#withAzureMonitorMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withAzureMonitorMixin(value): { azureMonitor+: value }, + azureMonitor+: + { + '#withAggregation': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The aggregation to be used within the query. Defaults to the primaryAggregationType defined by the metric.' } }, + withAggregation(value): { azureMonitor+: { aggregation: value } }, + '#withAlias': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Aliases can be set to modify the legend labels. e.g. {{ resourceGroup }}. See docs for more detail.' } }, + withAlias(value): { azureMonitor+: { alias: value } }, + '#withAllowedTimeGrainsMs': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Time grains that are supported by the metric.' } }, + withAllowedTimeGrainsMs(value): { azureMonitor+: { allowedTimeGrainsMs: (if std.isArray(value) + then value + else [value]) } }, + '#withAllowedTimeGrainsMsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Time grains that are supported by the metric.' } }, + withAllowedTimeGrainsMsMixin(value): { azureMonitor+: { allowedTimeGrainsMs+: (if std.isArray(value) + then value + else [value]) } }, + '#withCustomNamespace': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: "Used as the value for the metricNamespace property when it's different from the resource namespace." } }, + withCustomNamespace(value): { azureMonitor+: { customNamespace: value } }, + '#withDimension': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '@deprecated This property was migrated to dimensionFilters and should only be accessed in the migration' } }, + withDimension(value): { azureMonitor+: { dimension: value } }, + '#withDimensionFilter': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '@deprecated This property was migrated to dimensionFilters and should only be accessed in the migration' } }, + withDimensionFilter(value): { azureMonitor+: { dimensionFilter: value } }, + '#withDimensionFilters': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Filters to reduce the set of data returned. Dimensions that can be filtered on are defined by the metric.' } }, + withDimensionFilters(value): { azureMonitor+: { dimensionFilters: (if std.isArray(value) + then value + else [value]) } }, + '#withDimensionFiltersMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Filters to reduce the set of data returned. Dimensions that can be filtered on are defined by the metric.' } }, + withDimensionFiltersMixin(value): { azureMonitor+: { dimensionFilters+: (if std.isArray(value) + then value + else [value]) } }, + dimensionFilters+: + { + '#': { help: '', name: 'dimensionFilters' }, + '#withDimension': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Name of Dimension to be filtered on.' } }, + withDimension(value): { dimension: value }, + '#withFilter': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '@deprecated filter is deprecated in favour of filters to support multiselect.' } }, + withFilter(value): { filter: value }, + '#withFilters': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Values to match with the filter.' } }, + withFilters(value): { filters: (if std.isArray(value) + then value + else [value]) }, + '#withFiltersMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Values to match with the filter.' } }, + withFiltersMixin(value): { filters+: (if std.isArray(value) + then value + else [value]) }, + '#withOperator': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: "String denoting the filter operation. Supports 'eq' - equals,'ne' - not equals, 'sw' - starts with. Note that some dimensions may not support all operators." } }, + withOperator(value): { operator: value }, + }, + '#withMetricDefinition': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '@deprecated Use metricNamespace instead' } }, + withMetricDefinition(value): { azureMonitor+: { metricDefinition: value } }, + '#withMetricName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The metric to query data for within the specified metricNamespace. e.g. UsedCapacity' } }, + withMetricName(value): { azureMonitor+: { metricName: value } }, + '#withMetricNamespace': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: "metricNamespace is used as the resource type (or resource namespace).\nIt's usually equal to the target metric namespace. e.g. microsoft.storage/storageaccounts\nKept the name of the variable as metricNamespace to avoid backward incompatibility issues." } }, + withMetricNamespace(value): { azureMonitor+: { metricNamespace: value } }, + '#withRegion': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The Azure region containing the resource(s).' } }, + withRegion(value): { azureMonitor+: { region: value } }, + '#withResourceGroup': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '@deprecated Use resources instead' } }, + withResourceGroup(value): { azureMonitor+: { resourceGroup: value } }, + '#withResourceName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '@deprecated Use resources instead' } }, + withResourceName(value): { azureMonitor+: { resourceName: value } }, + '#withResourceUri': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '@deprecated Use resourceGroup, resourceName and metricNamespace instead' } }, + withResourceUri(value): { azureMonitor+: { resourceUri: value } }, + '#withResources': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Array of resource URIs to be queried.' } }, + withResources(value): { azureMonitor+: { resources: (if std.isArray(value) + then value + else [value]) } }, + '#withResourcesMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Array of resource URIs to be queried.' } }, + withResourcesMixin(value): { azureMonitor+: { resources+: (if std.isArray(value) + then value + else [value]) } }, + resources+: + { + '#': { help: '', name: 'resources' }, + '#withMetricNamespace': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withMetricNamespace(value): { metricNamespace: value }, + '#withRegion': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withRegion(value): { region: value }, + '#withResourceGroup': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withResourceGroup(value): { resourceGroup: value }, + '#withResourceName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withResourceName(value): { resourceName: value }, + '#withSubscription': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withSubscription(value): { subscription: value }, + }, + '#withTimeGrain': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The granularity of data points to be queried. Defaults to auto.' } }, + withTimeGrain(value): { azureMonitor+: { timeGrain: value } }, + '#withTimeGrainUnit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '@deprecated' } }, + withTimeGrainUnit(value): { azureMonitor+: { timeGrainUnit: value } }, + '#withTop': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Maximum number of records to return. Defaults to 10.' } }, + withTop(value): { azureMonitor+: { top: value } }, + }, + '#withAzureResourceGraph': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withAzureResourceGraph(value): { azureResourceGraph: value }, + '#withAzureResourceGraphMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withAzureResourceGraphMixin(value): { azureResourceGraph+: value }, + azureResourceGraph+: + { + '#withQuery': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Azure Resource Graph KQL query to be executed.' } }, + withQuery(value): { azureResourceGraph+: { query: value } }, + '#withResultFormat': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Specifies the format results should be returned as. Defaults to table.' } }, + withResultFormat(value): { azureResourceGraph+: { resultFormat: value } }, + }, + '#withAzureTraces': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Application Insights Traces sub-query properties' } }, + withAzureTraces(value): { azureTraces: value }, + '#withAzureTracesMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'Application Insights Traces sub-query properties' } }, + withAzureTracesMixin(value): { azureTraces+: value }, + azureTraces+: + { + '#withFilters': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Filters for property values.' } }, + withFilters(value): { azureTraces+: { filters: (if std.isArray(value) + then value + else [value]) } }, + '#withFiltersMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Filters for property values.' } }, + withFiltersMixin(value): { azureTraces+: { filters+: (if std.isArray(value) + then value + else [value]) } }, + filters+: + { + '#': { help: '', name: 'filters' }, + '#withFilters': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Values to filter by.' } }, + withFilters(value): { filters: (if std.isArray(value) + then value + else [value]) }, + '#withFiltersMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Values to filter by.' } }, + withFiltersMixin(value): { filters+: (if std.isArray(value) + then value + else [value]) }, + '#withOperation': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Comparison operator to use. Either equals or not equals.' } }, + withOperation(value): { operation: value }, + '#withProperty': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Property name, auto-populated based on available traces.' } }, + withProperty(value): { property: value }, + }, + '#withOperationId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Operation ID. Used only for Traces queries.' } }, + withOperationId(value): { azureTraces+: { operationId: value } }, + '#withQuery': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'KQL query to be executed.' } }, + withQuery(value): { azureTraces+: { query: value } }, + '#withResources': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Array of resource URIs to be queried.' } }, + withResources(value): { azureTraces+: { resources: (if std.isArray(value) + then value + else [value]) } }, + '#withResourcesMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Array of resource URIs to be queried.' } }, + withResourcesMixin(value): { azureTraces+: { resources+: (if std.isArray(value) + then value + else [value]) } }, + '#withResultFormat': { 'function': { args: [{ default: null, enums: ['table', 'time_series', 'trace'], name: 'value', type: 'string' }], help: '' } }, + withResultFormat(value): { azureTraces+: { resultFormat: value } }, + '#withTraceTypes': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Types of events to filter by.' } }, + withTraceTypes(value): { azureTraces+: { traceTypes: (if std.isArray(value) + then value + else [value]) } }, + '#withTraceTypesMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Types of events to filter by.' } }, + withTraceTypesMixin(value): { azureTraces+: { traceTypes+: (if std.isArray(value) + then value + else [value]) } }, + }, + '#withGrafanaTemplateVariableFn': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withGrafanaTemplateVariableFn(value): { grafanaTemplateVariableFn: value }, + '#withGrafanaTemplateVariableFnMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withGrafanaTemplateVariableFnMixin(value): { grafanaTemplateVariableFn+: value }, + grafanaTemplateVariableFn+: + { + '#withAppInsightsMetricNameQuery': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withAppInsightsMetricNameQuery(value): { grafanaTemplateVariableFn+: { AppInsightsMetricNameQuery: value } }, + '#withAppInsightsMetricNameQueryMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withAppInsightsMetricNameQueryMixin(value): { grafanaTemplateVariableFn+: { AppInsightsMetricNameQuery+: value } }, + AppInsightsMetricNameQuery+: + { + '#withRawQuery': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withRawQuery(value): { grafanaTemplateVariableFn+: { rawQuery: value } }, + '#withKind': { 'function': { args: [{ default: null, enums: ['AppInsightsMetricNameQuery'], name: 'value', type: 'string' }], help: '' } }, + withKind(value): { grafanaTemplateVariableFn+: { kind: value } }, + }, + '#withAppInsightsGroupByQuery': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withAppInsightsGroupByQuery(value): { grafanaTemplateVariableFn+: { AppInsightsGroupByQuery: value } }, + '#withAppInsightsGroupByQueryMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withAppInsightsGroupByQueryMixin(value): { grafanaTemplateVariableFn+: { AppInsightsGroupByQuery+: value } }, + AppInsightsGroupByQuery+: + { + '#withRawQuery': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withRawQuery(value): { grafanaTemplateVariableFn+: { rawQuery: value } }, + '#withKind': { 'function': { args: [{ default: null, enums: ['AppInsightsGroupByQuery'], name: 'value', type: 'string' }], help: '' } }, + withKind(value): { grafanaTemplateVariableFn+: { kind: value } }, + '#withMetricName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withMetricName(value): { grafanaTemplateVariableFn+: { metricName: value } }, + }, + '#withSubscriptionsQuery': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSubscriptionsQuery(value): { grafanaTemplateVariableFn+: { SubscriptionsQuery: value } }, + '#withSubscriptionsQueryMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSubscriptionsQueryMixin(value): { grafanaTemplateVariableFn+: { SubscriptionsQuery+: value } }, + SubscriptionsQuery+: + { + '#withRawQuery': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withRawQuery(value): { grafanaTemplateVariableFn+: { rawQuery: value } }, + '#withKind': { 'function': { args: [{ default: null, enums: ['SubscriptionsQuery'], name: 'value', type: 'string' }], help: '' } }, + withKind(value): { grafanaTemplateVariableFn+: { kind: value } }, + }, + '#withResourceGroupsQuery': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withResourceGroupsQuery(value): { grafanaTemplateVariableFn+: { ResourceGroupsQuery: value } }, + '#withResourceGroupsQueryMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withResourceGroupsQueryMixin(value): { grafanaTemplateVariableFn+: { ResourceGroupsQuery+: value } }, + ResourceGroupsQuery+: + { + '#withRawQuery': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withRawQuery(value): { grafanaTemplateVariableFn+: { rawQuery: value } }, + '#withKind': { 'function': { args: [{ default: null, enums: ['ResourceGroupsQuery'], name: 'value', type: 'string' }], help: '' } }, + withKind(value): { grafanaTemplateVariableFn+: { kind: value } }, + '#withSubscription': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withSubscription(value): { grafanaTemplateVariableFn+: { subscription: value } }, + }, + '#withResourceNamesQuery': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withResourceNamesQuery(value): { grafanaTemplateVariableFn+: { ResourceNamesQuery: value } }, + '#withResourceNamesQueryMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withResourceNamesQueryMixin(value): { grafanaTemplateVariableFn+: { ResourceNamesQuery+: value } }, + ResourceNamesQuery+: + { + '#withRawQuery': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withRawQuery(value): { grafanaTemplateVariableFn+: { rawQuery: value } }, + '#withKind': { 'function': { args: [{ default: null, enums: ['ResourceNamesQuery'], name: 'value', type: 'string' }], help: '' } }, + withKind(value): { grafanaTemplateVariableFn+: { kind: value } }, + '#withMetricNamespace': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withMetricNamespace(value): { grafanaTemplateVariableFn+: { metricNamespace: value } }, + '#withResourceGroup': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withResourceGroup(value): { grafanaTemplateVariableFn+: { resourceGroup: value } }, + '#withSubscription': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withSubscription(value): { grafanaTemplateVariableFn+: { subscription: value } }, + }, + '#withMetricNamespaceQuery': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withMetricNamespaceQuery(value): { grafanaTemplateVariableFn+: { MetricNamespaceQuery: value } }, + '#withMetricNamespaceQueryMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withMetricNamespaceQueryMixin(value): { grafanaTemplateVariableFn+: { MetricNamespaceQuery+: value } }, + MetricNamespaceQuery+: + { + '#withRawQuery': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withRawQuery(value): { grafanaTemplateVariableFn+: { rawQuery: value } }, + '#withKind': { 'function': { args: [{ default: null, enums: ['MetricNamespaceQuery'], name: 'value', type: 'string' }], help: '' } }, + withKind(value): { grafanaTemplateVariableFn+: { kind: value } }, + '#withMetricNamespace': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withMetricNamespace(value): { grafanaTemplateVariableFn+: { metricNamespace: value } }, + '#withResourceGroup': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withResourceGroup(value): { grafanaTemplateVariableFn+: { resourceGroup: value } }, + '#withResourceName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withResourceName(value): { grafanaTemplateVariableFn+: { resourceName: value } }, + '#withSubscription': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withSubscription(value): { grafanaTemplateVariableFn+: { subscription: value } }, + }, + '#withMetricDefinitionsQuery': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '@deprecated Use MetricNamespaceQuery instead' } }, + withMetricDefinitionsQuery(value): { grafanaTemplateVariableFn+: { MetricDefinitionsQuery: value } }, + '#withMetricDefinitionsQueryMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '@deprecated Use MetricNamespaceQuery instead' } }, + withMetricDefinitionsQueryMixin(value): { grafanaTemplateVariableFn+: { MetricDefinitionsQuery+: value } }, + MetricDefinitionsQuery+: + { + '#withRawQuery': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withRawQuery(value): { grafanaTemplateVariableFn+: { rawQuery: value } }, + '#withKind': { 'function': { args: [{ default: null, enums: ['MetricDefinitionsQuery'], name: 'value', type: 'string' }], help: '' } }, + withKind(value): { grafanaTemplateVariableFn+: { kind: value } }, + '#withMetricNamespace': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withMetricNamespace(value): { grafanaTemplateVariableFn+: { metricNamespace: value } }, + '#withResourceGroup': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withResourceGroup(value): { grafanaTemplateVariableFn+: { resourceGroup: value } }, + '#withResourceName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withResourceName(value): { grafanaTemplateVariableFn+: { resourceName: value } }, + '#withSubscription': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withSubscription(value): { grafanaTemplateVariableFn+: { subscription: value } }, + }, + '#withMetricNamesQuery': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withMetricNamesQuery(value): { grafanaTemplateVariableFn+: { MetricNamesQuery: value } }, + '#withMetricNamesQueryMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withMetricNamesQueryMixin(value): { grafanaTemplateVariableFn+: { MetricNamesQuery+: value } }, + MetricNamesQuery+: + { + '#withRawQuery': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withRawQuery(value): { grafanaTemplateVariableFn+: { rawQuery: value } }, + '#withKind': { 'function': { args: [{ default: null, enums: ['MetricNamesQuery'], name: 'value', type: 'string' }], help: '' } }, + withKind(value): { grafanaTemplateVariableFn+: { kind: value } }, + '#withMetricNamespace': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withMetricNamespace(value): { grafanaTemplateVariableFn+: { metricNamespace: value } }, + '#withResourceGroup': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withResourceGroup(value): { grafanaTemplateVariableFn+: { resourceGroup: value } }, + '#withResourceName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withResourceName(value): { grafanaTemplateVariableFn+: { resourceName: value } }, + '#withSubscription': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withSubscription(value): { grafanaTemplateVariableFn+: { subscription: value } }, + }, + '#withWorkspacesQuery': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withWorkspacesQuery(value): { grafanaTemplateVariableFn+: { WorkspacesQuery: value } }, + '#withWorkspacesQueryMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withWorkspacesQueryMixin(value): { grafanaTemplateVariableFn+: { WorkspacesQuery+: value } }, + WorkspacesQuery+: + { + '#withRawQuery': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withRawQuery(value): { grafanaTemplateVariableFn+: { rawQuery: value } }, + '#withKind': { 'function': { args: [{ default: null, enums: ['WorkspacesQuery'], name: 'value', type: 'string' }], help: '' } }, + withKind(value): { grafanaTemplateVariableFn+: { kind: value } }, + '#withSubscription': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withSubscription(value): { grafanaTemplateVariableFn+: { subscription: value } }, + }, + '#withUnknownQuery': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withUnknownQuery(value): { grafanaTemplateVariableFn+: { UnknownQuery: value } }, + '#withUnknownQueryMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withUnknownQueryMixin(value): { grafanaTemplateVariableFn+: { UnknownQuery+: value } }, + UnknownQuery+: + { + '#withRawQuery': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withRawQuery(value): { grafanaTemplateVariableFn+: { rawQuery: value } }, + '#withKind': { 'function': { args: [{ default: null, enums: ['UnknownQuery'], name: 'value', type: 'string' }], help: '' } }, + withKind(value): { grafanaTemplateVariableFn+: { kind: value } }, + }, + }, + '#withNamespace': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withNamespace(value): { namespace: value }, + '#withRegion': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Azure Monitor query type.\nqueryType: #AzureQueryType' } }, + withRegion(value): { region: value }, + '#withResource': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withResource(value): { resource: value }, + '#withResourceGroup': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Template variables params. These exist for backwards compatiblity with legacy template variables.' } }, + withResourceGroup(value): { resourceGroup: value }, + '#withSubscription': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Azure subscription containing the resource(s) to be queried.' } }, + withSubscription(value): { subscription: value }, + '#withSubscriptions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Subscriptions to be queried via Azure Resource Graph.' } }, + withSubscriptions(value): { subscriptions: (if std.isArray(value) + then value + else [value]) }, + '#withSubscriptionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Subscriptions to be queried via Azure Resource Graph.' } }, + withSubscriptionsMixin(value): { subscriptions+: (if std.isArray(value) + then value + else [value]) }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/query/cloudWatch.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/query/cloudWatch.libsonnet new file mode 100644 index 0000000000..ad5e4b5781 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/query/cloudWatch.libsonnet @@ -0,0 +1,310 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.query.cloudWatch', name: 'cloudWatch' }, + CloudWatchAnnotationQuery+: + { + '#withDatasource': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: "For mixed data sources the selected datasource is on the query level.\nFor non mixed scenarios this is undefined.\nTODO find a better way to do this ^ that's friendly to schema\nTODO this shouldn't be unknown but DataSourceRef | null" } }, + withDatasource(value): { datasource: value }, + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'true if query is disabled (ie should not be returned to the dashboard)\nNote this does not always imply that the query should not be executed since\nthe results from a hidden query may be used as the input to other queries (SSE etc)' } }, + withHide(value=true): { hide: value }, + '#withQueryType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Specify the query flavor\nTODO make this required and give it a default' } }, + withQueryType(value): { queryType: value }, + '#withRefId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'A unique identifier for the query within the list of targets.\nIn server side expressions, the refId is used as a variable name to identify results.\nBy default, the UI will assign A->Z; however setting meaningful names may be useful.' } }, + withRefId(value): { refId: value }, + '#withAccountId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The ID of the AWS account to query for the metric, specifying `all` will query all accounts that the monitoring account is permitted to query.' } }, + withAccountId(value): { accountId: value }, + '#withDimensions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'A name/value pair that is part of the identity of a metric. For example, you can get statistics for a specific EC2 instance by specifying the InstanceId dimension when you search for metrics.' } }, + withDimensions(value): { dimensions: value }, + '#withDimensionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'A name/value pair that is part of the identity of a metric. For example, you can get statistics for a specific EC2 instance by specifying the InstanceId dimension when you search for metrics.' } }, + withDimensionsMixin(value): { dimensions+: value }, + '#withMatchExact': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Only show metrics that exactly match all defined dimension names.' } }, + withMatchExact(value=true): { matchExact: value }, + '#withMetricName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Name of the metric' } }, + withMetricName(value): { metricName: value }, + '#withNamespace': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'A namespace is a container for CloudWatch metrics. Metrics in different namespaces are isolated from each other, so that metrics from different applications are not mistakenly aggregated into the same statistics. For example, Amazon EC2 uses the AWS/EC2 namespace.' } }, + withNamespace(value): { namespace: value }, + '#withPeriod': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: "The length of time associated with a specific Amazon CloudWatch statistic. Can be specified by a number of seconds, 'auto', or as a duration string e.g. '15m' being 15 minutes" } }, + withPeriod(value): { period: value }, + '#withRegion': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'AWS region to query for the metric' } }, + withRegion(value): { region: value }, + '#withStatistic': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Metric data aggregations over specified periods of time. For detailed definitions of the statistics supported by CloudWatch, see https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Statistics-definitions.html.' } }, + withStatistic(value): { statistic: value }, + '#withStatistics': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '@deprecated use statistic' } }, + withStatistics(value): { statistics: (if std.isArray(value) + then value + else [value]) }, + '#withStatisticsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '@deprecated use statistic' } }, + withStatisticsMixin(value): { statistics+: (if std.isArray(value) + then value + else [value]) }, + '#withActionPrefix': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Use this parameter to filter the results of the operation to only those alarms\nthat use a certain alarm action. For example, you could specify the ARN of\nan SNS topic to find all alarms that send notifications to that topic.\ne.g. `arn:aws:sns:us-east-1:123456789012:my-app-` would match `arn:aws:sns:us-east-1:123456789012:my-app-action`\nbut not match `arn:aws:sns:us-east-1:123456789012:your-app-action`' } }, + withActionPrefix(value): { actionPrefix: value }, + '#withAlarmNamePrefix': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'An alarm name prefix. If you specify this parameter, you receive information\nabout all alarms that have names that start with this prefix.\ne.g. `my-team-service-` would match `my-team-service-high-cpu` but not match `your-team-service-high-cpu`' } }, + withAlarmNamePrefix(value): { alarmNamePrefix: value }, + '#withPrefixMatching': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Enable matching on the prefix of the action name or alarm name, specify the prefixes with actionPrefix and/or alarmNamePrefix' } }, + withPrefixMatching(value=true): { prefixMatching: value }, + '#withQueryMode': { 'function': { args: [{ default: null, enums: ['Metrics', 'Logs', 'Annotations'], name: 'value', type: 'string' }], help: '' } }, + withQueryMode(value): { queryMode: value }, + }, + CloudWatchLogsQuery+: + { + '#withDatasource': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: "For mixed data sources the selected datasource is on the query level.\nFor non mixed scenarios this is undefined.\nTODO find a better way to do this ^ that's friendly to schema\nTODO this shouldn't be unknown but DataSourceRef | null" } }, + withDatasource(value): { datasource: value }, + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'true if query is disabled (ie should not be returned to the dashboard)\nNote this does not always imply that the query should not be executed since\nthe results from a hidden query may be used as the input to other queries (SSE etc)' } }, + withHide(value=true): { hide: value }, + '#withQueryType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Specify the query flavor\nTODO make this required and give it a default' } }, + withQueryType(value): { queryType: value }, + '#withRefId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'A unique identifier for the query within the list of targets.\nIn server side expressions, the refId is used as a variable name to identify results.\nBy default, the UI will assign A->Z; however setting meaningful names may be useful.' } }, + withRefId(value): { refId: value }, + '#withExpression': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The CloudWatch Logs Insights query to execute' } }, + withExpression(value): { expression: value }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value): { id: value }, + '#withLogGroupNames': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '@deprecated use logGroups' } }, + withLogGroupNames(value): { logGroupNames: (if std.isArray(value) + then value + else [value]) }, + '#withLogGroupNamesMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '@deprecated use logGroups' } }, + withLogGroupNamesMixin(value): { logGroupNames+: (if std.isArray(value) + then value + else [value]) }, + '#withLogGroups': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Log groups to query' } }, + withLogGroups(value): { logGroups: (if std.isArray(value) + then value + else [value]) }, + '#withLogGroupsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Log groups to query' } }, + withLogGroupsMixin(value): { logGroups+: (if std.isArray(value) + then value + else [value]) }, + logGroups+: + { + '#': { help: '', name: 'logGroups' }, + '#withAccountId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'AccountId of the log group' } }, + withAccountId(value): { accountId: value }, + '#withAccountLabel': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Label of the log group' } }, + withAccountLabel(value): { accountLabel: value }, + '#withArn': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'ARN of the log group' } }, + withArn(value): { arn: value }, + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Name of the log group' } }, + withName(value): { name: value }, + }, + '#withQueryMode': { 'function': { args: [{ default: null, enums: ['Metrics', 'Logs', 'Annotations'], name: 'value', type: 'string' }], help: '' } }, + withQueryMode(value): { queryMode: value }, + '#withRegion': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'AWS region to query for the logs' } }, + withRegion(value): { region: value }, + '#withStatsGroups': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Fields to group the results by, this field is automatically populated whenever the query is updated' } }, + withStatsGroups(value): { statsGroups: (if std.isArray(value) + then value + else [value]) }, + '#withStatsGroupsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Fields to group the results by, this field is automatically populated whenever the query is updated' } }, + withStatsGroupsMixin(value): { statsGroups+: (if std.isArray(value) + then value + else [value]) }, + }, + CloudWatchMetricsQuery+: + { + '#withDatasource': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: "For mixed data sources the selected datasource is on the query level.\nFor non mixed scenarios this is undefined.\nTODO find a better way to do this ^ that's friendly to schema\nTODO this shouldn't be unknown but DataSourceRef | null" } }, + withDatasource(value): { datasource: value }, + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'true if query is disabled (ie should not be returned to the dashboard)\nNote this does not always imply that the query should not be executed since\nthe results from a hidden query may be used as the input to other queries (SSE etc)' } }, + withHide(value=true): { hide: value }, + '#withQueryType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Specify the query flavor\nTODO make this required and give it a default' } }, + withQueryType(value): { queryType: value }, + '#withRefId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'A unique identifier for the query within the list of targets.\nIn server side expressions, the refId is used as a variable name to identify results.\nBy default, the UI will assign A->Z; however setting meaningful names may be useful.' } }, + withRefId(value): { refId: value }, + '#withAccountId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The ID of the AWS account to query for the metric, specifying `all` will query all accounts that the monitoring account is permitted to query.' } }, + withAccountId(value): { accountId: value }, + '#withDimensions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'A name/value pair that is part of the identity of a metric. For example, you can get statistics for a specific EC2 instance by specifying the InstanceId dimension when you search for metrics.' } }, + withDimensions(value): { dimensions: value }, + '#withDimensionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'A name/value pair that is part of the identity of a metric. For example, you can get statistics for a specific EC2 instance by specifying the InstanceId dimension when you search for metrics.' } }, + withDimensionsMixin(value): { dimensions+: value }, + '#withMatchExact': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Only show metrics that exactly match all defined dimension names.' } }, + withMatchExact(value=true): { matchExact: value }, + '#withMetricName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Name of the metric' } }, + withMetricName(value): { metricName: value }, + '#withNamespace': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'A namespace is a container for CloudWatch metrics. Metrics in different namespaces are isolated from each other, so that metrics from different applications are not mistakenly aggregated into the same statistics. For example, Amazon EC2 uses the AWS/EC2 namespace.' } }, + withNamespace(value): { namespace: value }, + '#withPeriod': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: "The length of time associated with a specific Amazon CloudWatch statistic. Can be specified by a number of seconds, 'auto', or as a duration string e.g. '15m' being 15 minutes" } }, + withPeriod(value): { period: value }, + '#withRegion': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'AWS region to query for the metric' } }, + withRegion(value): { region: value }, + '#withStatistic': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Metric data aggregations over specified periods of time. For detailed definitions of the statistics supported by CloudWatch, see https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Statistics-definitions.html.' } }, + withStatistic(value): { statistic: value }, + '#withStatistics': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '@deprecated use statistic' } }, + withStatistics(value): { statistics: (if std.isArray(value) + then value + else [value]) }, + '#withStatisticsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '@deprecated use statistic' } }, + withStatisticsMixin(value): { statistics+: (if std.isArray(value) + then value + else [value]) }, + '#withAlias': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Deprecated: use label\n@deprecated use label' } }, + withAlias(value): { alias: value }, + '#withExpression': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Math expression query' } }, + withExpression(value): { expression: value }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'ID can be used to reference other queries in math expressions. The ID can include numbers, letters, and underscore, and must start with a lowercase letter.' } }, + withId(value): { id: value }, + '#withLabel': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Change the time series legend names using dynamic labels. See https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/graph-dynamic-labels.html for more details.' } }, + withLabel(value): { label: value }, + '#withMetricEditorMode': { 'function': { args: [{ default: null, enums: [0, 1], name: 'value', type: 'integer' }], help: '' } }, + withMetricEditorMode(value): { metricEditorMode: value }, + '#withMetricQueryType': { 'function': { args: [{ default: null, enums: [0, 1], name: 'value', type: 'integer' }], help: '' } }, + withMetricQueryType(value): { metricQueryType: value }, + '#withQueryMode': { 'function': { args: [{ default: null, enums: ['Metrics', 'Logs', 'Annotations'], name: 'value', type: 'string' }], help: '' } }, + withQueryMode(value): { queryMode: value }, + '#withSql': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSql(value): { sql: value }, + '#withSqlMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSqlMixin(value): { sql+: value }, + sql+: + { + '#withFrom': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'FROM part of the SQL expression' } }, + withFrom(value): { sql+: { from: value } }, + '#withFromMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'FROM part of the SQL expression' } }, + withFromMixin(value): { sql+: { from+: value } }, + from+: + { + '#withQueryEditorPropertyExpression': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withQueryEditorPropertyExpression(value): { sql+: { from+: { QueryEditorPropertyExpression: value } } }, + '#withQueryEditorPropertyExpressionMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withQueryEditorPropertyExpressionMixin(value): { sql+: { from+: { QueryEditorPropertyExpression+: value } } }, + QueryEditorPropertyExpression+: + { + '#withProperty': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withProperty(value): { sql+: { from+: { property: value } } }, + '#withPropertyMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withPropertyMixin(value): { sql+: { from+: { property+: value } } }, + property+: + { + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withName(value): { sql+: { from+: { property+: { name: value } } } }, + '#withType': { 'function': { args: [{ default: null, enums: ['string'], name: 'value', type: 'string' }], help: '' } }, + withType(value): { sql+: { from+: { property+: { type: value } } } }, + }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { sql+: { from+: { type: value } } }, + }, + '#withQueryEditorFunctionExpression': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withQueryEditorFunctionExpression(value): { sql+: { from+: { QueryEditorFunctionExpression: value } } }, + '#withQueryEditorFunctionExpressionMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withQueryEditorFunctionExpressionMixin(value): { sql+: { from+: { QueryEditorFunctionExpression+: value } } }, + QueryEditorFunctionExpression+: + { + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withName(value): { sql+: { from+: { name: value } } }, + '#withParameters': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withParameters(value): { sql+: { from+: { parameters: (if std.isArray(value) + then value + else [value]) } } }, + '#withParametersMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withParametersMixin(value): { sql+: { from+: { parameters+: (if std.isArray(value) + then value + else [value]) } } }, + parameters+: + { + '#': { help: '', name: 'parameters' }, + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withName(value): { name: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { sql+: { from+: { type: value } } }, + }, + }, + '#withGroupBy': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withGroupBy(value): { sql+: { groupBy: value } }, + '#withGroupByMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withGroupByMixin(value): { sql+: { groupBy+: value } }, + groupBy+: + { + '#withExpressions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withExpressions(value): { sql+: { groupBy+: { expressions: (if std.isArray(value) + then value + else [value]) } } }, + '#withExpressionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withExpressionsMixin(value): { sql+: { groupBy+: { expressions+: (if std.isArray(value) + then value + else [value]) } } }, + '#withType': { 'function': { args: [{ default: null, enums: ['and', 'or'], name: 'value', type: 'string' }], help: '' } }, + withType(value): { sql+: { groupBy+: { type: value } } }, + }, + '#withLimit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'LIMIT part of the SQL expression' } }, + withLimit(value): { sql+: { limit: value } }, + '#withOrderBy': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOrderBy(value): { sql+: { orderBy: value } }, + '#withOrderByMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withOrderByMixin(value): { sql+: { orderBy+: value } }, + orderBy+: + { + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withName(value): { sql+: { orderBy+: { name: value } } }, + '#withParameters': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withParameters(value): { sql+: { orderBy+: { parameters: (if std.isArray(value) + then value + else [value]) } } }, + '#withParametersMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withParametersMixin(value): { sql+: { orderBy+: { parameters+: (if std.isArray(value) + then value + else [value]) } } }, + parameters+: + { + '#': { help: '', name: 'parameters' }, + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withName(value): { name: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { sql+: { orderBy+: { type: value } } }, + }, + '#withOrderByDirection': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The sort order of the SQL expression, `ASC` or `DESC`' } }, + withOrderByDirection(value): { sql+: { orderByDirection: value } }, + '#withSelect': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSelect(value): { sql+: { select: value } }, + '#withSelectMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSelectMixin(value): { sql+: { select+: value } }, + select+: + { + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withName(value): { sql+: { select+: { name: value } } }, + '#withParameters': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withParameters(value): { sql+: { select+: { parameters: (if std.isArray(value) + then value + else [value]) } } }, + '#withParametersMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withParametersMixin(value): { sql+: { select+: { parameters+: (if std.isArray(value) + then value + else [value]) } } }, + parameters+: + { + '#': { help: '', name: 'parameters' }, + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withName(value): { name: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { sql+: { select+: { type: value } } }, + }, + '#withWhere': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withWhere(value): { sql+: { where: value } }, + '#withWhereMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withWhereMixin(value): { sql+: { where+: value } }, + where+: + { + '#withExpressions': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withExpressions(value): { sql+: { where+: { expressions: (if std.isArray(value) + then value + else [value]) } } }, + '#withExpressionsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withExpressionsMixin(value): { sql+: { where+: { expressions+: (if std.isArray(value) + then value + else [value]) } } }, + '#withType': { 'function': { args: [{ default: null, enums: ['and', 'or'], name: 'value', type: 'string' }], help: '' } }, + withType(value): { sql+: { where+: { type: value } } }, + }, + }, + '#withSqlExpression': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'When the metric query type is `metricQueryType` is set to `Query`, this field is used to specify the query string.' } }, + withSqlExpression(value): { sqlExpression: value }, + }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/query/elasticsearch.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/query/elasticsearch.libsonnet new file mode 100644 index 0000000000..b94b2a3178 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/query/elasticsearch.libsonnet @@ -0,0 +1,763 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.query.elasticsearch', name: 'elasticsearch' }, + '#withDatasource': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: "For mixed data sources the selected datasource is on the query level.\nFor non mixed scenarios this is undefined.\nTODO find a better way to do this ^ that's friendly to schema\nTODO this shouldn't be unknown but DataSourceRef | null" } }, + withDatasource(value): { datasource: value }, + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'true if query is disabled (ie should not be returned to the dashboard)\nNote this does not always imply that the query should not be executed since\nthe results from a hidden query may be used as the input to other queries (SSE etc)' } }, + withHide(value=true): { hide: value }, + '#withQueryType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Specify the query flavor\nTODO make this required and give it a default' } }, + withQueryType(value): { queryType: value }, + '#withRefId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'A unique identifier for the query within the list of targets.\nIn server side expressions, the refId is used as a variable name to identify results.\nBy default, the UI will assign A->Z; however setting meaningful names may be useful.' } }, + withRefId(value): { refId: value }, + '#withAlias': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Alias pattern' } }, + withAlias(value): { alias: value }, + '#withBucketAggs': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'List of bucket aggregations' } }, + withBucketAggs(value): { bucketAggs: (if std.isArray(value) + then value + else [value]) }, + '#withBucketAggsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'List of bucket aggregations' } }, + withBucketAggsMixin(value): { bucketAggs+: (if std.isArray(value) + then value + else [value]) }, + bucketAggs+: + { + '#': { help: '', name: 'bucketAggs' }, + DateHistogram+: + { + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value): { id: value }, + '#withSettings': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettings(value): { settings: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withField(value): { field: value }, + '#withSettingsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettingsMixin(value): { settings+: value }, + settings+: + { + '#withInterval': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withInterval(value): { settings+: { interval: value } }, + '#withMinDocCount': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withMinDocCount(value): { settings+: { min_doc_count: value } }, + '#withOffset': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withOffset(value): { settings+: { offset: value } }, + '#withTimeZone': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withTimeZone(value): { settings+: { timeZone: value } }, + '#withTrimEdges': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withTrimEdges(value): { settings+: { trimEdges: value } }, + }, + }, + Histogram+: + { + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value): { id: value }, + '#withSettings': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettings(value): { settings: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withField(value): { field: value }, + '#withSettingsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettingsMixin(value): { settings+: value }, + settings+: + { + '#withInterval': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withInterval(value): { settings+: { interval: value } }, + '#withMinDocCount': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withMinDocCount(value): { settings+: { min_doc_count: value } }, + }, + }, + Terms+: + { + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value): { id: value }, + '#withSettings': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettings(value): { settings: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withField(value): { field: value }, + '#withSettingsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettingsMixin(value): { settings+: value }, + settings+: + { + '#withMinDocCount': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withMinDocCount(value): { settings+: { min_doc_count: value } }, + '#withMissing': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withMissing(value): { settings+: { missing: value } }, + '#withOrder': { 'function': { args: [{ default: null, enums: ['desc', 'asc'], name: 'value', type: 'string' }], help: '' } }, + withOrder(value): { settings+: { order: value } }, + '#withOrderBy': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withOrderBy(value): { settings+: { orderBy: value } }, + '#withSize': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withSize(value): { settings+: { size: value } }, + }, + }, + Filters+: + { + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value): { id: value }, + '#withSettings': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettings(value): { settings: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + '#withSettingsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettingsMixin(value): { settings+: value }, + settings+: + { + '#withFilters': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withFilters(value): { settings+: { filters: (if std.isArray(value) + then value + else [value]) } }, + '#withFiltersMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withFiltersMixin(value): { settings+: { filters+: (if std.isArray(value) + then value + else [value]) } }, + filters+: + { + '#': { help: '', name: 'filters' }, + '#withLabel': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withLabel(value): { label: value }, + '#withQuery': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withQuery(value): { query: value }, + }, + }, + }, + GeoHashGrid+: + { + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value): { id: value }, + '#withSettings': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettings(value): { settings: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withField(value): { field: value }, + '#withSettingsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettingsMixin(value): { settings+: value }, + settings+: + { + '#withPrecision': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withPrecision(value): { settings+: { precision: value } }, + }, + }, + Nested+: + { + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value): { id: value }, + '#withSettings': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettings(value): { settings: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withField(value): { field: value }, + '#withSettingsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettingsMixin(value): { settings+: value }, + }, + }, + '#withMetrics': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'List of metric aggregations' } }, + withMetrics(value): { metrics: (if std.isArray(value) + then value + else [value]) }, + '#withMetricsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'List of metric aggregations' } }, + withMetricsMixin(value): { metrics+: (if std.isArray(value) + then value + else [value]) }, + metrics+: + { + '#': { help: '', name: 'metrics' }, + Count+: + { + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withHide(value=true): { hide: value }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value): { id: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + }, + PipelineMetricAggregation+: + { + MovingAverage+: + { + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withHide(value=true): { hide: value }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value): { id: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withField(value): { field: value }, + '#withPipelineAgg': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withPipelineAgg(value): { pipelineAgg: value }, + '#withSettings': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettings(value): { settings: value }, + '#withSettingsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettingsMixin(value): { settings+: value }, + }, + Derivative+: + { + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withHide(value=true): { hide: value }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value): { id: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withField(value): { field: value }, + '#withPipelineAgg': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withPipelineAgg(value): { pipelineAgg: value }, + '#withSettings': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettings(value): { settings: value }, + '#withSettingsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettingsMixin(value): { settings+: value }, + settings+: + { + '#withUnit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withUnit(value): { settings+: { unit: value } }, + }, + }, + CumulativeSum+: + { + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withHide(value=true): { hide: value }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value): { id: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withField(value): { field: value }, + '#withPipelineAgg': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withPipelineAgg(value): { pipelineAgg: value }, + '#withSettings': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettings(value): { settings: value }, + '#withSettingsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettingsMixin(value): { settings+: value }, + settings+: + { + '#withFormat': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withFormat(value): { settings+: { format: value } }, + }, + }, + BucketScript+: + { + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withHide(value=true): { hide: value }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value): { id: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + '#withPipelineVariables': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withPipelineVariables(value): { pipelineVariables: (if std.isArray(value) + then value + else [value]) }, + '#withPipelineVariablesMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withPipelineVariablesMixin(value): { pipelineVariables+: (if std.isArray(value) + then value + else [value]) }, + pipelineVariables+: + { + '#': { help: '', name: 'pipelineVariables' }, + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withName(value): { name: value }, + '#withPipelineAgg': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withPipelineAgg(value): { pipelineAgg: value }, + }, + '#withSettings': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettings(value): { settings: value }, + '#withSettingsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettingsMixin(value): { settings+: value }, + settings+: + { + '#withScript': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withScript(value): { settings+: { script: value } }, + '#withScriptMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withScriptMixin(value): { settings+: { script+: value } }, + script+: + { + '#withInline': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withInline(value): { settings+: { script+: { inline: value } } }, + }, + }, + }, + }, + MetricAggregationWithSettings+: + { + BucketScript+: + { + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withHide(value=true): { hide: value }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value): { id: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + '#withPipelineVariables': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withPipelineVariables(value): { pipelineVariables: (if std.isArray(value) + then value + else [value]) }, + '#withPipelineVariablesMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withPipelineVariablesMixin(value): { pipelineVariables+: (if std.isArray(value) + then value + else [value]) }, + pipelineVariables+: + { + '#': { help: '', name: 'pipelineVariables' }, + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withName(value): { name: value }, + '#withPipelineAgg': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withPipelineAgg(value): { pipelineAgg: value }, + }, + '#withSettings': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettings(value): { settings: value }, + '#withSettingsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettingsMixin(value): { settings+: value }, + settings+: + { + '#withScript': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withScript(value): { settings+: { script: value } }, + '#withScriptMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withScriptMixin(value): { settings+: { script+: value } }, + script+: + { + '#withInline': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withInline(value): { settings+: { script+: { inline: value } } }, + }, + }, + }, + CumulativeSum+: + { + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withHide(value=true): { hide: value }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value): { id: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withField(value): { field: value }, + '#withPipelineAgg': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withPipelineAgg(value): { pipelineAgg: value }, + '#withSettings': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettings(value): { settings: value }, + '#withSettingsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettingsMixin(value): { settings+: value }, + settings+: + { + '#withFormat': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withFormat(value): { settings+: { format: value } }, + }, + }, + Derivative+: + { + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withHide(value=true): { hide: value }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value): { id: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withField(value): { field: value }, + '#withPipelineAgg': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withPipelineAgg(value): { pipelineAgg: value }, + '#withSettings': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettings(value): { settings: value }, + '#withSettingsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettingsMixin(value): { settings+: value }, + settings+: + { + '#withUnit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withUnit(value): { settings+: { unit: value } }, + }, + }, + SerialDiff+: + { + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withHide(value=true): { hide: value }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value): { id: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withField(value): { field: value }, + '#withPipelineAgg': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withPipelineAgg(value): { pipelineAgg: value }, + '#withSettings': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettings(value): { settings: value }, + '#withSettingsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettingsMixin(value): { settings+: value }, + settings+: + { + '#withLag': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withLag(value): { settings+: { lag: value } }, + }, + }, + RawData+: + { + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withHide(value=true): { hide: value }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value): { id: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + '#withSettings': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettings(value): { settings: value }, + '#withSettingsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettingsMixin(value): { settings+: value }, + settings+: + { + '#withSize': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withSize(value): { settings+: { size: value } }, + }, + }, + RawDocument+: + { + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withHide(value=true): { hide: value }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value): { id: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + '#withSettings': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettings(value): { settings: value }, + '#withSettingsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettingsMixin(value): { settings+: value }, + settings+: + { + '#withSize': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withSize(value): { settings+: { size: value } }, + }, + }, + UniqueCount+: + { + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withHide(value=true): { hide: value }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value): { id: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withField(value): { field: value }, + '#withSettings': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettings(value): { settings: value }, + '#withSettingsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettingsMixin(value): { settings+: value }, + settings+: + { + '#withMissing': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withMissing(value): { settings+: { missing: value } }, + '#withPrecisionThreshold': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withPrecisionThreshold(value): { settings+: { precision_threshold: value } }, + }, + }, + Percentiles+: + { + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withHide(value=true): { hide: value }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value): { id: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withField(value): { field: value }, + '#withSettings': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettings(value): { settings: value }, + '#withSettingsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettingsMixin(value): { settings+: value }, + settings+: + { + '#withScript': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withScript(value): { settings+: { script: value } }, + '#withScriptMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withScriptMixin(value): { settings+: { script+: value } }, + script+: + { + '#withInline': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withInline(value): { settings+: { script+: { inline: value } } }, + }, + '#withMissing': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withMissing(value): { settings+: { missing: value } }, + '#withPercents': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withPercents(value): { settings+: { percents: (if std.isArray(value) + then value + else [value]) } }, + '#withPercentsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withPercentsMixin(value): { settings+: { percents+: (if std.isArray(value) + then value + else [value]) } }, + }, + }, + ExtendedStats+: + { + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withHide(value=true): { hide: value }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value): { id: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withField(value): { field: value }, + '#withSettings': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettings(value): { settings: value }, + '#withSettingsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettingsMixin(value): { settings+: value }, + settings+: + { + '#withScript': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withScript(value): { settings+: { script: value } }, + '#withScriptMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withScriptMixin(value): { settings+: { script+: value } }, + script+: + { + '#withInline': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withInline(value): { settings+: { script+: { inline: value } } }, + }, + '#withMissing': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withMissing(value): { settings+: { missing: value } }, + '#withSigma': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withSigma(value): { settings+: { sigma: value } }, + }, + '#withMeta': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withMeta(value): { meta: value }, + '#withMetaMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withMetaMixin(value): { meta+: value }, + }, + Min+: + { + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withHide(value=true): { hide: value }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value): { id: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withField(value): { field: value }, + '#withSettings': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettings(value): { settings: value }, + '#withSettingsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettingsMixin(value): { settings+: value }, + settings+: + { + '#withScript': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withScript(value): { settings+: { script: value } }, + '#withScriptMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withScriptMixin(value): { settings+: { script+: value } }, + script+: + { + '#withInline': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withInline(value): { settings+: { script+: { inline: value } } }, + }, + '#withMissing': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withMissing(value): { settings+: { missing: value } }, + }, + }, + Max+: + { + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withHide(value=true): { hide: value }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value): { id: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withField(value): { field: value }, + '#withSettings': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettings(value): { settings: value }, + '#withSettingsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettingsMixin(value): { settings+: value }, + settings+: + { + '#withScript': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withScript(value): { settings+: { script: value } }, + '#withScriptMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withScriptMixin(value): { settings+: { script+: value } }, + script+: + { + '#withInline': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withInline(value): { settings+: { script+: { inline: value } } }, + }, + '#withMissing': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withMissing(value): { settings+: { missing: value } }, + }, + }, + Sum+: + { + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withHide(value=true): { hide: value }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value): { id: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withField(value): { field: value }, + '#withSettings': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettings(value): { settings: value }, + '#withSettingsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettingsMixin(value): { settings+: value }, + settings+: + { + '#withScript': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withScript(value): { settings+: { script: value } }, + '#withScriptMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withScriptMixin(value): { settings+: { script+: value } }, + script+: + { + '#withInline': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withInline(value): { settings+: { script+: { inline: value } } }, + }, + '#withMissing': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withMissing(value): { settings+: { missing: value } }, + }, + }, + Average+: + { + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withHide(value=true): { hide: value }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value): { id: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withField(value): { field: value }, + '#withSettings': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettings(value): { settings: value }, + '#withSettingsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettingsMixin(value): { settings+: value }, + settings+: + { + '#withMissing': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withMissing(value): { settings+: { missing: value } }, + '#withScript': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withScript(value): { settings+: { script: value } }, + '#withScriptMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withScriptMixin(value): { settings+: { script+: value } }, + script+: + { + '#withInline': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withInline(value): { settings+: { script+: { inline: value } } }, + }, + }, + }, + MovingAverage+: + { + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withHide(value=true): { hide: value }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value): { id: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withField(value): { field: value }, + '#withPipelineAgg': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withPipelineAgg(value): { pipelineAgg: value }, + '#withSettings': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettings(value): { settings: value }, + '#withSettingsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettingsMixin(value): { settings+: value }, + }, + MovingFunction+: + { + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withHide(value=true): { hide: value }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value): { id: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withField(value): { field: value }, + '#withPipelineAgg': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withPipelineAgg(value): { pipelineAgg: value }, + '#withSettings': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettings(value): { settings: value }, + '#withSettingsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettingsMixin(value): { settings+: value }, + settings+: + { + '#withScript': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withScript(value): { settings+: { script: value } }, + '#withScriptMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withScriptMixin(value): { settings+: { script+: value } }, + script+: + { + '#withInline': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withInline(value): { settings+: { script+: { inline: value } } }, + }, + '#withShift': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withShift(value): { settings+: { shift: value } }, + '#withWindow': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withWindow(value): { settings+: { window: value } }, + }, + }, + Logs+: + { + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withHide(value=true): { hide: value }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value): { id: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + '#withSettings': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettings(value): { settings: value }, + '#withSettingsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettingsMixin(value): { settings+: value }, + settings+: + { + '#withLimit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withLimit(value): { settings+: { limit: value } }, + }, + }, + Rate+: + { + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withHide(value=true): { hide: value }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value): { id: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + '#withField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withField(value): { field: value }, + '#withSettings': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettings(value): { settings: value }, + '#withSettingsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettingsMixin(value): { settings+: value }, + settings+: + { + '#withMode': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withMode(value): { settings+: { mode: value } }, + '#withUnit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withUnit(value): { settings+: { unit: value } }, + }, + }, + TopMetrics+: + { + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withHide(value=true): { hide: value }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withId(value): { id: value }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { type: value }, + '#withSettings': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettings(value): { settings: value }, + '#withSettingsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSettingsMixin(value): { settings+: value }, + settings+: + { + '#withMetrics': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withMetrics(value): { settings+: { metrics: (if std.isArray(value) + then value + else [value]) } }, + '#withMetricsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withMetricsMixin(value): { settings+: { metrics+: (if std.isArray(value) + then value + else [value]) } }, + '#withOrder': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withOrder(value): { settings+: { order: value } }, + '#withOrderBy': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withOrderBy(value): { settings+: { orderBy: value } }, + }, + }, + }, + }, + '#withQuery': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Lucene query' } }, + withQuery(value): { query: value }, + '#withTimeField': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Name of time field' } }, + withTimeField(value): { timeField: value }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/query/grafanaPyroscope.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/query/grafanaPyroscope.libsonnet new file mode 100644 index 0000000000..67fd2827ba --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/query/grafanaPyroscope.libsonnet @@ -0,0 +1,26 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.query.grafanaPyroscope', name: 'grafanaPyroscope' }, + '#withDatasource': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: "For mixed data sources the selected datasource is on the query level.\nFor non mixed scenarios this is undefined.\nTODO find a better way to do this ^ that's friendly to schema\nTODO this shouldn't be unknown but DataSourceRef | null" } }, + withDatasource(value): { datasource: value }, + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'true if query is disabled (ie should not be returned to the dashboard)\nNote this does not always imply that the query should not be executed since\nthe results from a hidden query may be used as the input to other queries (SSE etc)' } }, + withHide(value=true): { hide: value }, + '#withQueryType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Specify the query flavor\nTODO make this required and give it a default' } }, + withQueryType(value): { queryType: value }, + '#withRefId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'A unique identifier for the query within the list of targets.\nIn server side expressions, the refId is used as a variable name to identify results.\nBy default, the UI will assign A->Z; however setting meaningful names may be useful.' } }, + withRefId(value): { refId: value }, + '#withGroupBy': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Allows to group the results.' } }, + withGroupBy(value): { groupBy: (if std.isArray(value) + then value + else [value]) }, + '#withGroupByMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Allows to group the results.' } }, + withGroupByMixin(value): { groupBy+: (if std.isArray(value) + then value + else [value]) }, + '#withLabelSelector': { 'function': { args: [{ default: '{}', enums: null, name: 'value', type: 'string' }], help: 'Specifies the query label selectors.' } }, + withLabelSelector(value='{}'): { labelSelector: value }, + '#withMaxNodes': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'Sets the maximum number of nodes in the flamegraph.' } }, + withMaxNodes(value): { maxNodes: value }, + '#withProfileTypeId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Specifies the type of profile to query.' } }, + withProfileTypeId(value): { profileTypeId: value }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/query/loki.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/query/loki.libsonnet new file mode 100644 index 0000000000..b15000229e --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/query/loki.libsonnet @@ -0,0 +1,26 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.query.loki', name: 'loki' }, + '#withDatasource': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: "For mixed data sources the selected datasource is on the query level.\nFor non mixed scenarios this is undefined.\nTODO find a better way to do this ^ that's friendly to schema\nTODO this shouldn't be unknown but DataSourceRef | null" } }, + withDatasource(value): { datasource: value }, + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'true if query is disabled (ie should not be returned to the dashboard)\nNote this does not always imply that the query should not be executed since\nthe results from a hidden query may be used as the input to other queries (SSE etc)' } }, + withHide(value=true): { hide: value }, + '#withQueryType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Specify the query flavor\nTODO make this required and give it a default' } }, + withQueryType(value): { queryType: value }, + '#withRefId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'A unique identifier for the query within the list of targets.\nIn server side expressions, the refId is used as a variable name to identify results.\nBy default, the UI will assign A->Z; however setting meaningful names may be useful.' } }, + withRefId(value): { refId: value }, + '#withEditorMode': { 'function': { args: [{ default: null, enums: ['code', 'builder'], name: 'value', type: 'string' }], help: '' } }, + withEditorMode(value): { editorMode: value }, + '#withExpr': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The LogQL query.' } }, + withExpr(value): { expr: value }, + '#withInstant': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '@deprecated, now use queryType.' } }, + withInstant(value=true): { instant: value }, + '#withLegendFormat': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Used to override the name of the series.' } }, + withLegendFormat(value): { legendFormat: value }, + '#withMaxLines': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'Used to limit the number of log rows returned.' } }, + withMaxLines(value): { maxLines: value }, + '#withRange': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '@deprecated, now use queryType.' } }, + withRange(value=true): { range: value }, + '#withResolution': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'Used to scale the interval value.' } }, + withResolution(value): { resolution: value }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/query/parca.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/query/parca.libsonnet new file mode 100644 index 0000000000..832453d5af --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/query/parca.libsonnet @@ -0,0 +1,16 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.query.parca', name: 'parca' }, + '#withDatasource': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: "For mixed data sources the selected datasource is on the query level.\nFor non mixed scenarios this is undefined.\nTODO find a better way to do this ^ that's friendly to schema\nTODO this shouldn't be unknown but DataSourceRef | null" } }, + withDatasource(value): { datasource: value }, + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'true if query is disabled (ie should not be returned to the dashboard)\nNote this does not always imply that the query should not be executed since\nthe results from a hidden query may be used as the input to other queries (SSE etc)' } }, + withHide(value=true): { hide: value }, + '#withQueryType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Specify the query flavor\nTODO make this required and give it a default' } }, + withQueryType(value): { queryType: value }, + '#withRefId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'A unique identifier for the query within the list of targets.\nIn server side expressions, the refId is used as a variable name to identify results.\nBy default, the UI will assign A->Z; however setting meaningful names may be useful.' } }, + withRefId(value): { refId: value }, + '#withLabelSelector': { 'function': { args: [{ default: '{}', enums: null, name: 'value', type: 'string' }], help: 'Specifies the query label selectors.' } }, + withLabelSelector(value='{}'): { labelSelector: value }, + '#withProfileTypeId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Specifies the type of profile to query.' } }, + withProfileTypeId(value): { profileTypeId: value }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/query/prometheus.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/query/prometheus.libsonnet new file mode 100644 index 0000000000..71adff65c4 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/query/prometheus.libsonnet @@ -0,0 +1,28 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.query.prometheus', name: 'prometheus' }, + '#withDatasource': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: "For mixed data sources the selected datasource is on the query level.\nFor non mixed scenarios this is undefined.\nTODO find a better way to do this ^ that's friendly to schema\nTODO this shouldn't be unknown but DataSourceRef | null" } }, + withDatasource(value): { datasource: value }, + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'true if query is disabled (ie should not be returned to the dashboard)\nNote this does not always imply that the query should not be executed since\nthe results from a hidden query may be used as the input to other queries (SSE etc)' } }, + withHide(value=true): { hide: value }, + '#withQueryType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Specify the query flavor\nTODO make this required and give it a default' } }, + withQueryType(value): { queryType: value }, + '#withRefId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'A unique identifier for the query within the list of targets.\nIn server side expressions, the refId is used as a variable name to identify results.\nBy default, the UI will assign A->Z; however setting meaningful names may be useful.' } }, + withRefId(value): { refId: value }, + '#withEditorMode': { 'function': { args: [{ default: null, enums: ['code', 'builder'], name: 'value', type: 'string' }], help: '' } }, + withEditorMode(value): { editorMode: value }, + '#withExemplar': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Execute an additional query to identify interesting raw samples relevant for the given expr' } }, + withExemplar(value=true): { exemplar: value }, + '#withExpr': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The actual expression/query that will be evaluated by Prometheus' } }, + withExpr(value): { expr: value }, + '#withFormat': { 'function': { args: [{ default: null, enums: ['time_series', 'table', 'heatmap'], name: 'value', type: 'string' }], help: '' } }, + withFormat(value): { format: value }, + '#withInstant': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Returns only the latest value that Prometheus has scraped for the requested time series' } }, + withInstant(value=true): { instant: value }, + '#withIntervalFactor': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '@deprecated Used to specify how many times to divide max data points by. We use max data points under query options\nSee https://github.com/grafana/grafana/issues/48081' } }, + withIntervalFactor(value): { intervalFactor: value }, + '#withLegendFormat': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Series name override or template. Ex. {{hostname}} will be replaced with label value for hostname' } }, + withLegendFormat(value): { legendFormat: value }, + '#withRange': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'Returns a Range vector, comprised of a set of time series containing a range of data points over time for each time series' } }, + withRange(value=true): { range: value }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/query/tempo.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/query/tempo.libsonnet new file mode 100644 index 0000000000..d80af81688 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/query/tempo.libsonnet @@ -0,0 +1,54 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.query.tempo', name: 'tempo' }, + '#withDatasource': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: "For mixed data sources the selected datasource is on the query level.\nFor non mixed scenarios this is undefined.\nTODO find a better way to do this ^ that's friendly to schema\nTODO this shouldn't be unknown but DataSourceRef | null" } }, + withDatasource(value): { datasource: value }, + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'true if query is disabled (ie should not be returned to the dashboard)\nNote this does not always imply that the query should not be executed since\nthe results from a hidden query may be used as the input to other queries (SSE etc)' } }, + withHide(value=true): { hide: value }, + '#withQueryType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Specify the query flavor\nTODO make this required and give it a default' } }, + withQueryType(value): { queryType: value }, + '#withRefId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'A unique identifier for the query within the list of targets.\nIn server side expressions, the refId is used as a variable name to identify results.\nBy default, the UI will assign A->Z; however setting meaningful names may be useful.' } }, + withRefId(value): { refId: value }, + '#withFilters': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withFilters(value): { filters: (if std.isArray(value) + then value + else [value]) }, + '#withFiltersMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withFiltersMixin(value): { filters+: (if std.isArray(value) + then value + else [value]) }, + filters+: + { + '#': { help: '', name: 'filters' }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Uniquely identify the filter, will not be used in the query generation' } }, + withId(value): { id: value }, + '#withOperator': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The operator that connects the tag to the value, for example: =, >, !=, =~' } }, + withOperator(value): { operator: value }, + '#withScope': { 'function': { args: [{ default: null, enums: ['unscoped', 'resource', 'span'], name: 'value', type: 'string' }], help: 'static fields are pre-set in the UI, dynamic fields are added by the user' } }, + withScope(value): { scope: value }, + '#withTag': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The tag for the search filter, for example: .http.status_code, .service.name, status' } }, + withTag(value): { tag: value }, + '#withValue': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The value for the search filter' } }, + withValue(value): { value: value }, + '#withValueMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The value for the search filter' } }, + withValueMixin(value): { value+: value }, + '#withValueType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'The type of the value, used for example to check whether we need to wrap the value in quotes when generating the query' } }, + withValueType(value): { valueType: value }, + }, + '#withLimit': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'Defines the maximum number of traces that are returned from Tempo' } }, + withLimit(value): { limit: value }, + '#withMaxDuration': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Define the maximum duration to select traces. Use duration format, for example: 1.2s, 100ms' } }, + withMaxDuration(value): { maxDuration: value }, + '#withMinDuration': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Define the minimum duration to select traces. Use duration format, for example: 1.2s, 100ms' } }, + withMinDuration(value): { minDuration: value }, + '#withQuery': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'TraceQL query or trace ID' } }, + withQuery(value): { query: value }, + '#withSearch': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Logfmt query to filter traces by their tags. Example: http.status_code=200 error=true' } }, + withSearch(value): { search: value }, + '#withServiceMapQuery': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Filters to be included in a PromQL query to select data for the service graph. Example: {client="app",service="app"}' } }, + withServiceMapQuery(value): { serviceMapQuery: value }, + '#withServiceName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Query traces by service name' } }, + withServiceName(value): { serviceName: value }, + '#withSpanName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Query traces by span name' } }, + withSpanName(value): { spanName: value }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/query/testData.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/query/testData.libsonnet new file mode 100644 index 0000000000..63fbc79d85 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/query/testData.libsonnet @@ -0,0 +1,168 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.query.testData', name: 'testData' }, + '#withDatasource': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: "For mixed data sources the selected datasource is on the query level.\nFor non mixed scenarios this is undefined.\nTODO find a better way to do this ^ that's friendly to schema\nTODO this shouldn't be unknown but DataSourceRef | null" } }, + withDatasource(value): { datasource: value }, + '#withHide': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'true if query is disabled (ie should not be returned to the dashboard)\nNote this does not always imply that the query should not be executed since\nthe results from a hidden query may be used as the input to other queries (SSE etc)' } }, + withHide(value=true): { hide: value }, + '#withQueryType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Specify the query flavor\nTODO make this required and give it a default' } }, + withQueryType(value): { queryType: value }, + '#withRefId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'A unique identifier for the query within the list of targets.\nIn server side expressions, the refId is used as a variable name to identify results.\nBy default, the UI will assign A->Z; however setting meaningful names may be useful.' } }, + withRefId(value): { refId: value }, + '#withAlias': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withAlias(value): { alias: value }, + '#withChannel': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withChannel(value): { channel: value }, + '#withCsvContent': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withCsvContent(value): { csvContent: value }, + '#withCsvFileName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withCsvFileName(value): { csvFileName: value }, + '#withCsvWave': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withCsvWave(value): { csvWave: (if std.isArray(value) + then value + else [value]) }, + '#withCsvWaveMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withCsvWaveMixin(value): { csvWave+: (if std.isArray(value) + then value + else [value]) }, + csvWave+: + { + '#': { help: '', name: 'csvWave' }, + '#withLabels': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withLabels(value): { labels: value }, + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withName(value): { name: value }, + '#withTimeStep': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withTimeStep(value): { timeStep: value }, + '#withValuesCSV': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withValuesCSV(value): { valuesCSV: value }, + }, + '#withErrorType': { 'function': { args: [{ default: null, enums: ['server_panic', 'frontend_exception', 'frontend_observable'], name: 'value', type: 'string' }], help: '' } }, + withErrorType(value): { errorType: value }, + '#withLabels': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withLabels(value): { labels: value }, + '#withLevelColumn': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withLevelColumn(value=true): { levelColumn: value }, + '#withLines': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withLines(value): { lines: value }, + '#withNodes': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withNodes(value): { nodes: value }, + '#withNodesMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withNodesMixin(value): { nodes+: value }, + nodes+: + { + '#withCount': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withCount(value): { nodes+: { count: value } }, + '#withType': { 'function': { args: [{ default: null, enums: ['random', 'response', 'random edges'], name: 'value', type: 'string' }], help: '' } }, + withType(value): { nodes+: { type: value } }, + }, + '#withPoints': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withPoints(value): { points: (if std.isArray(value) + then value + else [value]) }, + '#withPointsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withPointsMixin(value): { points+: (if std.isArray(value) + then value + else [value]) }, + '#withPulseWave': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withPulseWave(value): { pulseWave: value }, + '#withPulseWaveMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withPulseWaveMixin(value): { pulseWave+: value }, + pulseWave+: + { + '#withOffCount': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withOffCount(value): { pulseWave+: { offCount: value } }, + '#withOffValue': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withOffValue(value): { pulseWave+: { offValue: value } }, + '#withOnCount': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withOnCount(value): { pulseWave+: { onCount: value } }, + '#withOnValue': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withOnValue(value): { pulseWave+: { onValue: value } }, + '#withTimeStep': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withTimeStep(value): { pulseWave+: { timeStep: value } }, + }, + '#withRawFrameContent': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withRawFrameContent(value): { rawFrameContent: value }, + '#withScenarioId': { 'function': { args: [{ default: null, enums: ['random_walk', 'slow_query', 'random_walk_with_error', 'random_walk_table', 'exponential_heatmap_bucket_data', 'linear_heatmap_bucket_data', 'no_data_points', 'datapoints_outside_range', 'csv_metric_values', 'predictable_pulse', 'predictable_csv_wave', 'streaming_client', 'simulation', 'usa', 'live', 'grafana_api', 'arrow', 'annotations', 'table_static', 'server_error_500', 'logs', 'node_graph', 'flame_graph', 'raw_frame', 'csv_file', 'csv_content', 'trace', 'manual_entry', 'variables-query'], name: 'value', type: 'string' }], help: '' } }, + withScenarioId(value): { scenarioId: value }, + '#withSeriesCount': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withSeriesCount(value): { seriesCount: value }, + '#withSim': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSim(value): { sim: value }, + '#withSimMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withSimMixin(value): { sim+: value }, + sim+: + { + '#withConfig': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withConfig(value): { sim+: { config: value } }, + '#withConfigMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withConfigMixin(value): { sim+: { config+: value } }, + '#withKey': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withKey(value): { sim+: { key: value } }, + '#withKeyMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withKeyMixin(value): { sim+: { key+: value } }, + key+: + { + '#withTick': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'number' }], help: '' } }, + withTick(value): { sim+: { key+: { tick: value } } }, + '#withType': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withType(value): { sim+: { key+: { type: value } } }, + '#withUid': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withUid(value): { sim+: { key+: { uid: value } } }, + }, + '#withLast': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withLast(value=true): { sim+: { last: value } }, + '#withStream': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: '' } }, + withStream(value=true): { sim+: { stream: value } }, + }, + '#withSpanCount': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withSpanCount(value): { spanCount: value }, + '#withStream': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withStream(value): { stream: value }, + '#withStreamMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withStreamMixin(value): { stream+: value }, + stream+: + { + '#withBands': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withBands(value): { stream+: { bands: value } }, + '#withNoise': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withNoise(value): { stream+: { noise: value } }, + '#withSpeed': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withSpeed(value): { stream+: { speed: value } }, + '#withSpread': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: '' } }, + withSpread(value): { stream+: { spread: value } }, + '#withType': { 'function': { args: [{ default: null, enums: ['signal', 'logs', 'fetch'], name: 'value', type: 'string' }], help: '' } }, + withType(value): { stream+: { type: value } }, + '#withUrl': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withUrl(value): { stream+: { url: value } }, + }, + '#withStringInput': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withStringInput(value): { stringInput: value }, + '#withUsa': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withUsa(value): { usa: value }, + '#withUsaMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: '' } }, + withUsaMixin(value): { usa+: value }, + usa+: + { + '#withFields': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withFields(value): { usa+: { fields: (if std.isArray(value) + then value + else [value]) } }, + '#withFieldsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withFieldsMixin(value): { usa+: { fields+: (if std.isArray(value) + then value + else [value]) } }, + '#withMode': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withMode(value): { usa+: { mode: value } }, + '#withPeriod': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: '' } }, + withPeriod(value): { usa+: { period: value } }, + '#withStates': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withStates(value): { usa+: { states: (if std.isArray(value) + then value + else [value]) } }, + '#withStatesMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: '' } }, + withStatesMixin(value): { usa+: { states+: (if std.isArray(value) + then value + else [value]) } }, + }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/serviceaccount.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/serviceaccount.libsonnet new file mode 100644 index 0000000000..d401e96f2a --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/serviceaccount.libsonnet @@ -0,0 +1,32 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.serviceaccount', name: 'serviceaccount' }, + '#withAccessControl': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'AccessControl metadata associated with a given resource.' } }, + withAccessControl(value): { accessControl: value }, + '#withAccessControlMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'AccessControl metadata associated with a given resource.' } }, + withAccessControlMixin(value): { accessControl+: value }, + '#withAvatarUrl': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: "AvatarUrl is the service account's avatar URL. It allows the frontend to display a picture in front\nof the service account." } }, + withAvatarUrl(value): { avatarUrl: value }, + '#withId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'ID is the unique identifier of the service account in the database.' } }, + withId(value): { id: value }, + '#withIsDisabled': { 'function': { args: [{ default: true, enums: null, name: 'value', type: 'boolean' }], help: 'IsDisabled indicates if the service account is disabled.' } }, + withIsDisabled(value=true): { isDisabled: value }, + '#withLogin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Login of the service account.' } }, + withLogin(value): { login: value }, + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Name of the service account.' } }, + withName(value): { name: value }, + '#withOrgId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'OrgId is the ID of an organisation the service account belongs to.' } }, + withOrgId(value): { orgId: value }, + '#withRole': { 'function': { args: [{ default: null, enums: ['Admin', 'Editor', 'Viewer'], name: 'value', type: 'string' }], help: "OrgRole is a Grafana Organization Role which can be 'Viewer', 'Editor', 'Admin'." } }, + withRole(value): { role: value }, + '#withTeams': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Teams is a list of teams the service account belongs to.' } }, + withTeams(value): { teams: (if std.isArray(value) + then value + else [value]) }, + '#withTeamsMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'array' }], help: 'Teams is a list of teams the service account belongs to.' } }, + withTeamsMixin(value): { teams+: (if std.isArray(value) + then value + else [value]) }, + '#withTokens': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'Tokens is the number of active tokens for the service account.\nTokens are used to authenticate the service account against Grafana.' } }, + withTokens(value): { tokens: value }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/team.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/team.libsonnet new file mode 100644 index 0000000000..c8f7ff7e28 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/raw/team.libsonnet @@ -0,0 +1,20 @@ +// This file is generated, do not manually edit. +{ + '#': { help: 'grafonnet.team', name: 'team' }, + '#withAccessControl': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'AccessControl metadata associated with a given resource.' } }, + withAccessControl(value): { accessControl: value }, + '#withAccessControlMixin': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'object' }], help: 'AccessControl metadata associated with a given resource.' } }, + withAccessControlMixin(value): { accessControl+: value }, + '#withAvatarUrl': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: "AvatarUrl is the team's avatar URL." } }, + withAvatarUrl(value): { avatarUrl: value }, + '#withEmail': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Email of the team.' } }, + withEmail(value): { email: value }, + '#withMemberCount': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'MemberCount is the number of the team members.' } }, + withMemberCount(value): { memberCount: value }, + '#withName': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'string' }], help: 'Name of the team.' } }, + withName(value): { name: value }, + '#withOrgId': { 'function': { args: [{ default: null, enums: null, name: 'value', type: 'integer' }], help: 'OrgId is the ID of an organisation the team belongs to.' } }, + withOrgId(value): { orgId: value }, + '#withPermission': { 'function': { args: [{ default: null, enums: [0, 1, 2, 4], name: 'value', type: 'integer' }], help: '' } }, + withPermission(value): { permission: value }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/CONTRIB.md b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/CONTRIB.md new file mode 100644 index 0000000000..fb85608dd9 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/CONTRIB.md @@ -0,0 +1,20 @@ + +## Panels overview + +All panels in this lib should implement one of the following methods: + +- `panel.new(title,targets,description)` - creates new panel. List of arguments could vary; +- `panel.stylize(allLayers=true)` - directly applies this panel style to existing panel. By default includes all layers of styles. To apply only top layer, set allLayers=false. This mode is useful to cherry-pick style layers to create new style combination. + +Some other methods could be found such as: +- `panel.stylizeByRegexp(regexp)` - attaches style as panel overrides (by regexp); +- `panel.stylizeByName(name)` - attaches style as panel overrides (by name). + +## Panels common groups + +This library consists of multiple common groups of panels for widely used resources such as CPU, memory, disks and so on. + +All of those groups inherit `generic` group as their base. + +All panels inherit `generic/base.libsonnet` via `generic//base.libsonnet`. + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/Makefile b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/Makefile new file mode 100644 index 0000000000..46933e1a4c --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/Makefile @@ -0,0 +1,23 @@ +JSONNET_FMT := jsonnetfmt -n 2 --max-blank-lines 1 --string-style s --comment-style s + +.PHONY: all +all: build + +vendor: jsonnetfile.json + jb install + +.PHONY: build +build: vendor + +.PHONY: fmt +fmt: + find . -name 'vendor' -prune -o -name '*.libsonnet' -print -o -name '*.jsonnet' -print | \ + xargs -n 1 -- $(JSONNET_FMT) -i + +.PHONY: lint +lint: build + find . -name 'vendor' -prune -o -name '*.libsonnet' -print -o -name '*.jsonnet' -print | \ + while read f; do \ + $(JSONNET_FMT) "$$f" | diff -u "$$f" -; \ + done + diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/README.md b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/README.md new file mode 100644 index 0000000000..93b3563242 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/README.md @@ -0,0 +1,33 @@ +# Grafana integrations common lib + +This common library can be used to quickly create dashboards' `panels` and `annotations`. + +By using this common library we can 'enforce' common style choices across multiple dashboards and mixins. + +## Import + +```sh +jb init +jb install https://github.com/grafana/jsonnet-libs/common-lib +``` + +## Use + +### Create new panel + +```jsonnet + +local commonlib = import 'github.com/grafana/jsonnet-libs/common-lib/common/main.libsonnet'; +local cpuUsage = commonlib.panels.cpu.timeSeries.utilization.new(targets=[targets.cpuUsage]); + +``` + +### Mutate exisiting panel with style options + +```jsonnet + +local commonlib = import 'github.com/grafana/jsonnet-libs/common-lib/common/main.libsonnet'; +local cpuPanel = oldPanel + commonlib.panels.cpu.timeSeries.utilization.stylize(); +``` + +See [windows-observ-lib](./windows-observ-lib) for full example. diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/annotations/base.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/annotations/base.libsonnet new file mode 100644 index 0000000000..8cb149be72 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/annotations/base.libsonnet @@ -0,0 +1,32 @@ +local g = import '../g.libsonnet'; +local annotation = g.dashboard.annotation; +{ + new( + title, + target, + ): + annotation.withEnable(true) + + annotation.withName(title) + + annotation.withDatasourceMixin(target.datasource) + { + titleFormat: title, + expr: target.expr, + + } + + (if std.objectHas(target, 'interval') then { step: target.interval } else {}), + + withTagKeys(value): + { + tagKeys: value, + }, + withValueForTime(value=false): + { + useValueForTime: value, + }, + withTextFormat(value=''): + { + textFormat: value, + }, + + +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/annotations/fatal.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/annotations/fatal.libsonnet new file mode 100644 index 0000000000..409d62d252 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/annotations/fatal.libsonnet @@ -0,0 +1,14 @@ +local g = import '../g.libsonnet'; +local annotation = g.dashboard.annotation; +local base = import './base.libsonnet'; + +// Show fatal or critical events as annotations +base { + new( + title, + target, + ): + super.new(title, target) + + annotation.withIconColor('light-purple') + + annotation.withHide(true), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/annotations/main.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/annotations/main.libsonnet new file mode 100644 index 0000000000..a904f9f3a8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/annotations/main.libsonnet @@ -0,0 +1,6 @@ +{ + base: import './base.libsonnet', + reboot: import './reboot.libsonnet', + serviceFailed: import './service_failed.libsonnet', + fatal: import './fatal.libsonnet', +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/annotations/reboot.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/annotations/reboot.libsonnet new file mode 100644 index 0000000000..a6d67e1110 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/annotations/reboot.libsonnet @@ -0,0 +1,16 @@ +local g = import '../g.libsonnet'; +local annotation = g.dashboard.annotation; +local base = import './base.libsonnet'; + +base { + new( + title, + target, + instanceLabels, + ): + super.new(title, target) + + annotation.withIconColor('light-yellow') + + annotation.withHide(true) + + { useValueForTime: 'on' } + + base.withTagKeys(instanceLabels), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/annotations/service_failed.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/annotations/service_failed.libsonnet new file mode 100644 index 0000000000..63f601f055 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/annotations/service_failed.libsonnet @@ -0,0 +1,13 @@ +local g = import '../g.libsonnet'; +local annotation = g.dashboard.annotation; +local base = import './base.libsonnet'; + +base { + new( + title, + target, + ): + super.new(title, target) + + annotation.withIconColor('light-orange') + + annotation.withHide(true), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/g.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/g.libsonnet new file mode 100644 index 0000000000..6da9f4eef9 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/g.libsonnet @@ -0,0 +1 @@ +import 'github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/main.libsonnet' diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/main.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/main.libsonnet new file mode 100644 index 0000000000..4b7c76e3b0 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/main.libsonnet @@ -0,0 +1,5 @@ +{ + annotations: import './annotations/main.libsonnet', + panels: import './panels.libsonnet', + utils: import './utils.libsonnet', +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels.libsonnet new file mode 100644 index 0000000000..f054c0e316 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels.libsonnet @@ -0,0 +1,33 @@ +local g = import './g.libsonnet'; + +{ + generic: { + stat: import './panels/generic/stat/main.libsonnet', + timeSeries: import './panels/generic/timeSeries/main.libsonnet', + table: import './panels/generic/table/main.libsonnet', + statusHistory: import './panels/generic/statusHistory/main.libsonnet', + }, + network: { + timeSeries: import './panels/network/timeSeries/main.libsonnet', + statusHistory: import './panels/network/statusHistory/main.libsonnet', + }, + system: { + stat: import './panels/system/stat/main.libsonnet', + table: import './panels/system/table/main.libsonnet', + statusHistory: import './panels/system/statusHistory/main.libsonnet', + timeSeries: import './panels/system/timeSeries/main.libsonnet', + }, + cpu: { + stat: import './panels/cpu/stat/main.libsonnet', + timeSeries: import './panels/cpu/timeSeries/main.libsonnet', + }, + memory: { + stat: import './panels/memory/stat/main.libsonnet', + timeSeries: import './panels/memory/timeSeries/main.libsonnet', + }, + disk: { + timeSeries: import './panels/disk/timeSeries/main.libsonnet', + table: import './panels/disk/table/main.libsonnet', + stat: import './panels/disk/stat/main.libsonnet', + }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/cpu/stat/base.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/cpu/stat/base.libsonnet new file mode 100644 index 0000000000..587b02b91f --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/cpu/stat/base.libsonnet @@ -0,0 +1,7 @@ +local g = import '../../../g.libsonnet'; +local stat = g.panel.stat; +local base = import '../../generic/stat/base.libsonnet'; + +base { + +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/cpu/stat/count.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/cpu/stat/count.libsonnet new file mode 100644 index 0000000000..915060b491 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/cpu/stat/count.libsonnet @@ -0,0 +1,21 @@ +local g = import '../../../g.libsonnet'; +local generic = import '../../generic/stat/main.libsonnet'; +local base = import './base.libsonnet'; +local stat = g.panel.stat; + +base { + new( + title='CPU count', + targets, + description=||| + CPU count is the number of processor cores or central processing units (CPUs) in a computer, + determining its processing capability and ability to handle tasks concurrently. + ||| + ): + super.new(title, targets, description), + + stylize(allLayers=true): + (if allLayers then super.stylize() else {}) + + generic.info.stylize(allLayers=false), + +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/cpu/stat/main.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/cpu/stat/main.libsonnet new file mode 100644 index 0000000000..df20b658e5 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/cpu/stat/main.libsonnet @@ -0,0 +1,5 @@ +{ + base: import './base.libsonnet', + usage: import './usage.libsonnet', + count: import './count.libsonnet', +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/cpu/stat/usage.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/cpu/stat/usage.libsonnet new file mode 100644 index 0000000000..bf019157de --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/cpu/stat/usage.libsonnet @@ -0,0 +1,22 @@ +local g = import '../../../g.libsonnet'; +local generic = import '../../generic/stat/main.libsonnet'; +local base = import './base.libsonnet'; +local stat = g.panel.stat; + +base { + new( + title='CPU usage', + targets, + description=||| + Total CPU utilization percent is a metric that indicates the overall level of central processing unit (CPU) usage in a computer system. + It represents the combined load placed on all CPU cores or processors. + + For instance, if the total CPU utilization percent is 50%, it means that, + on average, half of the CPU's processing capacity is being used to execute tasks. A higher percentage indicates that the CPU is working more intensively, potentially leading to system slowdowns if it remains consistently high. + ||| + ): + super.new(title, targets, description), + stylize(allLayers=true): + (if allLayers then super.stylize() else {}) + + generic.percentage.stylize(allLayers=false), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/cpu/timeSeries/base.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/cpu/timeSeries/base.libsonnet new file mode 100644 index 0000000000..622d9bed7c --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/cpu/timeSeries/base.libsonnet @@ -0,0 +1,6 @@ +local g = import '../../../g.libsonnet'; +local base = import '../../generic/timeSeries/base.libsonnet'; + +base { + +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/cpu/timeSeries/main.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/cpu/timeSeries/main.libsonnet new file mode 100644 index 0000000000..3e90065783 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/cpu/timeSeries/main.libsonnet @@ -0,0 +1,5 @@ +{ + base: import './base.libsonnet', + utilization: import './utilization.libsonnet', + utilizationByMode: import './utilization_by_mode.libsonnet', +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/cpu/timeSeries/utilization.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/cpu/timeSeries/utilization.libsonnet new file mode 100644 index 0000000000..fd365ac097 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/cpu/timeSeries/utilization.libsonnet @@ -0,0 +1,22 @@ +local g = import '../../../g.libsonnet'; +local generic = import '../../generic/timeSeries/main.libsonnet'; +local base = import './base.libsonnet'; +base { + new( + title='CPU usage', + targets, + description=||| + Total CPU utilization percent is a metric that indicates the overall level of central processing unit (CPU) usage in a computer system. + It represents the combined load placed on all CPU cores or processors. + + For instance, if the total CPU utilization percent is 50%, it means that, + on average, half of the CPU's processing capacity is being used to execute tasks. A higher percentage indicates that the CPU is working more intensively, potentially leading to system slowdowns if it remains consistently high. + ||| + ): + super.new(title, targets, description) + + self.stylize(), + + stylize(allLayers=true): + (if allLayers then super.stylize() else {}) + + generic.percentage.stylize(allLayers=false), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/cpu/timeSeries/utilization_by_core.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/cpu/timeSeries/utilization_by_core.libsonnet new file mode 100644 index 0000000000..18b0e90b1b --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/cpu/timeSeries/utilization_by_core.libsonnet @@ -0,0 +1,20 @@ +local g = import '../../../g.libsonnet'; +local generic = import '../../generic/timeSeries/main.libsonnet'; +local base = import './base.libsonnet'; +base { + new( + title='CPU usage', + targets, + description=||| + CPU utilization percent by core is a metric that indicates level of central processing unit (CPU) usage in a computer system. + It represents the load placed on each CPU core or processors. + ||| + ): + super.new(title, targets, description) + + self.stylize(), + + stylize(allLayers=true): + (if allLayers then super.stylize() else {}) + + generic.percentage.stylize(allLayers=false) + + g.panel.timeSeries.fieldConfig.defaults.custom.withStacking({ mode: 'normal' }), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/cpu/timeSeries/utilization_by_mode.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/cpu/timeSeries/utilization_by_mode.libsonnet new file mode 100644 index 0000000000..177c6ea496 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/cpu/timeSeries/utilization_by_mode.libsonnet @@ -0,0 +1,45 @@ +local g = import '../../../g.libsonnet'; +local base = import './base.libsonnet'; +base { + new( + title='CPU usage by modes', + targets, + description='CPU usage by different modes.' + ): + super.new(title, targets, description) + + self.stylize(), + + stylize(allLayers=true): + local timeSeries = g.panel.timeSeries; + local fieldOverride = g.panel.timeSeries.fieldOverride; + + (if allLayers then super.stylize() else {}) + + + timeSeries.standardOptions.withUnit('percent') + + timeSeries.fieldConfig.defaults.custom.withFillOpacity(80) + + timeSeries.fieldConfig.defaults.custom.withStacking({ mode: 'normal' }) + + timeSeries.standardOptions.withOverrides( + [ + fieldOverride.byName.new('idle') + + fieldOverride.byName.withPropertiesFromOptions( + timeSeries.standardOptions.color.withMode('fixed') + + timeSeries.standardOptions.color.withFixedColor('light-blue'), + ), + fieldOverride.byName.new('interrupt') + + fieldOverride.byName.withPropertiesFromOptions( + timeSeries.standardOptions.color.withMode('fixed') + + timeSeries.standardOptions.color.withFixedColor('light-purple'), + ), + fieldOverride.byName.new('user') + + fieldOverride.byName.withPropertiesFromOptions( + timeSeries.standardOptions.color.withMode('fixed') + + timeSeries.standardOptions.color.withFixedColor('light-orange'), + ), + fieldOverride.byRegexp.new('system|privileged') + + fieldOverride.byRegexp.withPropertiesFromOptions( + timeSeries.standardOptions.color.withMode('fixed') + + timeSeries.standardOptions.color.withFixedColor('light-red'), + ), + ] + ), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/stat/base.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/stat/base.libsonnet new file mode 100644 index 0000000000..09aef26e72 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/stat/base.libsonnet @@ -0,0 +1,6 @@ +local g = import '../../../g.libsonnet'; +local stat = g.panel.stat; +local base = import '../../generic/stat/base.libsonnet'; + +base { +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/stat/main.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/stat/main.libsonnet new file mode 100644 index 0000000000..79f34433d3 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/stat/main.libsonnet @@ -0,0 +1,4 @@ +{ + base: import './base.libsonnet', + total: import './total.libsonnet', +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/stat/total.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/stat/total.libsonnet new file mode 100644 index 0000000000..6e81dfc059 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/stat/total.libsonnet @@ -0,0 +1,20 @@ +local g = import '../../../g.libsonnet'; +local generic = import '../../generic/stat/main.libsonnet'; +local base = import './base.libsonnet'; +local stat = g.panel.stat; + +base { + new( + title, + targets, + description='' + ): + super.new(title=title, targets=targets, description=description), + + stylize(allLayers=true): + + (if allLayers then super.stylize() else {}) + + + generic.info.stylize(allLayers=false) + + stat.standardOptions.withUnit('bytes'), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/table/base.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/table/base.libsonnet new file mode 100644 index 0000000000..6caa7f945f --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/table/base.libsonnet @@ -0,0 +1,10 @@ +local g = import '../../../g.libsonnet'; +local base = import '../../generic/table/base.libsonnet'; +local table = g.panel.table; +local fieldOverride = g.panel.table.fieldOverride; +local custom = table.fieldConfig.defaults.custom; +local defaults = table.fieldConfig.defaults; +local options = table.options; +base { + +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/table/main.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/table/main.libsonnet new file mode 100644 index 0000000000..5493c27611 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/table/main.libsonnet @@ -0,0 +1,4 @@ +{ + base: import './base.libsonnet', + usage: import './usage.libsonnet', +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/table/usage.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/table/usage.libsonnet new file mode 100644 index 0000000000..9011838d55 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/table/usage.libsonnet @@ -0,0 +1,256 @@ +local g = import '../../../g.libsonnet'; +local base = import './base.libsonnet'; +local table = g.panel.table; +local fieldOverride = g.panel.table.fieldOverride; +local custom = table.fieldConfig.defaults.custom; +local defaults = table.fieldConfig.defaults; +local options = table.options; + +base { + new( + title='Disk space usage', + totalTarget, + usageTarget=null, + freeTarget=null, + groupLabel, + description=||| + This table provides information about total disk space, used space, available space, and usage percentages for each mounted file system on the system. + |||, + ): + // validate inputs + std.prune( + { + checks: [ + if (usageTarget == null && freeTarget == null) then error 'Must provide at leason one of "usageTarget" or "freeTraget"', + if !(std.objectHas(totalTarget, 'format') && std.assertEqual(totalTarget.format, 'table')) then error 'totalTarget format must be "table"', + if !(std.objectHas(totalTarget, 'instant') && std.assertEqual(totalTarget.instant, true)) then error 'totalTarget must have type "instant"', + if usageTarget != null && !(std.objectHas(usageTarget, 'format') && std.assertEqual(usageTarget.format, 'table')) then error 'usageTarget format must be "table"', + if usageTarget != null && !(std.objectHas(usageTarget, 'instant') && std.assertEqual(usageTarget.instant, true)) then error 'usageTarget must have type "instant"', + if freeTarget != null && !(std.objectHas(freeTarget, 'format') && std.assertEqual(freeTarget.format, 'table')) then error 'freeTarget format must be "table"', + if freeTarget != null && !(std.objectHas(freeTarget, 'instant') && std.assertEqual(freeTarget.instant, true)) then error 'freeTarget must have type "instant"', + ], + } + ) + + if usageTarget != null + then + ( + super.new( + title=title, + targets=[ + totalTarget { refId: 'TOTAL' }, + usageTarget { refId: 'USAGE' }, + ], + description=description, + ) + + $.withUsageTableCommonMixin() + + table.queryOptions.withTransformationsMixin( + [ + { + id: 'groupBy', + options: { + fields: { + 'Value #TOTAL': { + aggregations: [ + 'lastNotNull', + ], + operation: 'aggregate', + }, + 'Value #USAGE': { + aggregations: [ + 'lastNotNull', + ], + operation: 'aggregate', + }, + [groupLabel]: { + aggregations: [], + operation: 'groupby', + }, + }, + }, + }, + { + id: 'merge', + options: {}, + }, + { + id: 'calculateField', + options: { + alias: 'Available', + binary: { + left: 'Value #TOTAL (lastNotNull)', + operator: '-', + reducer: 'sum', + right: 'Value #USAGE (lastNotNull)', + }, + mode: 'binary', + reduce: { + reducer: 'sum', + }, + }, + }, + { + id: 'calculateField', + options: { + alias: 'Used, %', + binary: { + left: 'Value #USAGE (lastNotNull)', + operator: '/', + reducer: 'sum', + right: 'Value #TOTAL (lastNotNull)', + }, + mode: 'binary', + reduce: { + reducer: 'sum', + }, + }, + }, + { + id: 'organize', + options: { + excludeByName: {}, + indexByName: { + [groupLabel]: 0, + 'Value #TOTAL (lastNotNull)': 1, + Available: 2, + 'Value #USAGE (lastNotNull)': 3, + 'Used, %': 4, + }, + renameByName: { + 'Value #TOTAL (lastNotNull)': 'Size', + 'Value #USAGE (lastNotNull)': 'Used', + [groupLabel]: 'Mounted on', + }, + }, + }, + self.transformations.sortBy('Mounted on'), + ] + ) + ) + else if freeTarget != null && usageTarget == null + then + ( + super.new( + title=title, + targets=[ + totalTarget { refId: 'TOTAL' }, + freeTarget { refId: 'FREE' }, + ], + description=description, + ) + + $.withUsageTableCommonMixin() + + table.queryOptions.withTransformationsMixin( + [ + { + id: 'groupBy', + options: { + fields: { + 'Value #TOTAL': { + aggregations: [ + 'lastNotNull', + ], + operation: 'aggregate', + }, + 'Value #FREE': { + aggregations: [ + 'lastNotNull', + ], + operation: 'aggregate', + }, + [groupLabel]: { + aggregations: [], + operation: 'groupby', + }, + }, + }, + }, + { + id: 'merge', + options: {}, + }, + { + id: 'calculateField', + options: { + alias: 'Used', + binary: { + left: 'Value #TOTAL (lastNotNull)', + operator: '-', + reducer: 'sum', + right: 'Value #FREE (lastNotNull)', + }, + mode: 'binary', + reduce: { + reducer: 'sum', + }, + }, + }, + { + id: 'calculateField', + options: { + alias: 'Used, %', + binary: { + left: 'Used', + operator: '/', + reducer: 'sum', + right: 'Value #TOTAL (lastNotNull)', + }, + mode: 'binary', + reduce: { + reducer: 'sum', + }, + }, + }, + { + id: 'organize', + options: { + excludeByName: {}, + indexByName: { + [groupLabel]: 0, + 'Value #TOTAL (lastNotNull)': 1, + 'Value #FREE (lastNotNull)': 2, + Used: 3, + 'Used, %': 4, + }, + renameByName: { + 'Value #TOTAL (lastNotNull)': 'Size', + 'Value #FREE (lastNotNull)': 'Available', + [groupLabel]: 'Mounted on', + }, + }, + }, + self.transformations.sortBy('Mounted on'), + ] + ) + ) + else {}, + + withUsageTableCommonMixin(): + table.standardOptions.thresholds.withSteps( + [ + table.thresholdStep.withColor('light-blue') + + table.thresholdStep.withValue(null), + table.thresholdStep.withColor('light-yellow') + + table.thresholdStep.withValue(0.8), + table.thresholdStep.withColor('light-red') + + table.thresholdStep.withValue(0.9), + ] + ) + + + table.standardOptions.withOverrides([ + fieldOverride.byName.new('Mounted on') + + fieldOverride.byName.withProperty('custom.width', '260'), + fieldOverride.byName.new('Size') + + fieldOverride.byName.withProperty('custom.width', '80'), + fieldOverride.byName.new('Used') + + fieldOverride.byName.withProperty('custom.width', '80'), + fieldOverride.byName.new('Available') + + fieldOverride.byName.withProperty('custom.width', '80'), + fieldOverride.byName.new('Used, %') + + fieldOverride.byName.withProperty('custom.displayMode', 'basic') + + fieldOverride.byName.withPropertiesFromOptions( + table.standardOptions.withMax(1) + + table.standardOptions.withMin(0) + + table.standardOptions.withUnit('percentunit') + ), + ]) + + table.standardOptions.withUnit('bytes'), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/timeSeries/available.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/timeSeries/available.libsonnet new file mode 100644 index 0000000000..0e707c022f --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/timeSeries/available.libsonnet @@ -0,0 +1,23 @@ +local g = import '../../../g.libsonnet'; +local base = import './base.libsonnet'; +local timeSeries = g.panel.timeSeries; +local fieldOverride = g.panel.timeSeries.fieldOverride; +local custom = timeSeries.fieldConfig.defaults.custom; +local defaults = timeSeries.fieldConfig.defaults; +local options = timeSeries.options; +base { + new( + title='Disk space available', + targets, + description='', + ): + super.new(title, targets, description) + + self.stylize(), + + stylize(allLayers=true): + + (if allLayers == true then super.stylize() else {}) + + + timeSeries.standardOptions.withUnit('bytes') + + timeSeries.standardOptions.withMin(0), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/timeSeries/base.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/timeSeries/base.libsonnet new file mode 100644 index 0000000000..f5b09f21d6 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/timeSeries/base.libsonnet @@ -0,0 +1,27 @@ +local g = import '../../../g.libsonnet'; +local base = import '../../generic/timeSeries/base.libsonnet'; +local timeSeries = g.panel.timeSeries; +local fieldOverride = g.panel.timeSeries.fieldOverride; +local custom = timeSeries.fieldConfig.defaults.custom; +local defaults = timeSeries.fieldConfig.defaults; +local options = timeSeries.options; +base { + + stylize(allLayers=true): + + (if allLayers == true then super.stylize() else {}) + // Decrease opacity (would look better with too many timeseries) + + defaults.custom.withFillOpacity(1), + + + withNegateOutPackets(regexp='/write|written/'): + defaults.custom.withAxisLabel('write(-) | read(+)') + + defaults.custom.withAxisCenteredZero(true) + + timeSeries.standardOptions.withOverrides( + fieldOverride.byRegexp.new(regexp) + + fieldOverride.byRegexp.withPropertiesFromOptions( + defaults.custom.withTransform('negative-Y') + ) + ), + +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/timeSeries/io_bytes_persec.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/timeSeries/io_bytes_persec.libsonnet new file mode 100644 index 0000000000..addf4f4950 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/timeSeries/io_bytes_persec.libsonnet @@ -0,0 +1,31 @@ +local g = import '../../../g.libsonnet'; +local base = import './base.libsonnet'; +local timeSeries = g.panel.timeSeries; +local fieldOverride = g.panel.timeSeries.fieldOverride; +local custom = timeSeries.fieldConfig.defaults.custom; +local defaults = timeSeries.fieldConfig.defaults; +local options = timeSeries.options; +base { + new( + title='Disk reads/writes', + targets, + description='Disk read/writes in bytes per second.', + ): + super.new(title, targets, description) + + self.stylize(), + + stylize(allLayers=true): + + (if allLayers == true then super.stylize() else {}) + + + timeSeries.standardOptions.withUnit('Bps') + // move 'IO busy time' to second axis if found + + timeSeries.standardOptions.withOverrides( + fieldOverride.byRegexp.new('/time|used|busy|util/') + + fieldOverride.byRegexp.withPropertiesFromOptions( + timeSeries.standardOptions.withUnit('percent') + + timeSeries.fieldConfig.defaults.custom.withDrawStyle('points') + + timeSeries.fieldConfig.defaults.custom.withAxisSoftMax(100) + ) + ), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/timeSeries/io_queue.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/timeSeries/io_queue.libsonnet new file mode 100644 index 0000000000..157796af63 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/timeSeries/io_queue.libsonnet @@ -0,0 +1,23 @@ +local g = import '../../../g.libsonnet'; +local generic = import '../../generic/timeSeries/main.libsonnet'; +local base = import './base.libsonnet'; +local timeSeries = g.panel.timeSeries; +local fieldOverride = g.panel.timeSeries.fieldOverride; +local custom = timeSeries.fieldConfig.defaults.custom; +local defaults = timeSeries.fieldConfig.defaults; +local options = timeSeries.options; +base { + new( + title='Disk IO queue', + targets, + description='Disk average IO queue.', + ): + super.new(title, targets, description) + + self.stylize(), + + stylize(allLayers=true): + + (if allLayers == true then super.stylize() else {}) + + + self.withNegateOutPackets(), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/timeSeries/io_wait_time.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/timeSeries/io_wait_time.libsonnet new file mode 100644 index 0000000000..ae17d529e4 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/timeSeries/io_wait_time.libsonnet @@ -0,0 +1,25 @@ +local g = import '../../../g.libsonnet'; +local base = import './base.libsonnet'; +local timeSeries = g.panel.timeSeries; +local fieldOverride = g.panel.timeSeries.fieldOverride; +local custom = timeSeries.fieldConfig.defaults.custom; +local defaults = timeSeries.fieldConfig.defaults; +local options = timeSeries.options; +base { + new( + title='Disk average wait time', + targets, + description=||| + The average time for requests issued to the device to be served. + This includes the time spent by the requests in queue and the time spent servicing them.' + ||| + ): + super.new(title, targets, description) + + self.stylize(), + + stylize(allLayers=true): + + (if allLayers == true then super.stylize() else {}) + + timeSeries.standardOptions.withUnit('s') + + self.withNegateOutPackets(), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/timeSeries/iops.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/timeSeries/iops.libsonnet new file mode 100644 index 0000000000..fd30b051f7 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/timeSeries/iops.libsonnet @@ -0,0 +1,23 @@ +local g = import '../../../g.libsonnet'; +local base = import './base.libsonnet'; +local timeSeries = g.panel.timeSeries; +local fieldOverride = g.panel.timeSeries.fieldOverride; +local custom = timeSeries.fieldConfig.defaults.custom; +local defaults = timeSeries.fieldConfig.defaults; +local options = timeSeries.options; +base { + new( + title='Disk I/O', + targets, + description=||| + The number of I/O requests per second for the device/volume. + ||| + ): + super.new(title, targets, description) + + self.stylize(), + stylize(allLayers=true): + + (if allLayers == true then super.stylize() else {}) + + timeSeries.standardOptions.withUnit('iops') + + self.withNegateOutPackets(), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/timeSeries/main.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/timeSeries/main.libsonnet new file mode 100644 index 0000000000..5fc8df51dd --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/timeSeries/main.libsonnet @@ -0,0 +1,10 @@ +{ + base: import './base.libsonnet', + ioBytesPerSec: import './io_bytes_persec.libsonnet', + iops: import './iops.libsonnet', + ioQueue: import './io_queue.libsonnet', + ioWaitTime: import './io_wait_time.libsonnet', + available: import './available.libsonnet', + usage: import './usage.libsonnet', + usagePercent: import './usage_percent.libsonnet', +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/timeSeries/usage.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/timeSeries/usage.libsonnet new file mode 100644 index 0000000000..84b2fab623 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/timeSeries/usage.libsonnet @@ -0,0 +1,23 @@ +local g = import '../../../g.libsonnet'; +local base = import './base.libsonnet'; +local timeSeries = g.panel.timeSeries; +local fieldOverride = g.panel.timeSeries.fieldOverride; +local custom = timeSeries.fieldConfig.defaults.custom; +local defaults = timeSeries.fieldConfig.defaults; +local options = timeSeries.options; +base { + new( + title='Disk space used', + targets, + description=||| + Disk space usage is the amount of storage being used on a device's hard drive or storage medium, in bytes. + |||, + ): + super.new(title, targets, description) + + self.stylize(), + + stylize(allLayers=true): + + (if allLayers == true then super.stylize() else {}) + + timeSeries.standardOptions.withUnit('bytes'), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/timeSeries/usage_percent.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/timeSeries/usage_percent.libsonnet new file mode 100644 index 0000000000..f5d355423d --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/disk/timeSeries/usage_percent.libsonnet @@ -0,0 +1,25 @@ +local g = import '../../../g.libsonnet'; +local generic = import '../../generic/timeSeries/main.libsonnet'; +local base = import './base.libsonnet'; +local timeSeries = g.panel.timeSeries; +local fieldOverride = g.panel.timeSeries.fieldOverride; +local custom = timeSeries.fieldConfig.defaults.custom; +local defaults = timeSeries.fieldConfig.defaults; +local options = timeSeries.options; +base { + new( + title='Disk space used, %', + targets, + description=||| + Disk space usage is the amount of storage being used on a device's hard drive or storage medium, in percent. + |||, + ): + super.new(title, targets, description) + + self.stylize(), + + stylize(allLayers=true): + + (if allLayers == true then super.stylize() else {}) + + timeSeries.standardOptions.withUnit('percent') + + generic.percentage.stylize(allLayers=false), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/base.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/base.libsonnet new file mode 100644 index 0000000000..067cf534cb --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/base.libsonnet @@ -0,0 +1,27 @@ +local g = import '../../g.libsonnet'; + +local timeSeries = g.panel.timeSeries; +local fieldOverride = g.panel.timeSeries.fieldOverride; +local custom = timeSeries.fieldConfig.defaults.custom; +local defaults = timeSeries.fieldConfig.defaults; +local options = timeSeries.options; + +// This is base of ALL panels in the common lib +{ + new(targets, description=''): + // hidden field to hold styles modifiers + + timeSeries.queryOptions.withTargets(targets) + + timeSeries.panelOptions.withDescription(description) + // set first target's datasource + // to panel's datasource if only single type of + // datasoures are used accross all targets: + + (if std.length(std.set(targets, function(t) t.datasource.type)) == 1 then + timeSeries.queryOptions.withDatasource( + targets[0].datasource.type, targets[0].datasource.uid + ) else {}) + + self.stylize(), + + stylize(): {}, + +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/stat/base.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/stat/base.libsonnet new file mode 100644 index 0000000000..8d70456ce1 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/stat/base.libsonnet @@ -0,0 +1,12 @@ +local g = import '../../../g.libsonnet'; +local stat = g.panel.stat; +local base = import '../base.libsonnet'; + +base { + new(title, targets, description=''): + stat.new(title) + + super.new(targets, description), + + stylize(allLayers=true): + (if allLayers then super.stylize() else {}), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/stat/info.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/stat/info.libsonnet new file mode 100644 index 0000000000..05fc5a7d76 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/stat/info.libsonnet @@ -0,0 +1,21 @@ +local g = import '../../../g.libsonnet'; +local base = import './base.libsonnet'; +local stat = g.panel.stat; +// Simple info panel prototype with text or count of things. +base { + + stylize(allLayers=true): + (if allLayers then super.stylize() else {}) + // Style choice: No color for simple text panels by default + + stat.options.withColorMode('fixed') + + stat.standardOptions.color.withFixedColor('text') + // Style choice: No graph + + stat.options.withGraphMode('none') + // Show last value by default, not mean. + + stat.options.withReduceOptions({}) + + stat.options.reduceOptions.withCalcsMixin( + [ + 'lastNotNull', + ] + ), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/stat/main.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/stat/main.libsonnet new file mode 100644 index 0000000000..93899e7461 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/stat/main.libsonnet @@ -0,0 +1,5 @@ +{ + base: import './base.libsonnet', + info: import './info.libsonnet', + percentage: import './percentage.libsonnet', +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/stat/percentage.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/stat/percentage.libsonnet new file mode 100644 index 0000000000..a8a8d90977 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/stat/percentage.libsonnet @@ -0,0 +1,24 @@ +local g = import '../../../g.libsonnet'; +local stat = g.panel.stat; +local base = import './base.libsonnet'; +// This panel can be used to display gauge metrics with possible values range 0-100%. +// Examples: cpu utilization, memory utilization etc. +base { + + stylize(allLayers=true): + (if allLayers then super.stylize() else {}) + + stat.standardOptions.withDecimals(1) + + stat.standardOptions.withUnit('percent') + + stat.options.withColorMode('value') + // Change color from blue(cold) to red(hot) + + stat.standardOptions.color.withMode('continuous-BlYlRd') + + stat.standardOptions.withMax(100) + + stat.standardOptions.withMin(0) + // Show last value by default, not mean. + + stat.options.withReduceOptions({}) + + stat.options.reduceOptions.withCalcsMixin( + [ + 'lastNotNull', + ] + ), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/statusHistory/base.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/statusHistory/base.libsonnet new file mode 100644 index 0000000000..bbc7b02921 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/statusHistory/base.libsonnet @@ -0,0 +1,18 @@ +local g = import '../../../g.libsonnet'; +local base = import '../base.libsonnet'; +local statusHistory = g.panel.statusHistory; +local fieldOverride = g.panel.statusHistory.fieldOverride; +local custom = statusHistory.fieldConfig.defaults.custom; +local defaults = statusHistory.fieldConfig.defaults; +local options = statusHistory.options; +base { + + new(title, targets, description=''): + statusHistory.new(title) + + super.new(targets, description) + // Minimize number of points to avoid 'Too many data points' error on large time intervals + + statusHistory.queryOptions.withMaxDataPoints(50), + + stylize(allLayers=true): + (if allLayers then super.stylize() else {}), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/statusHistory/main.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/statusHistory/main.libsonnet new file mode 100644 index 0000000000..3b77b583c8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/statusHistory/main.libsonnet @@ -0,0 +1,3 @@ +{ + base: import './base.libsonnet', +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/table/base.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/table/base.libsonnet new file mode 100644 index 0000000000..1575b50200 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/table/base.libsonnet @@ -0,0 +1,33 @@ +local g = import '../../../g.libsonnet'; + +local table = g.panel.table; +local fieldOverride = g.panel.table.fieldOverride; +local custom = table.fieldConfig.defaults.custom; +local defaults = table.fieldConfig.defaults; +local options = table.options; +local base = import '../base.libsonnet'; + +base { + new(title, targets, description=''): + table.new(title) + + super.new(targets, description), + + stylize(allLayers=true): + (if allLayers then super.stylize() else {}), + + transformations+: { + sortBy(field, desc=false): + { + id: 'sortBy', + options: { + fields: {}, + sort: [ + { + field: field, + desc: desc, + }, + ], + }, + }, + }, +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/table/main.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/table/main.libsonnet new file mode 100644 index 0000000000..3b77b583c8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/table/main.libsonnet @@ -0,0 +1,3 @@ +{ + base: import './base.libsonnet', +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/timeSeries/base.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/timeSeries/base.libsonnet new file mode 100644 index 0000000000..6277d2b728 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/timeSeries/base.libsonnet @@ -0,0 +1,33 @@ +local g = import '../../../g.libsonnet'; + +local timeSeries = g.panel.timeSeries; +local fieldOverride = g.panel.timeSeries.fieldOverride; +local custom = timeSeries.fieldConfig.defaults.custom; +local defaults = timeSeries.fieldConfig.defaults; +local options = timeSeries.options; +local base = import '../base.libsonnet'; +base { + new(title, targets, description=''): + timeSeries.new(title) + + super.new(targets, description), + + stylize(allLayers=true): + (if allLayers then super.stylize() else {}) + // Style choice: Make lines more thick + + custom.withLineWidth(2) + // Style choice: Opacity level + + custom.withFillOpacity(30) + // Style choice: Don't show points on lines + + custom.withShowPoints('never') + // Style choice: Opacity gradient + + custom.withGradientMode('opacity') + // Style choice: Smoother lines + + custom.withLineInterpolation('smooth') + // Style choice: Show all values in tooltip, sorted + + options.tooltip.withMode('multi') + + options.tooltip.withSort('desc') + // Style choice: Use simple legend without any values (cleaner look) + + options.legend.withDisplayMode('list') + + options.legend.withCalcs([]), + +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/timeSeries/main.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/timeSeries/main.libsonnet new file mode 100644 index 0000000000..92804486eb --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/timeSeries/main.libsonnet @@ -0,0 +1,6 @@ +{ + base: import './base.libsonnet', + percentage: import './percentage.libsonnet', + threshold: import './threshold.libsonnet', + topkPercentage: import './topk_percentage.libsonnet', +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/timeSeries/percentage.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/timeSeries/percentage.libsonnet new file mode 100644 index 0000000000..3a538bef68 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/timeSeries/percentage.libsonnet @@ -0,0 +1,16 @@ +local g = import '../../../g.libsonnet'; +local timeSeries = g.panel.timeSeries; +local base = import './base.libsonnet'; +// This panel can be used to display gauge metrics with possible values range 0-100%. +// Examples: cpu utilization, memory utilization etc. +base { + stylize(allLayers=true): + (if allLayers then super.stylize() else {}) + + timeSeries.standardOptions.withDecimals(1) + + timeSeries.standardOptions.withUnit('percent') + // Change color from blue(cold) to red(hot) + + timeSeries.standardOptions.color.withMode('continuous-BlYlRd') + + timeSeries.fieldConfig.defaults.custom.withGradientMode('scheme') + + timeSeries.standardOptions.withMax(100) + + timeSeries.standardOptions.withMin(0), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/timeSeries/threshold.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/timeSeries/threshold.libsonnet new file mode 100644 index 0000000000..2914965498 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/timeSeries/threshold.libsonnet @@ -0,0 +1,25 @@ +local g = import '../../../g.libsonnet'; +local timeSeries = g.panel.timeSeries; +local fieldOverride = g.panel.timeSeries.fieldOverride; +local fieldConfig = g.panel.timeSeries.fieldConfig; + +// Turns any series to threshold line: dashed red line without gradient fill +{ + local this = self, + + stylize(): + fieldConfig.defaults.custom.withLineStyleMixin( + { + fill: 'dash', + dash: [10, 10], + } + ) + + fieldConfig.defaults.custom.withFillOpacity(0) + + timeSeries.standardOptions.color.withMode('fixed') + + timeSeries.standardOptions.color.withFixedColor('light-orange'), + stylizeByRegexp(regexp): + timeSeries.standardOptions.withOverrides( + fieldOverride.byRegexp.new(regexp) + + fieldOverride.byRegexp.withPropertiesFromOptions(this.stylize()) + ), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/timeSeries/topk_percentage.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/timeSeries/topk_percentage.libsonnet new file mode 100644 index 0000000000..cbd0edb85f --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/generic/timeSeries/topk_percentage.libsonnet @@ -0,0 +1,63 @@ +local g = import '../../../g.libsonnet'; +local base = import './base.libsonnet'; +local generic = import './main.libsonnet'; +local timeSeries = g.panel.timeSeries; +local fieldOverride = g.panel.timeSeries.fieldOverride; +local fieldConfig = g.panel.timeSeries.fieldConfig; +local standardOptions = g.panel.timeSeries.standardOptions; +// Style to display Top K metrics that can go from 0 to 100%. +// It constructs mean baseline automatically. +base { + new( + title, + target, + topk=25, + instanceLabels, + drillDownDashboardUid, + description='Top %s' % topk + ): + + local topTarget = target + { expr: 'topk(' + topk + ',' + target.expr + ')' } + + g.query.prometheus.withLegendFormat( + std.join(': ', std.map(function(l) '{{' + l + '}}', instanceLabels)) + ); + local meanTarget = target + { expr: 'avg(' + target.expr + ')' } + + g.query.prometheus.withLegendFormat('Mean'); + super.new(title, targets=[topTarget, meanTarget], description=description) + + self.withDataLink(instanceLabels, drillDownDashboardUid), + withDataLink(instanceLabels, drillDownDashboardUid): + standardOptions.withLinks( + { + url: 'd/' + drillDownDashboardUid + '?' + std.join('&', std.map(function(l) 'var-%s=${__field.labels.%s}' % [l, l], instanceLabels)) + '&${__url_time_range}', + title: 'Drill down to this instance', + } + ), + stylize(allLayers=true): + (if allLayers then super.stylize() else {}) + + generic.percentage.stylize(allLayers=false) + + fieldConfig.defaults.custom.withFillOpacity(1) + + fieldConfig.defaults.custom.withLineWidth(1) + + timeSeries.options.legend.withDisplayMode('table') + + timeSeries.options.legend.withPlacement('right') + + timeSeries.options.legend.withCalcsMixin([ + 'mean', + 'max', + 'lastNotNull', + ]) + + timeSeries.standardOptions.withOverrides( + fieldOverride.byName.new('Mean') + + fieldOverride.byName.withPropertiesFromOptions( + fieldConfig.defaults.custom.withLineStyleMixin( + { + fill: 'dash', + dash: [10, 10], + } + ) + + fieldConfig.defaults.custom.withFillOpacity(0) + + timeSeries.standardOptions.color.withMode('fixed') + + timeSeries.standardOptions.color.withFixedColor('light-purple'), + ) + ), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/memory/stat/base.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/memory/stat/base.libsonnet new file mode 100644 index 0000000000..587b02b91f --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/memory/stat/base.libsonnet @@ -0,0 +1,7 @@ +local g = import '../../../g.libsonnet'; +local stat = g.panel.stat; +local base = import '../../generic/stat/base.libsonnet'; + +base { + +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/memory/stat/main.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/memory/stat/main.libsonnet new file mode 100644 index 0000000000..fe214ee12b --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/memory/stat/main.libsonnet @@ -0,0 +1,5 @@ +{ + base: import './base.libsonnet', + total: import './total.libsonnet', + usage: import './usage.libsonnet', +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/memory/stat/total.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/memory/stat/total.libsonnet new file mode 100644 index 0000000000..c230e29c25 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/memory/stat/total.libsonnet @@ -0,0 +1,27 @@ +local g = import '../../../g.libsonnet'; +local generic = import '../../generic/stat/main.libsonnet'; +local base = import './base.libsonnet'; +local stat = g.panel.stat; +local fieldOverride = g.panel.stat.fieldOverride; +local custom = stat.fieldConfig.defaults.custom; +local defaults = stat.fieldConfig.defaults; +local options = stat.options; +base { + new( + title='Memory total', + targets, + description=||| + Amount of random-access memory (RAM) installed. + It represents the system's available working memory that applications and the operating system use to perform tasks. + A higher memory total generally leads to better system performance and the ability to run more demanding applications and processes simultaneously. + ||| + ): + super.new(title=title, targets=targets, description=description), + + stylize(allLayers=true): + + (if allLayers then super.stylize() else {}) + + + generic.info.stylize(allLayers=false) + + stat.standardOptions.withUnit('bytes'), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/memory/stat/usage.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/memory/stat/usage.libsonnet new file mode 100644 index 0000000000..26f7fb23e8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/memory/stat/usage.libsonnet @@ -0,0 +1,24 @@ +local g = import '../../../g.libsonnet'; +local generic = import '../../generic/stat/main.libsonnet'; +local base = import './base.libsonnet'; +local stat = g.panel.stat; +local fieldOverride = g.panel.stat.fieldOverride; +local custom = stat.fieldConfig.defaults.custom; +local defaults = stat.fieldConfig.defaults; +local options = stat.options; +base { + new( + title='Memory usage', + targets, + description='RAM (random-access memory) currently in use by the operating system and running applications, in percent.' + ): + super.new(title=title, targets=targets, description=description), + + stylize(allLayers=true): + + (if allLayers then super.stylize() else {}) + + + generic.percentage.stylize(allLayers=false) + + stat.standardOptions.withUnit('percent'), + +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/memory/timeSeries/base.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/memory/timeSeries/base.libsonnet new file mode 100644 index 0000000000..dae01c389f --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/memory/timeSeries/base.libsonnet @@ -0,0 +1,10 @@ +local g = import '../../../g.libsonnet'; +local base = import '../../generic/timeSeries/base.libsonnet'; +local timeSeries = g.panel.timeSeries; +local fieldOverride = g.panel.timeSeries.fieldOverride; +local custom = timeSeries.fieldConfig.defaults.custom; +local defaults = timeSeries.fieldConfig.defaults; +local options = timeSeries.options; +base { + +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/memory/timeSeries/main.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/memory/timeSeries/main.libsonnet new file mode 100644 index 0000000000..8a48e365d0 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/memory/timeSeries/main.libsonnet @@ -0,0 +1,5 @@ +{ + base: import './base.libsonnet', + usagePercent: import './usage_percent.libsonnet', + usageBytes: import './usage_bytes.libsonnet', +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/memory/timeSeries/usage_bytes.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/memory/timeSeries/usage_bytes.libsonnet new file mode 100644 index 0000000000..623f54b9a2 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/memory/timeSeries/usage_bytes.libsonnet @@ -0,0 +1,26 @@ +local g = import '../../../g.libsonnet'; +local generic = import '../../generic/timeSeries/main.libsonnet'; +local base = import './base.libsonnet'; +local timeSeries = g.panel.timeSeries; +local fieldOverride = g.panel.timeSeries.fieldOverride; +local custom = timeSeries.fieldConfig.defaults.custom; +local defaults = timeSeries.fieldConfig.defaults; +local options = timeSeries.options; +base { + totalRegexp:: '.*(T|t)otal.*', + new( + title='Memory usage', + targets, + description=||| + RAM (random-access memory) currently in use by the operating system and running applications, in bytes. + |||, + totalRegexp=self.totalRegexp, + ): + super.new(title=title, targets=targets, description=description), + + stylize(allLayers=true, totalRegexp=self.totalRegexp): + (if allLayers then super.stylize() else {}) + + timeSeries.standardOptions.withUnit('bytes') + + timeSeries.standardOptions.withMin(0) + + generic.threshold.stylizeByRegexp(totalRegexp), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/memory/timeSeries/usage_percent.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/memory/timeSeries/usage_percent.libsonnet new file mode 100644 index 0000000000..4f1fa51b17 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/memory/timeSeries/usage_percent.libsonnet @@ -0,0 +1,22 @@ +local g = import '../../../g.libsonnet'; +local generic = import '../../generic/timeSeries/main.libsonnet'; +local base = import './base.libsonnet'; +local timeSeries = g.panel.timeSeries; +local fieldOverride = g.panel.timeSeries.fieldOverride; +local custom = timeSeries.fieldConfig.defaults.custom; +local defaults = timeSeries.fieldConfig.defaults; +local options = timeSeries.options; +base { + new( + title='Memory usage', + targets, + description=||| + RAM (random-access memory) currently in use by the operating system and running applications, in percent. + ||| + ): + super.new(title=title, targets=targets, description=description), + + stylize(allLayers=true): + (if allLayers then super.stylize() else {}) + + generic.percentage.stylize(allLayers=false), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/network/statusHistory/base.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/network/statusHistory/base.libsonnet new file mode 100644 index 0000000000..b3823999c0 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/network/statusHistory/base.libsonnet @@ -0,0 +1,5 @@ +local g = import '../../../g.libsonnet'; +local base = import '../../generic/statusHistory/base.libsonnet'; +base { + +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/network/statusHistory/interface_status.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/network/statusHistory/interface_status.libsonnet new file mode 100644 index 0000000000..78ae916065 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/network/statusHistory/interface_status.libsonnet @@ -0,0 +1,29 @@ +local g = import '../../../g.libsonnet'; +local base = import './base.libsonnet'; +local statusHistory = g.panel.statusHistory; +base { + new(title='Interface status', targets, description='Interfaces statuses'): + super.new(title, targets, description), + + stylize(allLayers=true): + (if allLayers then super.stylize() else {}) + + statusHistory.standardOptions.color.withMode('fixed') + + statusHistory.options.withShowValue('never') + + statusHistory.standardOptions.withMappings( + { + type: 'value', + options: { + '0': { + text: 'Down', + color: 'light-red', + index: 0, + }, + '1': { + text: 'Up', + color: 'light-green', + index: 1, + }, + }, + } + ), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/network/statusHistory/main.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/network/statusHistory/main.libsonnet new file mode 100644 index 0000000000..04d137612c --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/network/statusHistory/main.libsonnet @@ -0,0 +1,3 @@ +{ + interfaceStatus: import './interface_status.libsonnet', +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/network/timeSeries/base.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/network/timeSeries/base.libsonnet new file mode 100644 index 0000000000..e7addef294 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/network/timeSeries/base.libsonnet @@ -0,0 +1,26 @@ +local g = import '../../../g.libsonnet'; +local base = import '../../generic/timeSeries/base.libsonnet'; +local timeSeries = g.panel.timeSeries; +local fieldOverride = g.panel.timeSeries.fieldOverride; +local custom = timeSeries.fieldConfig.defaults.custom; +local defaults = timeSeries.fieldConfig.defaults; +local options = timeSeries.options; +base { + + stylize(allLayers=true): + + (if allLayers == true then super.stylize() else {}) + + + timeSeries.standardOptions.withDecimals(1) + + timeSeries.standardOptions.withUnit('pps'), + + withNegateOutPackets(regexp='/transmit|tx|out/'): + defaults.custom.withAxisLabel('out(-) | in(+)') + + defaults.custom.withAxisCenteredZero(false) + + timeSeries.standardOptions.withOverrides( + fieldOverride.byRegexp.new(regexp) + + fieldOverride.byRegexp.withPropertiesFromOptions( + defaults.custom.withTransform('negative-Y') + ) + ), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/network/timeSeries/dropped.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/network/timeSeries/dropped.libsonnet new file mode 100644 index 0000000000..22700e9cc2 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/network/timeSeries/dropped.libsonnet @@ -0,0 +1,28 @@ +local g = import '../../../g.libsonnet'; +local base = import './base.libsonnet'; +local timeSeries = g.panel.timeSeries; +local fieldOverride = g.panel.timeSeries.fieldOverride; +local custom = timeSeries.fieldConfig.defaults.custom; +local defaults = timeSeries.fieldConfig.defaults; +local options = timeSeries.options; +base { + new( + title='Dropped packets', + targets, + description=||| + Dropped packets occur when data packets traveling through a network are intentionally discarded or lost due to congestion, resource limitations, or network configuration issues. + + Common causes include network congestion, buffer overflows, QoS settings, and network errors, as corrupted or incomplete packets may be discarded by receiving devices. + + Dropped packets can impact network performance and lead to issues such as degraded voice or video quality in real-time applications. + |||, + ): + super.new(title, targets, description) + + self.stylize(), + + stylize(allLayers=true): + + (if allLayers == true then super.stylize() else {}) + + + timeSeries.standardOptions.withNoValue('No dropped packets'), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/network/timeSeries/errors.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/network/timeSeries/errors.libsonnet new file mode 100644 index 0000000000..eb7b313ef8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/network/timeSeries/errors.libsonnet @@ -0,0 +1,26 @@ +local g = import '../../../g.libsonnet'; +local base = import './base.libsonnet'; +local timeSeries = g.panel.timeSeries; +local fieldOverride = g.panel.timeSeries.fieldOverride; +local custom = timeSeries.fieldConfig.defaults.custom; +local defaults = timeSeries.fieldConfig.defaults; +local options = timeSeries.options; +base { + new( + title='Network errors', + targets, + description=||| + Network errors refer to issues that occur during the transmission of data across a network. + + These errors can result from various factors, including physical issues, jitter, collisions, noise and interference. + + Monitoring network errors is essential for diagnosing and resolving issues, as they can indicate problems with network hardware or environmental factors affecting network quality. + |||, + ): + super.new(title, targets, description) + + self.stylize(), + stylize(allLayers=true): + + (if allLayers == true then super.stylize() else {}) + + timeSeries.standardOptions.withNoValue('No errors'), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/network/timeSeries/main.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/network/timeSeries/main.libsonnet new file mode 100644 index 0000000000..42ddfd2159 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/network/timeSeries/main.libsonnet @@ -0,0 +1,8 @@ +{ + base: import './base.libsonnet', + traffic: import './traffic.libsonnet', + errors: import './errors.libsonnet', + dropped: import './dropped.libsonnet', + packets: import './packets.libsonnet', + multicast: import './multicast.libsonnet', +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/network/timeSeries/multicast.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/network/timeSeries/multicast.libsonnet new file mode 100644 index 0000000000..c817a463c5 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/network/timeSeries/multicast.libsonnet @@ -0,0 +1,15 @@ +local g = import '../../../g.libsonnet'; +local base = import './base.libsonnet'; +local timeSeries = g.panel.timeSeries; +local fieldOverride = g.panel.timeSeries.fieldOverride; +local custom = timeSeries.fieldConfig.defaults.custom; +local defaults = timeSeries.fieldConfig.defaults; +local options = timeSeries.options; +base { + new( + title='Multicast packets', + targets, + description='Packets sent from one source to multiple recipients simultaneously, allowing efficient one-to-many communication in a network.', + ): + super.new(title, targets, description), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/network/timeSeries/packets.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/network/timeSeries/packets.libsonnet new file mode 100644 index 0000000000..cc136107ff --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/network/timeSeries/packets.libsonnet @@ -0,0 +1,15 @@ +local g = import '../../../g.libsonnet'; +local base = import './base.libsonnet'; +local timeSeries = g.panel.timeSeries; +local fieldOverride = g.panel.timeSeries.fieldOverride; +local custom = timeSeries.fieldConfig.defaults.custom; +local defaults = timeSeries.fieldConfig.defaults; +local options = timeSeries.options; +base { + new( + title='Network packets', + targets, + description='Network packet count tracks the number of data packets transmitted and received over a network connection, providing insight into network activity and performance.', + ): + super.new(title, targets, description), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/network/timeSeries/traffic.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/network/timeSeries/traffic.libsonnet new file mode 100644 index 0000000000..8f87e3d01e --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/network/timeSeries/traffic.libsonnet @@ -0,0 +1,21 @@ +local g = import '../../../g.libsonnet'; +local base = import './base.libsonnet'; +local timeSeries = g.panel.timeSeries; +local fieldOverride = g.panel.timeSeries.fieldOverride; +local custom = timeSeries.fieldConfig.defaults.custom; +local defaults = timeSeries.fieldConfig.defaults; +local options = timeSeries.options; +base { + new( + title='Network traffic', + targets, + description='Network traffic (bits per sec) measures data transmitted and received.', + ): + super.new(title, targets, description) + + self.stylize(), + + stylize(allLayers=true): + + (if allLayers == true then super.stylize() else {}) + + timeSeries.standardOptions.withUnit('bps'), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/system/stat/base.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/system/stat/base.libsonnet new file mode 100644 index 0000000000..587b02b91f --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/system/stat/base.libsonnet @@ -0,0 +1,7 @@ +local g = import '../../../g.libsonnet'; +local stat = g.panel.stat; +local base = import '../../generic/stat/base.libsonnet'; + +base { + +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/system/stat/main.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/system/stat/main.libsonnet new file mode 100644 index 0000000000..d79009cf11 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/system/stat/main.libsonnet @@ -0,0 +1,3 @@ +{ + uptime: import './uptime.libsonnet', +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/system/stat/uptime.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/system/stat/uptime.libsonnet new file mode 100644 index 0000000000..d8c45ba260 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/system/stat/uptime.libsonnet @@ -0,0 +1,33 @@ +local g = import '../../../g.libsonnet'; +local generic = import '../../generic/stat/main.libsonnet'; +local base = import './base.libsonnet'; +local stat = g.panel.stat; +// Uptime panel. expects duration in seconds as input +base { + new(title='Uptime', targets, description='The duration of time that has passed since the last reboot or system start.'): + super.new(title, targets, description) + + stat.options.withReduceOptions({}) + + stat.options.reduceOptions.withCalcsMixin( + [ + 'lastNotNull', + ] + ) + + self.stylize(), + stylize(allLayers=true): + (if allLayers then super.stylize() else {}) + + stat.standardOptions.withDecimals(1) + + stat.standardOptions.withUnit('dtdurations') + + stat.options.withColorMode('value') + + stat.options.withGraphMode('none') + + stat.standardOptions.thresholds.withMode('absolute') + + stat.standardOptions.thresholds.withSteps( + [ + // Warn with orange color when uptime resets: + stat.thresholdStep.withColor('orange') + + stat.thresholdStep.withValue(null), + // clear color after 10 minutes: + stat.thresholdStep.withColor('text') + + stat.thresholdStep.withValue(600), + ] + ), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/system/statusHistory/base.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/system/statusHistory/base.libsonnet new file mode 100644 index 0000000000..b3823999c0 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/system/statusHistory/base.libsonnet @@ -0,0 +1,5 @@ +local g = import '../../../g.libsonnet'; +local base = import '../../generic/statusHistory/base.libsonnet'; +base { + +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/system/statusHistory/main.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/system/statusHistory/main.libsonnet new file mode 100644 index 0000000000..0cc0937beb --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/system/statusHistory/main.libsonnet @@ -0,0 +1,3 @@ +{ + ntp: import './ntp.libsonnet', +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/system/statusHistory/ntp.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/system/statusHistory/ntp.libsonnet new file mode 100644 index 0000000000..42d1c23ba0 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/system/statusHistory/ntp.libsonnet @@ -0,0 +1,28 @@ +local g = import '../../../g.libsonnet'; +local base = import './base.libsonnet'; +local statusHistory = g.panel.statusHistory; +base { + new(title='NTP status', targets, description=''): + super.new(title, targets, description), + + stylize(allLayers=true): + (if allLayers then super.stylize() else {}) + + statusHistory.standardOptions.color.withMode('fixed') + + statusHistory.standardOptions.withMappings( + { + type: 'value', + options: { + '0': { + text: 'Not in sync', + color: 'light-yellow', + index: 1, + }, + '1': { + text: 'In sync', + color: 'light-green', + index: 0, + }, + }, + } + ), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/system/table/base.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/system/table/base.libsonnet new file mode 100644 index 0000000000..c120e15def --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/system/table/base.libsonnet @@ -0,0 +1,9 @@ +local g = import '../../../g.libsonnet'; +local base = import '../../generic/table/base.libsonnet'; +local table = g.panel.table; +local fieldOverride = g.panel.table.fieldOverride; +local custom = table.fieldConfig.defaults.custom; +local defaults = table.fieldConfig.defaults; +local options = table.options; +base { +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/system/table/main.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/system/table/main.libsonnet new file mode 100644 index 0000000000..aa2ce04ffc --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/system/table/main.libsonnet @@ -0,0 +1,4 @@ +{ + base: import './base.libsonnet', + uptime: import './uptime.libsonnet', +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/system/table/uptime.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/system/table/uptime.libsonnet new file mode 100644 index 0000000000..31b714e07d --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/system/table/uptime.libsonnet @@ -0,0 +1,20 @@ +local g = import '../../../g.libsonnet'; +local uptime = import '../stat/uptime.libsonnet'; +local base = import './base.libsonnet'; +local table = g.panel.table; +local fieldOverride = table.fieldOverride; + +base { + local this = self, + + new(): error 'not supported', + stylize(): error 'not supported', + + // when attached to table, this function applies style to row named 'name="Uptime"' + stylizeByName(name='Uptime'): + table.standardOptions.withOverrides( + fieldOverride.byName.new(name) + + fieldOverride.byName.withProperty('custom.cellOptions', { type: 'color-text' }) + + fieldOverride.byName.withPropertiesFromOptions(uptime.stylize(allLayers=false),) + ), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/system/timeSeries/base.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/system/timeSeries/base.libsonnet new file mode 100644 index 0000000000..dae01c389f --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/system/timeSeries/base.libsonnet @@ -0,0 +1,10 @@ +local g = import '../../../g.libsonnet'; +local base = import '../../generic/timeSeries/base.libsonnet'; +local timeSeries = g.panel.timeSeries; +local fieldOverride = g.panel.timeSeries.fieldOverride; +local custom = timeSeries.fieldConfig.defaults.custom; +local defaults = timeSeries.fieldConfig.defaults; +local options = timeSeries.options; +base { + +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/system/timeSeries/load_average.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/system/timeSeries/load_average.libsonnet new file mode 100644 index 0000000000..d707a52f83 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/system/timeSeries/load_average.libsonnet @@ -0,0 +1,41 @@ +local g = import '../../../g.libsonnet'; +local generic = import '../../generic/timeSeries/main.libsonnet'; +local base = import './base.libsonnet'; +base { + + new( + title='Load average', + loadTargets, + cpuCountTarget, + description=||| + System load average over the previous 1, 5, and 15 minute ranges. + + A measurement of how many processes are waiting for CPU cycles. The maximum number is the number of CPU cores for the node. + ||| + ): + // validate inputs + std.prune( + { + checks: [ + if !(std.objectHas(cpuCountTarget, 'legendFormat')) then error 'cpuCountTarget must have legendFormat"', + ], + } + ) + + + local targets = loadTargets + [cpuCountTarget]; + super.new(title, targets, description) + // call directly threshold styler (not called from super automatically) + + self.stylizeCpuCores(cpuCountTarget.legendFormat), + + stylizeCpuCores(cpuCountName): + generic.threshold.stylizeByRegexp(cpuCountName), + + stylize(allLayers=true, cpuCountName=null): + (if allLayers then super.stylize() else {}) + + + g.panel.timeSeries.fieldConfig.defaults.custom.withFillOpacity(0) + + g.panel.timeSeries.standardOptions.withMin(0) + + g.panel.timeSeries.standardOptions.withUnit('short') + // this is only called if cpuCountName provided + + (if cpuCountName != null then self.stylizeCpuCores(cpuCountName) else {}), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/system/timeSeries/main.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/system/timeSeries/main.libsonnet new file mode 100644 index 0000000000..d3e3b69f5a --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/panels/system/timeSeries/main.libsonnet @@ -0,0 +1,4 @@ +{ + base: import './base.libsonnet', + loadAverage: import './load_average.libsonnet', +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/utils.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/utils.libsonnet new file mode 100644 index 0000000000..7c78f318ee --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/common/utils.libsonnet @@ -0,0 +1,41 @@ +{ + local this = self, + + labelsToURLvars(labels, prefix):: + std.join('&', ['var-%s=${%s%s}' % [label, prefix, label] for label in labels]), + + // For PromQL or LogQL + labelsToPromQLSelector(labels): std.join(',', ['%s=~"$%s"' % [label, label] for label in labels]), + labelsToLogQLSelector: self.labelsToPromQLSelector, + + labelsToPanelLegend(labels): std.join('/', ['{{%s}}' % [label] for label in labels]), + + toSentenceCase(string):: + std.asciiUpper(string[0]) + std.slice(string, 1, std.length(string), 1), + + // Generate a chain of labels. Useful to create chained variables: + chainLabels(labels, additionalFilters=[]): + local last(arr) = std.reverse(arr)[0]; + local chainSelector(chain) = + std.join( + ',', + additionalFilters + + (if std.length(chain) > 0 + then [this.labelsToPromQLSelector(chain)] + else []) + ); + std.foldl( + function(prev, label) + prev + + [{ + label: label, + chainSelector: chainSelector(self.chain), + chain:: + if std.length(prev) > 0 + then last(prev).chain + [last(prev).label] + else [], + }], + labels, + [] + ), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/jsonnetfile.json b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/jsonnetfile.json new file mode 100644 index 0000000000..115d14345b --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/common-lib/jsonnetfile.json @@ -0,0 +1,15 @@ +{ + "version": 1, + "dependencies": [ + { + "source": { + "git": { + "remote": "https://github.com/grafana/grafonnet.git", + "subdir": "gen/grafonnet-v10.0.0" + } + }, + "version": "main" + } + ], + "legacyImports": true +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/logs-lib/Makefile b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/logs-lib/Makefile new file mode 100644 index 0000000000..a5076be3f1 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/logs-lib/Makefile @@ -0,0 +1,31 @@ +JSONNET_FMT := jsonnetfmt -n 2 --max-blank-lines 1 --string-style s --comment-style s + +.PHONY: all +all: build dashboards_out + +vendor: jsonnetfile.json + jb install + +.PHONY: build +build: vendor + +.PHONY: fmt +fmt: + find . -name 'vendor' -prune -o -name '*.libsonnet' -print -o -name '*.jsonnet' -print | \ + xargs -n 1 -- $(JSONNET_FMT) -i + +.PHONY: lint +lint: build + find . -name 'vendor' -prune -o -name '*.libsonnet' -print -o -name '*.jsonnet' -print | \ + while read f; do \ + $(JSONNET_FMT) "$$f" | diff -u "$$f" -; \ + done + mixtool lint mixin.libsonnet + +dashboards_out: mixin.libsonnet $(wildcard dashboards/*) + @mkdir -p dashboards_out + mixtool generate dashboards -J lib -J vendor mixin.libsonnet -d dashboards_out + +.PHONY: clean +clean: + rm -rf dashboards_out prometheus_alerts.yaml diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/logs-lib/README.md b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/logs-lib/README.md new file mode 100644 index 0000000000..fd39f200d4 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/logs-lib/README.md @@ -0,0 +1,126 @@ +# Logs lib + +This logs lib can be used to generate logs dashboard using [grafonnet](https://github.com/grafana/grafonnet). + +## Import + +```sh +jb init +jb install https://github.com/grafana/jsonnet-libs/logs-lib +``` + +## Examples + +### Generate kubernetes logs dashboard + +```jsonnet +local logslib = import 'github.com/grafana/jsonnet-libs/logs-lib/logs/main.libsonnet'; + +//Additional selector to add to all variable queries and alerts(if any) +local kubeFilterSelector = 'namespace!=""'; +// Array of labels to compose chained grafana variables (order matters) +local kubeLabels = ['cluster', 'namespace', 'app', 'pod', 'container']; + +// pick one of Loki's parsers to use: i.e. logfmt, json. +// | __error__=`` is appended automatically +// https://grafana.com/docs/loki/latest/logql/log_queries/#parser-expression +// set null or do not provide at all if parsing is not required. +local formatParser = 'logfmt'; + +//group by 'app' label instead of 'level': +local logsVolumeGroupBy = 'app'; + +//extra filters to do advanced line_format: +local extraFilters = ||| + | label_format timestamp="{{__timestamp__}}" + | line_format `{{ if eq "[[pod]]" ".*" }}{{.pod | trunc 20}}:{{else}}{{.container}}:{{end}} {{__line__}}` +|||; + +( + logsDashboard.new('Kubernetes apps logs', + datasourceRegex='', + filterSelector=kubeFilterSelector, + labels=kubeLabels, + formatParser=formatParser, + logsVolumeGroupBy=logsVolumeGroupBy, + extraFilters=extraFilters) +).dashboards.logs +``` + +![image](https://github.com/grafana/jsonnet-libs/assets/14870891/7b246cc9-5de1-42f5-b3cd-bb9f89302405) + +### Generate systemd logs dashboard and modify panels and variables + +This lib exposes `variables`, `targets`, `panels`, and `dashboards`. + +Because of that, you can override options of those objects before exporting the dashboard. + +Again, use [Grafonnet](https://grafana.github.io/grafonnet/API/panel/index.html) for this: + +```jsonnet +local g = import 'github.com/grafana/grafonnet/gen/grafonnet-latest/main.libsonnet'; +local logslib = import 'github.com/grafana/jsonnet-libs/logs-lib/logs/main.libsonnet'; + + +local linuxFilterSelector = 'unit!=""'; +local linuxLabels = ['job', 'instance', 'unit', 'level']; + +// pick one of Loki's parsers to use: i.e. logfmt, json. +// | __error__=`` is appended automatically +// https://grafana.com/docs/loki/latest/logql/log_queries/#parser-expression +// set null or do not provide at all if parsing is not required. +local formatParser = 'unpack'; + +// 2. create and export systemd logs dashboard +local systemdLogs = + logslib.new('Linux systemd logs', + datasourceRegex='', + filterSelector=linuxFilterSelector, + labels=linuxLabels, + formatParser=formatParser, + showLogsVolume=true) + // override panels or variables using grafonnet + { + panels+: + { + logs+: + g.panel.logs.options.withEnableLogDetails(false), + }, + variables+: + { + regex_search+: + g.dashboard.variable.textbox.new('regex_search', default='error'), + }, + }; +// export logs dashboard +systemdLogs.dashboards.logs + +``` + +![image](https://github.com/grafana/jsonnet-libs/assets/14870891/5e6313fd-9135-446a-b7bf-cf124b436970) + +### Generate docker logs dashboard + +```jsonnet + +local logslib = import 'github.com/grafana/jsonnet-libs/logs-lib/logs/main.libsonnet'; + +// Array of labels to compose chained grafana variables +local dockerFilterSelector = 'container_name!=""'; +local dockerLabels = ['job', 'instance', 'container_name']; + +// pick one of Loki's parsers to use: i.e. logfmt, json. +// | __error__=`` is appended automatically +// https://grafana.com/docs/loki/latest/logql/log_queries/#parser-expression +// set null or do not provide at all if parsing is not required. +local formatParser = 'logfmt'; + +( + logslib.new('Docker logs', + datasourceRegex='', + filterSelector=dockerFilterSelector, + labels=dockerLabels, + formatParser=formatParser) +).dashboards.logs + +``` diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/logs-lib/jsonnetfile.json b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/logs-lib/jsonnetfile.json new file mode 100644 index 0000000000..115d14345b --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/logs-lib/jsonnetfile.json @@ -0,0 +1,15 @@ +{ + "version": 1, + "dependencies": [ + { + "source": { + "git": { + "remote": "https://github.com/grafana/grafonnet.git", + "subdir": "gen/grafonnet-v10.0.0" + } + }, + "version": "main" + } + ], + "legacyImports": true +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/logs-lib/logs/dashboards.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/logs-lib/logs/dashboards.libsonnet new file mode 100644 index 0000000000..f721f3a643 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/logs-lib/logs/dashboards.libsonnet @@ -0,0 +1,30 @@ +local g = import './g.libsonnet'; + +function( + title, + showLogsVolume, + panels, + variables, +) + { + local this = self, + logs: + g.dashboard.new(title) + + g.dashboard.withUid(g.util.string.slugify(title)) + + g.dashboard.withVariables(variables.toArray) + + g.dashboard.withPanels( + ( + if showLogsVolume then + [panels.logsVolume + + g.panel.timeSeries.gridPos.withH(6) + + g.panel.timeSeries.gridPos.withW(24)] + else [] + ) + + + [ + panels.logs + + g.panel.logs.gridPos.withH(18) + + g.panel.logs.gridPos.withW(24), + ] + ), + } diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/logs-lib/logs/g.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/logs-lib/logs/g.libsonnet new file mode 100644 index 0000000000..6da9f4eef9 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/logs-lib/logs/g.libsonnet @@ -0,0 +1 @@ +import 'github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/main.libsonnet' diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/logs-lib/logs/main.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/logs-lib/logs/main.libsonnet new file mode 100644 index 0000000000..6b80ee4f0a --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/logs-lib/logs/main.libsonnet @@ -0,0 +1,51 @@ +local dashboards = import './dashboards.libsonnet'; +local g = import './g.libsonnet'; +local panels = import './panels.libsonnet'; +local targets = import './targets.libsonnet'; +local variables = import './variables.libsonnet'; + +{ + new( + title, + filterSelector, + labels, + datasourceRegex, + datasourceName='loki_datasource', + datasourceLabel='Loki data source', + formatParser=null, + showLogsVolume=true, + logsVolumeGroupBy='level', + extraFilters='', + ): { + + local this = self, + variables: variables( + datasourceName, + datasourceLabel, + datasourceRegex, + filterSelector, + labels, + ), + + targets: targets( + this.variables, + formatParser, + logsVolumeGroupBy, + extraFilters, + ), + + panels: panels( + this.targets.logsVolumeTarget, + this.targets.logsTarget, + logsVolumeGroupBy, + ), + + dashboards: dashboards( + title, + showLogsVolume, + this.panels, + this.variables, + ), + }, + +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/logs-lib/logs/panels.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/logs-lib/logs/panels.libsonnet new file mode 100644 index 0000000000..9f3a0b1b86 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/logs-lib/logs/panels.libsonnet @@ -0,0 +1,86 @@ +local g = import './g.libsonnet'; + +local timeSeries = g.panel.timeSeries; +local logsPanel = g.panel.logs; +local defaults = timeSeries.fieldConfig.defaults; +local custom = timeSeries.fieldConfig.defaults.custom; +local options = timeSeries.options; +local fieldConfig = timeSeries.fieldConfig; +function( + logsVolumeTarget, + logsTarget, + logsVolumeGroupBy, +) + + { + local this = self, + + logsVolumeInit(targets, title='Logs volume'):: + timeSeries.new(title) + + timeSeries.queryOptions.withTargets(targets) + + timeSeries.panelOptions.withDescription('Logs volume grouped by "%s" label.' % logsVolumeGroupBy) + // set type to first target's type + + timeSeries.queryOptions.withDatasource( + logsVolumeTarget.datasource.type, logsVolumeTarget.datasource.uid + ) + + custom.withDrawStyle('bars') + + custom.stacking.withMode('normal') + + custom.withFillOpacity(50) + // should be set, otherwise interval is around 1s by default + + timeSeries.queryOptions.withInterval('30s') + + options.tooltip.withMode('multi') + + options.tooltip.withSort('desc') + + timeSeries.standardOptions.withUnit('none') + + timeSeries.queryOptions.withTransformationsMixin( + { + id: 'renameByRegex', + options: { + regex: 'Value', + renamePattern: 'logs', + }, + } + ) + + timeSeries.standardOptions.withOverridesMixin( + [ + { + matcher: { + id: 'byRegexp', + options: o.regex, + }, + properties: [ + { + id: 'color', + value: { + mode: 'fixed', + fixedColor: o.color, + }, + }, + ], + } + // https://grafana.com/docs/grafana/latest/explore/logs-integration/#log-level + for o in + [ + { regex: '(E|e)merg|(F|f)atal|(A|a)lert|(C|c)rit.*', color: 'purple' }, + { regex: '(E|e)(rr.*|RR.*)', color: 'red' }, + { regex: '(W|w)(arn.*|ARN.*|rn|RN)', color: 'orange' }, + { regex: '(N|n)(otice|ote)|(I|i)(nf.*|NF.*)', color: 'green' }, + { regex: 'dbg.*|DBG.*|(D|d)(EBUG|ebug)', color: 'blue' }, + { regex: '(T|t)(race|RACE)', color: 'light-blue' }, + { regex: 'logs', color: 'text' }, + ] + ] + ), + + logsInit(targets, title='Logs'):: + logsPanel.new(title) + + logsPanel.queryOptions.withTargets(targets) + + logsPanel.options.withDedupStrategy('exact') //"none", "exact", "numbers", "signature" + + logsPanel.options.withEnableLogDetails(true) + + logsPanel.options.withShowTime(true) + + logsPanel.options.withWrapLogMessage(true) + + logsPanel.options.withPrettifyLogMessage(true), + + logsVolume: self.logsVolumeInit(logsVolumeTarget), + logs: self.logsInit(logsTarget), + + } diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/logs-lib/logs/targets.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/logs-lib/logs/targets.libsonnet new file mode 100644 index 0000000000..4be78130e6 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/logs-lib/logs/targets.libsonnet @@ -0,0 +1,41 @@ +local utils = import '../utils.libsonnet'; +local g = import './g.libsonnet'; +local lokiQuery = g.query.loki; +function( + variables, + formatParser, + logsVolumeGroupBy, + extraFilters, +) { + formatParser:: if formatParser != null then '| %s | __error__=``' % formatParser else '', + logsTarget:: + lokiQuery.new( + datasource='${' + variables.datasource.name + '}', + expr=||| + {%s} + |~ "$regex_search" + %s + %s + ||| % [ + variables.queriesSelector, + self.formatParser, + extraFilters, + ] + ), + + logsVolumeTarget:: + lokiQuery.new( + datasource='${' + variables.datasource.name + '}', + expr=||| + sum by (%s) (count_over_time({%s} + |~ "$regex_search" + %s + [$__interval])) + ||| % [ + logsVolumeGroupBy, + variables.queriesSelector, + self.formatParser, + ] + ) + + lokiQuery.withLegendFormat('{{ %s }}' % logsVolumeGroupBy), +} diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/logs-lib/logs/variables.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/logs-lib/logs/variables.libsonnet new file mode 100644 index 0000000000..1f362c4e17 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/logs-lib/logs/variables.libsonnet @@ -0,0 +1,59 @@ +local utils = import '../utils.libsonnet'; +local g = import './g.libsonnet'; +local var = g.dashboard.variable; +function( + datasourceName, + datasourceLabel, + datasourceRegex, + filterSelector, + labels, +) + { + local this = self, + local variablesFromLabels(labels, filterSelector) = + local chainVarProto(chainVar) = + var.query.new(chainVar.label) + + var.query.withDatasourceFromVariable(this.datasource) + + var.query.generalOptions.withLabel(utils.toSentenceCase(chainVar.label)) + + var.query.queryTypes.withLabelValues( + chainVar.label, + '{%s}' % chainVar.chainSelector, + ) + + var.query.selectionOptions.withIncludeAll( + value=true, + customAllValue='.*' + ) + + var.query.selectionOptions.withMulti() + + var.query.refresh.onTime() + + var.query.withSort( + i=1, + type='alphabetical', + asc=true, + caseInsensitive=false + ) + ; + [ + chainVarProto(chainVar) + for chainVar in utils.chainLabels(labels, [filterSelector]) + ], + + datasource: + var.datasource.new(datasourceName, 'loki') + + var.datasource.withRegex(datasourceRegex) + + var.query.generalOptions.withLabel(datasourceLabel), + + regex_search: + var.textbox.new('regex_search', default='') + + var.query.generalOptions.withLabel('Regex search'), + + toArray: + [self.datasource] + + variablesFromLabels(labels, filterSelector) + + [self.regex_search], + + queriesSelector: + '%s,%s' % [ + filterSelector, + utils.labelsToPromQLSelector(labels), + ], + } diff --git a/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/logs-lib/utils.libsonnet b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/logs-lib/utils.libsonnet new file mode 100644 index 0000000000..7d0a60a3a4 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/grafana/jsonnet-libs/logs-lib/utils.libsonnet @@ -0,0 +1,41 @@ +{ + local this = self, + + labelsToURLvars(labels, prefix):: + std.join('&', ['var-%s=${%s%s}' % [label, prefix, label] for label in labels]), + + // For PromQL or LogQL + labelsToPromQLSelector(labels): std.join(',', ['%s=~"$%s"' % [label, label] for label in labels]), + labelsToLogQLSelector: self.labelsToPromQLSelector, + + labelsToPanelLegend(labels): std.join('/', ['{{%s}}' % [label] for label in labels]), + + toSentenceCase(string):: + std.asciiUpper(string[0]) + std.slice(string, 1, std.length(string), 1), + + // Generate a chain of labels. Useful to create chained variables + chainLabels(labels, additionalFilters=[]): + local last(arr) = std.reverse(arr)[0]; + local chainSelector(chain) = + std.join( + ',', + additionalFilters + + (if std.length(chain) > 0 + then [this.labelsToPromQLSelector(chain)] + else []) + ); + std.foldl( + function(prev, label) + prev + + [{ + label: label, + chainSelector: chainSelector(self.chain), + chain:: + if std.length(prev) > 0 + then last(prev).chain + [last(prev).label] + else [], + }], + labels, + [] + ), +} diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/docsonnet/doc-util/README.md b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/docsonnet/doc-util/README.md new file mode 100644 index 0000000000..c6777425cf --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/docsonnet/doc-util/README.md @@ -0,0 +1,326 @@ +# doc-util + +`doc-util` provides a Jsonnet interface for `docsonnet`, + a Jsonnet API doc generator that uses structured data instead of comments. + +## Install + +``` +jb install github.com/jsonnet-libs/docsonnet/doc-util@master +``` + +## Usage + +```jsonnet +local d = import "github.com/jsonnet-libs/docsonnet/doc-util/main.libsonnet" +``` + + +## Index + +* [`fn arg(name, type, default, enums)`](#fn-arg) +* [`fn fn(help, args)`](#fn-fn) +* [`fn obj(help, fields)`](#fn-obj) +* [`fn pkg(name, url, help, filename="", version="master")`](#fn-pkg) +* [`fn render(obj)`](#fn-render) +* [`fn val(type, help, default)`](#fn-val) +* [`obj argument`](#obj-argument) + * [`fn fromSchema(name, schema)`](#fn-argumentfromschema) + * [`fn new(name, type, default, enums)`](#fn-argumentnew) +* [`obj func`](#obj-func) + * [`fn new(help, args)`](#fn-funcnew) + * [`fn withArgs(args)`](#fn-funcwithargs) + * [`fn withHelp(help)`](#fn-funcwithhelp) +* [`obj object`](#obj-object) + * [`fn new(help, fields)`](#fn-objectnew) + * [`fn withFields(fields)`](#fn-objectwithfields) +* [`obj value`](#obj-value) + * [`fn new(type, help, default)`](#fn-valuenew) +* [`obj T`](#obj-t) +* [`obj package`](#obj-package) + * [`fn new(name, url, help, filename="", version="master")`](#fn-packagenew) + * [`fn newSub(name, help)`](#fn-packagenewsub) + +## Fields + +### fn arg + +```jsonnet +arg(name, type, default, enums) +``` + +PARAMETERS: + +* **name** (`string`) +* **type** (`string`) +* **default** (`any`) +* **enums** (`array`) + +`arg` is a shorthand for `argument.new` +### fn fn + +```jsonnet +fn(help, args) +``` + +PARAMETERS: + +* **help** (`string`) +* **args** (`array`) + +`fn` is a shorthand for `func.new` +### fn obj + +```jsonnet +obj(help, fields) +``` + +PARAMETERS: + +* **help** (`string`) +* **fields** (`object`) + +`obj` is a shorthand for `object.new` +### fn pkg + +```jsonnet +pkg(name, url, help, filename="", version="master") +``` + +PARAMETERS: + +* **name** (`string`) +* **url** (`string`) +* **help** (`string`) +* **filename** (`string`) + - default value: `""` +* **version** (`string`) + - default value: `"master"` + +`new` is a shorthand for `package.new` +### fn render + +```jsonnet +render(obj) +``` + +PARAMETERS: + +* **obj** (`object`) + +`render` converts the docstrings to human readable Markdown files. + +Usage: + +```jsonnet +// docs.jsonnet +d.render(import 'main.libsonnet') +``` + +Call with: `jsonnet -S -c -m docs/ docs.jsonnet` + +### fn val + +```jsonnet +val(type, help, default) +``` + +PARAMETERS: + +* **type** (`string`) +* **help** (`string`) +* **default** (`any`) + +`val` is a shorthand for `value.new` +### obj argument + +Utilities for creating function arguments + +#### fn argument.fromSchema + +```jsonnet +argument.fromSchema(name, schema) +``` + +PARAMETERS: + +* **name** (`string`) +* **schema** (`object`) + +`fromSchema` creates a new function argument, taking a JSON `schema` to describe the type information for this argument. + +Examples: + +```jsonnet +[ + d.argument.fromSchema('foo', { type: 'string' }), + d.argument.fromSchema('bar', { type: 'string', default='loo' }), + d.argument.fromSchema('baz', { type: 'number', enum=[1,2,3] }), +] +``` + +#### fn argument.new + +```jsonnet +argument.new(name, type, default, enums) +``` + +PARAMETERS: + +* **name** (`string`) +* **type** (`string`) +* **default** (`any`) +* **enums** (`array`) + +`new` creates a new function argument, taking the `name`, the `type`. Optionally it +can take a `default` value and `enum`-erate potential values. + +Examples: + +```jsonnet +[ + d.argument.new('foo', d.T.string), + d.argument.new('bar', d.T.string, default='loo'), + d.argument.new('baz', d.T.number, enums=[1,2,3]), +] +``` + +### obj func + +Utilities for documenting Jsonnet methods (functions of objects) + +#### fn func.new + +```jsonnet +func.new(help, args) +``` + +PARAMETERS: + +* **help** (`string`) +* **args** (`array`) + +new creates a new function, optionally with description and arguments +#### fn func.withArgs + +```jsonnet +func.withArgs(args) +``` + +PARAMETERS: + +* **args** (`array`) + +The `withArgs` modifier overrides the arguments of that function +#### fn func.withHelp + +```jsonnet +func.withHelp(help) +``` + +PARAMETERS: + +* **help** (`string`) + +The `withHelp` modifier overrides the help text of that function +### obj object + +Utilities for documenting Jsonnet objects (`{ }`). + +#### fn object.new + +```jsonnet +object.new(help, fields) +``` + +PARAMETERS: + +* **help** (`string`) +* **fields** (`object`) + +new creates a new object, optionally with description and fields +#### fn object.withFields + +```jsonnet +object.withFields(fields) +``` + +PARAMETERS: + +* **fields** (`object`) + +The `withFields` modifier overrides the fields property of an already created object +### obj value + +Utilities for documenting plain Jsonnet values (primitives) + +#### fn value.new + +```jsonnet +value.new(type, help, default) +``` + +PARAMETERS: + +* **type** (`string`) +* **help** (`string`) +* **default** (`any`) + +new creates a new object of given type, optionally with description and default value +### obj T + +* `T.any` (`string`): `"any"` - argument of type "any" +* `T.array` (`string`): `"array"` - argument of type "array" +* `T.boolean` (`string`): `"bool"` - argument of type "boolean" +* `T.func` (`string`): `"function"` - argument of type "func" +* `T.null` (`string`): `"null"` - argument of type "null" +* `T.number` (`string`): `"number"` - argument of type "number" +* `T.object` (`string`): `"object"` - argument of type "object" +* `T.string` (`string`): `"string"` - argument of type "string" + +### obj package + + +#### fn package.new + +```jsonnet +package.new(name, url, help, filename="", version="master") +``` + +PARAMETERS: + +* **name** (`string`) +* **url** (`string`) +* **help** (`string`) +* **filename** (`string`) + - default value: `""` +* **version** (`string`) + - default value: `"master"` + +`new` creates a new package + +Arguments: + +* given `name` +* source `url` for jsonnet-bundler and the import +* `help` text +* `filename` for the import, defaults to blank for backward compatibility +* `version` for jsonnet-bundler install, defaults to `master` just like jsonnet-bundler + +#### fn package.newSub + +```jsonnet +package.newSub(name, help) +``` + +PARAMETERS: + +* **name** (`string`) +* **help** (`string`) + +`newSub` creates a package without the preconfigured install/usage templates. + +Arguments: + +* given `name` +* `help` text diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/docsonnet/doc-util/main.libsonnet b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/docsonnet/doc-util/main.libsonnet new file mode 100644 index 0000000000..f3ec298495 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/docsonnet/doc-util/main.libsonnet @@ -0,0 +1,263 @@ +{ + local d = self, + + '#': + d.pkg( + name='doc-util', + url='github.com/jsonnet-libs/docsonnet/doc-util', + help=||| + `doc-util` provides a Jsonnet interface for `docsonnet`, + a Jsonnet API doc generator that uses structured data instead of comments. + |||, + filename=std.thisFile, + ) + + d.package.withUsageTemplate( + 'local d = import "%(import)s"' + ), + + package:: { + '#new':: d.fn(||| + `new` creates a new package + + Arguments: + + * given `name` + * source `url` for jsonnet-bundler and the import + * `help` text + * `filename` for the import, defaults to blank for backward compatibility + * `version` for jsonnet-bundler install, defaults to `master` just like jsonnet-bundler + |||, [ + d.arg('name', d.T.string), + d.arg('url', d.T.string), + d.arg('help', d.T.string), + d.arg('filename', d.T.string, ''), + d.arg('version', d.T.string, 'master'), + ]), + new(name, url, help, filename='', version='master'):: + { + name: name, + help: + help + + std.get(self, 'installTemplate', '') % self + + std.get(self, 'usageTemplate', '') % self, + 'import': + if filename != '' + then url + '/' + filename + else url, + url: url, + filename: filename, + version: version, + + } + + self.withInstallTemplate( + 'jb install %(url)s@%(version)s' + ) + + self.withUsageTemplate( + 'local %(name)s = import "%(import)s"' + ), + + '#newSub':: d.fn(||| + `newSub` creates a package without the preconfigured install/usage templates. + + Arguments: + + * given `name` + * `help` text + |||, [ + d.arg('name', d.T.string), + d.arg('help', d.T.string), + ]), + newSub(name, help):: + { + name: name, + help: help, + }, + + withInstallTemplate(template):: { + installTemplate: + if template != null + then + ||| + + ## Install + + ``` + %s + ``` + ||| % template + else '', + }, + + withUsageTemplate(template):: { + usageTemplate: + if template != null + then + ||| + + ## Usage + + ```jsonnet + %s + ``` + ||| % template + else '', + }, + }, + + '#pkg':: self.package['#new'] + d.func.withHelp('`new` is a shorthand for `package.new`'), + pkg:: self.package.new, + + '#object': d.obj('Utilities for documenting Jsonnet objects (`{ }`).'), + object:: { + '#new': d.fn('new creates a new object, optionally with description and fields', [d.arg('help', d.T.string), d.arg('fields', d.T.object)]), + new(help='', fields={}):: { object: { + help: help, + fields: fields, + } }, + + '#withFields': d.fn('The `withFields` modifier overrides the fields property of an already created object', [d.arg('fields', d.T.object)]), + withFields(fields):: { object+: { + fields: fields, + } }, + }, + + '#obj': self.object['#new'] + d.func.withHelp('`obj` is a shorthand for `object.new`'), + obj:: self.object.new, + + '#func': d.obj('Utilities for documenting Jsonnet methods (functions of objects)'), + func:: { + '#new': d.fn('new creates a new function, optionally with description and arguments', [d.arg('help', d.T.string), d.arg('args', d.T.array)]), + new(help='', args=[]):: { 'function': { + help: help, + args: args, + } }, + + '#withHelp': d.fn('The `withHelp` modifier overrides the help text of that function', [d.arg('help', d.T.string)]), + withHelp(help):: { 'function'+: { + help: help, + } }, + + '#withArgs': d.fn('The `withArgs` modifier overrides the arguments of that function', [d.arg('args', d.T.array)]), + withArgs(args):: { 'function'+: { + args: args, + } }, + }, + + '#fn': self.func['#new'] + d.func.withHelp('`fn` is a shorthand for `func.new`'), + fn:: self.func.new, + + '#argument': d.obj('Utilities for creating function arguments'), + argument:: { + '#new': d.fn(||| + `new` creates a new function argument, taking the `name`, the `type`. Optionally it + can take a `default` value and `enum`-erate potential values. + + Examples: + + ```jsonnet + [ + d.argument.new('foo', d.T.string), + d.argument.new('bar', d.T.string, default='loo'), + d.argument.new('baz', d.T.number, enums=[1,2,3]), + ] + ``` + |||, [ + d.arg('name', d.T.string), + d.arg('type', d.T.string), + d.arg('default', d.T.any), + d.arg('enums', d.T.array), + ]), + new(name, type, default=null, enums=null): { + name: name, + type: type, + default: default, + enums: enums, + }, + '#fromSchema': d.fn(||| + `fromSchema` creates a new function argument, taking a JSON `schema` to describe the type information for this argument. + + Examples: + + ```jsonnet + [ + d.argument.fromSchema('foo', { type: 'string' }), + d.argument.fromSchema('bar', { type: 'string', default='loo' }), + d.argument.fromSchema('baz', { type: 'number', enum=[1,2,3] }), + ] + ``` + |||, [ + d.arg('name', d.T.string), + d.arg('schema', d.T.object), + ]), + fromSchema(name, schema): { + name: name, + schema: schema, + }, + }, + '#arg': self.argument['#new'] + self.func.withHelp('`arg` is a shorthand for `argument.new`'), + arg:: self.argument.new, + + '#value': d.obj('Utilities for documenting plain Jsonnet values (primitives)'), + value:: { + '#new': d.fn('new creates a new object of given type, optionally with description and default value', [d.arg('type', d.T.string), d.arg('help', d.T.string), d.arg('default', d.T.any)]), + new(type, help='', default=null): { value: { + help: help, + type: type, + default: default, + } }, + }, + '#val': self.value['#new'] + self.func.withHelp('`val` is a shorthand for `value.new`'), + val:: self.value.new, + + // T contains constants for the Jsonnet types + T:: { + '#string': d.val(d.T.string, 'argument of type "string"'), + string: 'string', + + '#number': d.val(d.T.string, 'argument of type "number"'), + number: 'number', + int: self.number, + integer: self.number, + + '#boolean': d.val(d.T.string, 'argument of type "boolean"'), + boolean: 'bool', + bool: self.boolean, + + '#object': d.val(d.T.string, 'argument of type "object"'), + object: 'object', + + '#array': d.val(d.T.string, 'argument of type "array"'), + array: 'array', + + '#any': d.val(d.T.string, 'argument of type "any"'), + any: 'any', + + '#null': d.val(d.T.string, 'argument of type "null"'), + 'null': 'null', + nil: self['null'], + + '#func': d.val(d.T.string, 'argument of type "func"'), + func: 'function', + 'function': self.func, + }, + + '#render': d.fn( + ||| + `render` converts the docstrings to human readable Markdown files. + + Usage: + + ```jsonnet + // docs.jsonnet + d.render(import 'main.libsonnet') + ``` + + Call with: `jsonnet -S -c -m docs/ docs.jsonnet` + |||, + args=[ + d.arg('obj', d.T.object), + ] + ), + render:: (import './render.libsonnet').render, + +} diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/docsonnet/doc-util/render.libsonnet b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/docsonnet/doc-util/render.libsonnet new file mode 100644 index 0000000000..e02c4e9ad3 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/docsonnet/doc-util/render.libsonnet @@ -0,0 +1,476 @@ +{ + local root = self, + + render(obj): + assert std.isObject(obj) && '#' in obj : 'error: object is not a docsonnet package'; + local package = self.package(obj); + package.toFiles(), + + findPackages(obj, path=[]): { + local find(obj, path, parentWasPackage=true) = + std.foldl( + function(acc, k) + acc + + ( + // If matches a package but warn if also has an object docstring + if '#' in obj[k] && '#' + k in obj + && !std.objectHasAll(obj[k]['#'], 'ignore') + then std.trace( + 'warning: %s both defined as object and package' % k, + [root.package(obj[k], path + [k], parentWasPackage)] + ) + // If matches a package, return it + else if '#' in obj[k] + && !std.objectHasAll(obj[k]['#'], 'ignore') + then [root.package(obj[k], path + [k], parentWasPackage)] + // If not, keep looking + else find(obj[k], path + [k], parentWasPackage=false) + ), + std.filter( + function(k) + !std.startsWith(k, '#') + && std.isObject(obj[k]), + std.objectFieldsAll(obj) + ), + [] + ), + + packages: find(obj, path), + + hasPackages(): std.length(self.packages) > 0, + + toIndex(relativeTo=[]): + if self.hasPackages() + then + std.join('\n', [ + '* ' + p.link(relativeTo) + for p in self.packages + ]) + + '\n' + else '', + + toFiles(): + std.foldl( + function(acc, p) + acc + + { [p.path]: p.toString() } + + p.packages.toFiles(), + self.packages, + {} + ), + }, + + package(obj, path=[], parentWasPackage=true): { + local this = self, + local doc = obj['#'], + + packages: root.findPackages(obj, path), + fields: root.fields(obj), + + local pathsuffix = + (if self.packages.hasPackages() + then '/index.md' + else '.md'), + + // filepath on disk + path: + std.join('/', path) + + pathsuffix, + + link(relativeTo): + local relativepath = root.util.getRelativePath(path, relativeTo); + '[%s](%s)' % [ + std.join('.', relativepath), + std.join('/', relativepath) + + pathsuffix, + ], + + toFiles(): + { 'README.md': this.toString() } + + self.packages.toFiles(), + + toString(): + std.join( + '\n', + [ + '# ' + doc.name + '\n', + std.get(doc, 'help', ''), + '', + ] + + (if self.packages.hasPackages() + then [ + '## Subpackages\n\n' + + self.packages.toIndex(path), + ] + else []) + + (if self.fields.hasFields() + then [ + '## Index\n\n' + + self.fields.toIndex() + + '\n## Fields\n' + + self.fields.toString(), + ] + else []) + ), + }, + + fields(obj, path=[]): { + values: root.findValues(obj, path), + functions: root.findFunctions(obj, path), + objects: root.findObjects(obj, path), + + hasFields(): + std.any([ + self.values.hasFields(), + self.functions.hasFields(), + self.objects.hasFields(), + ]), + + toIndex(): + std.join('', [ + self.functions.toIndex(), + self.objects.toIndex(), + ]), + + toString(): + std.join('', [ + self.values.toString(), + self.functions.toString(), + self.objects.toString(), + ]), + }, + + findObjects(obj, path=[]): { + local keys = + std.filter( + root.util.filter('object', obj), + std.objectFieldsAll(obj) + ), + + local undocumentedKeys = + std.filter( + function(k) + std.all([ + !std.startsWith(k, '#'), + std.isObject(obj[k]), + !std.objectHasAll(obj[k], 'ignore'), + !('#' + k in obj), // not documented in parent + !('#' in obj[k]), // not a sub package + ]), + std.objectFieldsAll(obj) + ), + + objects: + std.foldl( + function(acc, k) + acc + [ + root.obj( + root.util.realkey(k), + obj[k], + obj[root.util.realkey(k)], + path, + ), + ], + keys, + [] + ) + + std.foldl( + function(acc, k) + local o = root.obj( + k, + { object: { help: '' } }, + obj[k], + path, + ); + acc + + (if o.fields.hasFields() + then [o] + else []), + undocumentedKeys, + [] + ), + + hasFields(): std.length(self.objects) > 0, + + toIndex(): + if self.hasFields() + then + std.join('', [ + std.join( + '', + [' ' for d in std.range(0, (std.length(path) * 2) - 1)] + + ['* ', f.link] + + ['\n'] + + (if f.fields.hasFields() + then [f.fields.toIndex()] + else []) + ) + for f in self.objects + ]) + else '', + + toString(): + if self.hasFields() + then + std.join('', [ + o.toString() + for o in self.objects + ]) + else '', + }, + + obj(name, doc, obj, path): { + fields: root.fields(obj, path + [name]), + + path: std.join('.', path + [name]), + fragment: root.util.fragment(std.join('', path + [name])), + link: '[`obj %s`](#obj-%s)' % [name, self.fragment], + + toString(): + std.join( + '\n', + [root.util.title('obj ' + self.path, std.length(path) + 2)] + + (if std.get(doc.object, 'help', '') != '' + then [doc.object.help] + else []) + + [self.fields.toString()] + ), + }, + + findFunctions(obj, path=[]): { + local keys = + std.filter( + root.util.filter('function', obj), + std.objectFieldsAll(obj) + ), + + functions: + std.foldl( + function(acc, k) + acc + [ + root.func( + root.util.realkey(k), + obj[k], + path, + ), + ], + keys, + [] + ), + + hasFields(): std.length(self.functions) > 0, + + toIndex(): + if self.hasFields() + then + std.join('', [ + std.join( + '', + [' ' for d in std.range(0, (std.length(path) * 2) - 1)] + + ['* ', f.link] + + ['\n'] + ) + for f in self.functions + ]) + else '', + + toString(): + if self.hasFields() + then + std.join('', [ + f.toString() + for f in self.functions + ]) + else '', + }, + + func(name, doc, path): { + path: std.join('.', path + [name]), + fragment: root.util.fragment(std.join('', path + [name])), + link: '[`fn %s(%s)`](#fn-%s)' % [name, self.args, self.fragment], + + local getType(arg) = + local type = + if 'schema' in arg + then std.get(arg.schema, 'type', '') + else std.get(arg, 'type', ''); + if std.isArray(type) + then std.join(',', [t for t in type]) + else type, + + // Use BelRune as default can be 'null' as a value. Only supported for arg.schema, arg.default didn't support this, not sure how to support without breaking asssumptions downstream. + local BelRune = std.char(7), + local getDefault(arg) = + if 'schema' in arg + then std.get(arg.schema, 'default', BelRune) + else + local d = std.get(arg, 'default', BelRune); + if d == null + then BelRune + else d, + + local getEnum(arg) = + if 'schema' in arg + then std.get(arg.schema, 'enum', []) + else + local d = std.get(arg, 'enums', []); + if d == null + then [] + else d, + + args: + std.join(', ', [ + local default = getDefault(arg); + if default != BelRune + then std.join('=', [ + arg.name, + std.manifestJson(default), + ]) + else arg.name + for arg in doc['function'].args + ]), + + + args_list: + if std.length(doc['function'].args) > 0 + then + '\nPARAMETERS:\n\n' + + std.join('\n', [ + '* **%s** (`%s`)' % [arg.name, getType(arg)] + + ( + local default = getDefault(arg); + if default != BelRune + then '\n - default value: `%s`' % std.manifestJson(default) + else '' + ) + + ( + local enum = getEnum(arg); + if enum != [] + then + '\n - valid values: %s' % + std.join(', ', [ + '`%s`' % std.manifestJson(item) + for item in enum + ]) + else '' + ) + for arg in doc['function'].args + ]) + else '', + + toString(): + std.join('\n', [ + root.util.title('fn ' + self.path, std.length(path) + 2), + ||| + ```jsonnet + %s(%s) + ``` + %s + ||| % [self.path, self.args, self.args_list], + std.get(doc['function'], 'help', ''), + ]), + }, + + findValues(obj, path=[]): { + local keys = + std.filter( + root.util.filter('value', obj), + std.objectFieldsAll(obj) + ), + + values: + std.foldl( + function(acc, k) + acc + [ + root.val( + root.util.realkey(k), + obj[k], + obj[root.util.realkey(k)], + path, + ), + ], + keys, + [] + ), + + hasFields(): std.length(self.values) > 0, + + toString(): + if self.hasFields() + then + std.join('\n', [ + '* ' + f.toString() + for f in self.values + ]) + '\n' + else '', + }, + + val(name, doc, obj, path): { + toString(): + std.join(' ', [ + '`%s`' % std.join('.', path + [name]), + '(`%s`):' % doc.value.type, + '`"%s"`' % obj, + '-', + std.get(doc.value, 'help', ''), + ]), + }, + + util: { + realkey(key): + assert std.startsWith(key, '#') : 'Key %s not a docstring key' % key; + key[1:], + title(title, depth=0): + std.join( + '', + ['\n'] + + ['#' for i in std.range(0, depth)] + + [' ', title, '\n'] + ), + fragment(title): + std.asciiLower( + std.strReplace( + std.strReplace(title, '.', '') + , ' ', '-' + ) + ), + filter(type, obj): + function(k) + std.all([ + std.startsWith(k, '#'), + std.isObject(obj[k]), + !std.objectHasAll(obj[k], 'ignore'), + type in obj[k], + root.util.realkey(k) in obj, + ]), + + getRelativePath(path, relativeTo): + local shortest = std.min(std.length(relativeTo), std.length(path)); + + local commonIndex = + std.foldl( + function(acc, i) ( + if acc.stop + then acc + else + acc + { + // stop count if path diverges + local stop = relativeTo[i] != path[i], + stop: stop, + count+: if stop then 0 else 1, + } + ), + std.range(0, shortest - 1), + { stop: false, count: 0 } + ).count; + + local _relativeTo = relativeTo[commonIndex:]; + local _path = path[commonIndex:]; + + // prefix for relative difference + local prefix = ['..' for i in std.range(0, std.length(_relativeTo) - 1)]; + + // return path with prefix + prefix + _path, + }, +} diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/.github/workflows/tests.yml b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/.github/workflows/tests.yml new file mode 100644 index 0000000000..bfe3f82712 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/.github/workflows/tests.yml @@ -0,0 +1,32 @@ +name: tests +on: + pull_request: {} + push: + branches: + - main + - master + +jobs: + test: + name: test + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-go@v4 + - name: make test + run: | + go install github.com/google/go-jsonnet/cmd/jsonnet@latest + go install github.com/jsonnet-bundler/jsonnet-bundler/cmd/jb@latest + make test + docs: + name: docs + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-go@v4 + - name: make docs + run: | + go install github.com/jsonnet-libs/docsonnet@master + make docs + git diff --exit-code + \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/.gitignore b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/.gitignore new file mode 100644 index 0000000000..bb476a1189 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/.gitignore @@ -0,0 +1,3 @@ +.jekyll-cache +jsonnetfile.lock.json +vendor diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/LICENSE b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/LICENSE new file mode 100644 index 0000000000..0a39b255a2 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "{}" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2018 grafana, sh0rez + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/Makefile b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/Makefile new file mode 100644 index 0000000000..7ffe3aa9e2 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/Makefile @@ -0,0 +1,16 @@ +.PHONY: test +test: + @cd test/; \ + jb install; \ + RESULT=0; \ + for f in $$(find . -path './.git' -prune -o -name 'vendor' -prune -o -name '*_test.jsonnet' -print); do \ + echo "$$f"; \ + jsonnet -J vendor -J lib "$$f"; \ + RESULT=$$(($$RESULT + $$?)); \ + done; \ + exit $$RESULT + + +.PHONY: docs +docs: + docsonnet main.libsonnet diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/README.md b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/README.md new file mode 100644 index 0000000000..a060428ed2 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/README.md @@ -0,0 +1,19 @@ +# `xtd` + +`xtd` aims to collect useful functions not included in the Jsonnet standard library (`std`). + +## Install + +```console +jb install github.com/jsonnet-libs/xtd +``` + +## Usage + +```jsonnet +local xtd = import "github.com/jsonnet-libs/xtd/main.libsonnet" +``` + +## Docs + +[docs](docs/README.md) diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/aggregate.libsonnet b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/aggregate.libsonnet new file mode 100644 index 0000000000..78d3c1cac2 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/aggregate.libsonnet @@ -0,0 +1,104 @@ +local d = import 'doc-util/main.libsonnet'; + +{ + local this = self, + + '#': d.pkg( + name='aggregate', + url='github.com/jsonnet-libs/xtd/aggregate.libsonnet', + help=||| + `aggregate` implements helper functions to aggregate arrays of objects into objects with arrays. + + Example: + + ```jsonnet + local apps = [ + { + appid: 'id1', + name: 'yo', + id: i, + } + for i in std.range(0, 10) + ]; + + aggregate.byKeys(apps, ['appid', 'name']); + ``` + + Output: + + ```json + { + "id1": { + "yo": [ + { + "appid": "id1", + "id": 0, + "name": "yo" + }, + { + "appid": "id1", + "id": 1, + "name": "yo" + }, + ... + ] + } + } + ``` + |||, + ), + + '#byKey':: d.fn( + ||| + `byKey` aggregates an array by the value of `key` + |||, + [ + d.arg('arr', d.T.array), + d.arg('key', d.T.string), + ] + ), + byKey(arr, key): + // find all values of key + local values = std.set([ + item[key] + for item in arr + ]); + + // create the aggregate for the value of each key + { + [value]: [ + item + for item in std.filter( + function(x) + x[key] == value, + arr + ) + ] + for value in values + }, + + '#byKeys':: d.fn( + ||| + `byKey` aggregates an array by iterating over `keys`, each item in `keys` nests the + aggregate one layer deeper. + |||, + [ + d.arg('arr', d.T.array), + d.arg('keys', d.T.array), + ] + ), + byKeys(arr, keys): + local aggregate = self.byKey(arr, keys[0]); + // if last key in keys + if std.length(keys) == 1 + + // then return aggregate + then aggregate + + // else aggregate with remaining keys + else { + [k]: this.byKeys(aggregate[k], keys[1:]) + for k in std.objectFields(aggregate) + }, + +} diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/array.libsonnet b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/array.libsonnet new file mode 100644 index 0000000000..f000c87871 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/array.libsonnet @@ -0,0 +1,37 @@ +local d = import 'doc-util/main.libsonnet'; + +{ + '#': d.pkg( + name='array', + url='github.com/jsonnet-libs/xtd/array.libsonnet', + help='`array` implements helper functions for processing arrays.', + ), + + '#slice':: d.fn( + '`slice` works the same as `std.slice` but with support for negative index/end.', + [ + d.arg('indexable', d.T.array), + d.arg('index', d.T.number), + d.arg('end', d.T.number, default='null'), + d.arg('step', d.T.number, default=1), + ] + ), + slice(indexable, index, end=null, step=1): + local invar = { + index: + if index != null + then + if index < 0 + then std.length(indexable) + index + else index + else 0, + end: + if end != null + then + if end < 0 + then std.length(indexable) + end + else end + else std.length(indexable), + }; + indexable[invar.index:invar.end:step], +} diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/ascii.libsonnet b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/ascii.libsonnet new file mode 100644 index 0000000000..28571ac6f8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/ascii.libsonnet @@ -0,0 +1,39 @@ +local d = import 'doc-util/main.libsonnet'; + +{ + '#': d.pkg( + name='ascii', + url='github.com/jsonnet-libs/xtd/ascii.libsonnet', + help='`ascii` implements helper functions for ascii characters', + ), + + local cp(c) = std.codepoint(c), + + '#isLower':: d.fn( + '`isLower` reports whether ASCII character `c` is a lower case letter', + [d.arg('c', d.T.string)] + ), + isLower(c): + if cp(c) >= 97 && cp(c) < 123 + then true + else false, + + '#isUpper':: d.fn( + '`isUpper` reports whether ASCII character `c` is a upper case letter', + [d.arg('c', d.T.string)] + ), + isUpper(c): + if cp(c) >= 65 && cp(c) < 91 + then true + else false, + + '#isNumber':: d.fn( + '`isNumber` reports whether character `c` is a number.', + [d.arg('c', d.T.string)] + ), + isNumber(c): + if std.isNumber(c) || (cp(c) >= 48 && cp(c) < 58) + then true + else false, + +} diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/camelcase.libsonnet b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/camelcase.libsonnet new file mode 100644 index 0000000000..9f26ef3f61 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/camelcase.libsonnet @@ -0,0 +1,100 @@ +local xtd = import './main.libsonnet'; +local d = import 'doc-util/main.libsonnet'; + +{ + '#': d.pkg( + name='camelcase', + url='github.com/jsonnet-libs/xtd/camelcase.libsonnet', + help='`camelcase` can split camelCase words into an array of words.', + ), + + '#split':: d.fn( + ||| + `split` splits a camelcase word and returns an array of words. It also supports + digits. Both lower camel case and upper camel case are supported. It only supports + ASCII characters. + For more info please check: http://en.wikipedia.org/wiki/CamelCase + Based on https://github.com/fatih/camelcase/ + |||, + [d.arg('src', d.T.string)] + ), + split(src): + if src == '' + then [''] + else + local runes = std.foldl( + function(acc, r) + acc { + local class = + if xtd.ascii.isNumber(r) + then 1 + else if xtd.ascii.isLower(r) + then 2 + else if xtd.ascii.isUpper(r) + then 3 + else 4, + + lastClass:: class, + + runes: + if class == super.lastClass + then super.runes[:std.length(super.runes) - 1] + + [super.runes[std.length(super.runes) - 1] + r] + else super.runes + [r], + }, + [src[i] for i in std.range(0, std.length(src) - 1)], + { lastClass:: 0, runes: [] } + ).runes; + + local fixRunes = + std.foldl( + function(runes, i) + if xtd.ascii.isUpper(runes[i][0]) + && xtd.ascii.isLower(runes[i + 1][0]) + && !xtd.ascii.isNumber(runes[i + 1][0]) + && runes[i][0] != ' ' + && runes[i + 1][0] != ' ' + then + std.mapWithIndex( + function(index, r) + if index == i + 1 + then runes[i][std.length(runes[i]) - 1:] + r + else + if index == i + then r[:std.length(r) - 1] + else r + , runes + ) + else runes + , + [i for i in std.range(0, std.length(runes) - 2)], + runes + ); + + [ + r + for r in fixRunes + if r != '' + ], + + '#toCamelCase':: d.fn( + ||| + `toCamelCase` transforms a string to camelCase format, splitting words by the `-`, `_` or spaces. + For example: `hello_world` becomes `helloWorld`. + For more info please check: http://en.wikipedia.org/wiki/CamelCase + |||, + [d.arg('str', d.T.string)] + ), + toCamelCase(str):: + local separators = std.set(std.findSubstr('_', str) + std.findSubstr('-', str) + std.findSubstr(' ', str)); + local n = std.join('', [ + if std.setMember(i - 1, separators) + then std.asciiUpper(str[i]) + else str[i] + for i in std.range(0, std.length(str) - 1) + if !std.setMember(i, separators) + ]); + if std.length(n) == 0 + then n + else std.asciiLower(n[0]) + n[1:], +} diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/date.libsonnet b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/date.libsonnet new file mode 100644 index 0000000000..4842f98bb3 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/date.libsonnet @@ -0,0 +1,185 @@ +local d = import 'doc-util/main.libsonnet'; + +{ + '#': d.pkg( + name='date', + url='github.com/jsonnet-libs/xtd/date.libsonnet', + help='`time` provides various date related functions.', + ), + + // Lookup tables for calendar calculations + local commonYearMonthLength = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], + local commonYearMonthOffset = [0, 3, 3, 6, 1, 4, 6, 2, 5, 0, 3, 5], + local leapYearMonthOffset = [0, 3, 4, 0, 2, 5, 0, 3, 6, 1, 4, 6], + + // monthOffset looks up the offset to apply in day of week calculations based on the year and month + local monthOffset(year, month) = + if self.isLeapYear(year) + then leapYearMonthOffset[month - 1] + else commonYearMonthOffset[month - 1], + + '#isLeapYear': d.fn( + '`isLeapYear` returns true if the given year is a leap year.', + [d.arg('year', d.T.number)], + ), + isLeapYear(year):: year % 4 == 0 && (year % 100 != 0 || year % 400 == 0), + + '#dayOfWeek': d.fn( + '`dayOfWeek` returns the day of the week for the given date. 0=Sunday, 1=Monday, etc.', + [ + d.arg('year', d.T.number), + d.arg('month', d.T.number), + d.arg('day', d.T.number), + ], + ), + dayOfWeek(year, month, day):: + (day + monthOffset(year, month) + 5 * ((year - 1) % 4) + 4 * ((year - 1) % 100) + 6 * ((year - 1) % 400)) % 7, + + '#dayOfYear': d.fn( + ||| + `dayOfYear` calculates the ordinal day of the year based on the given date. The range of outputs is 1-365 + for common years, and 1-366 for leap years. + |||, + [ + d.arg('year', d.T.number), + d.arg('month', d.T.number), + d.arg('day', d.T.number), + ], + ), + dayOfYear(year, month, day):: + std.foldl( + function(a, b) a + b, + std.slice(commonYearMonthLength, 0, month - 1, 1), + 0 + ) + day + + if month > 2 && self.isLeapYear(year) + then 1 + else 0, + + // yearSeconds returns the number of seconds in the given year. + local yearSeconds(year) = ( + if $.isLeapYear(year) + then 366 * 24 * 3600 + else 365 * 24 * 3600 + ), + + // monthSeconds returns the number of seconds in the given month of a given year. + local monthSeconds(year, month) = ( + commonYearMonthLength[month - 1] * 24 * 3600 + + if month == 2 && $.isLeapYear(year) then 86400 else 0 + ), + + // sumYearsSeconds returns the number of seconds in all years since 1970 up to year-1. + local sumYearsSeconds(year) = std.foldl( + function(acc, y) acc + yearSeconds(y), + std.range(1970, year - 1), + 0, + ), + + // sumMonthsSeconds returns the number of seconds in all months up to month-1 of the given year. + local sumMonthsSeconds(year, month) = std.foldl( + function(acc, m) acc + monthSeconds(year, m), + std.range(1, month - 1), + 0, + ), + + // sumDaysSeconds returns the number of seconds in all days up to day-1. + local sumDaysSeconds(day) = (day - 1) * 24 * 3600, + + '#toUnixTimestamp': d.fn( + ||| + `toUnixTimestamp` calculates the unix timestamp of a given date. + |||, + [ + d.arg('year', d.T.number), + d.arg('month', d.T.number), + d.arg('day', d.T.number), + d.arg('hour', d.T.number), + d.arg('minute', d.T.number), + d.arg('second', d.T.number), + ], + ), + toUnixTimestamp(year, month, day, hour, minute, second):: + sumYearsSeconds(year) + sumMonthsSeconds(year, month) + sumDaysSeconds(day) + hour * 3600 + minute * 60 + second, + + // isNumeric checks that the input is a non-empty string containing only digit characters. + local isNumeric(input) = + assert std.type(input) == 'string' : 'isNumeric() only operates on string inputs, got %s' % std.type(input); + std.foldl( + function(acc, char) acc && std.codepoint('0') <= std.codepoint(char) && std.codepoint(char) <= std.codepoint('9'), + std.stringChars(input), + std.length(input) > 0, + ), + + // parseSeparatedNumbers parses input which has part `names` separated by `sep`. + // Returns an object which has one field for each name in `names` with its integer value. + local parseSeparatedNumbers(input, sep, names) = ( + assert std.type(input) == 'string' : 'parseSeparatedNumbers() only operates on string inputs, got %s' % std.type(input); + assert std.type(sep) == 'string' : 'parseSeparatedNumbers() only operates on string separators, got %s' % std.type(sep); + assert std.type(names) == 'array' : 'parseSeparatedNumbers() only operates on arrays of names, got input %s' % std.type(names); + + local parts = std.split(input, sep); + assert std.length(parts) == std.length(names) : 'expected %(expected)d parts separated by %(sep)s in %(format)s formatted input "%(input)s", but got %(got)d' % { + expected: std.length(names), + sep: sep, + format: std.join(sep, names), + input: input, + got: std.length(parts), + }; + + { + [names[i]]: + // Fail with meaningful message if not numeric, otherwise it will be a hell to debug. + assert isNumeric(parts[i]) : '%(name)%s part "%(part)s" of %(format)s of input "%(input)s" is not numeric' % { + name: names[i], + part: parts[i], + format: std.join(sep, names), + input: input, + }; + std.parseInt(parts[i]) + for i in std.range(0, std.length(parts) - 1) + } + ), + + // stringContains is a helper function to check whether a string contains a given substring. + local stringContains(haystack, needle) = std.length(std.findSubstr(needle, haystack)) > 0, + + '#parseRFC3339': d.fn( + ||| + `parseRFC3339` parses an RFC3339-formatted date & time string (like `2020-01-02T03:04:05Z`) into an object containing the 'year', 'month', 'day', 'hour', 'minute' and 'second fields. + This is a limited implementation that does not support timezones (so it requires an UTC input ending in 'Z' or 'z') nor sub-second precision. + The returned object has a `toUnixTimestamp()` method that can be used to obtain the unix timestamp of the parsed date. + |||, + [ + d.arg('input', d.T.string), + ], + ), + parseRFC3339(input):: + // Basic input type check. + assert std.type(input) == 'string' : 'parseRFC3339() only operates on string inputs, got %s' % std.type(input); + + // Sub-second precision isn't implemented yet, warn the user about that instead of returning wrong results. + assert !stringContains(input, '.') : 'the provided RFC3339 input "%s" has a dot, most likely representing a sub-second precision, but this function does not support that' % input; + + // We don't support timezones, so string should end with 'Z' or 'z'. + assert std.endsWith(input, 'Z') || std.endsWith(input, 'z') : 'the provided RFC3339 "%s" should end with "Z" or "z". This implementation does not currently support timezones' % input; + + // RFC3339 can separate date and time using 'T', 't' or ' '. + // Find out which one it is and use it. + local sep = + if stringContains(input, 'T') then 'T' + else if stringContains(input, 't') then 't' + else if stringContains(input, ' ') then ' ' + else error 'the provided RFC3339 input "%s" should contain either a "T", or a "t" or space " " as a separator for date and time parts' % input; + + // Split date and time using the selected separator. + // Remove the last character as we know it's 'Z' or 'z' and it's not useful to us. + local datetime = std.split(std.substr(input, 0, std.length(input) - 1), sep); + assert std.length(datetime) == 2 : 'the provided RFC3339 timestamp "%(input)s" does not have date and time parts separated by the character "%(sep)s"' % { input: input, sep: sep }; + + local date = parseSeparatedNumbers(datetime[0], '-', ['year', 'month', 'day']); + local time = parseSeparatedNumbers(datetime[1], ':', ['hour', 'minute', 'second']); + date + time + { + toUnixTimestamp():: $.toUnixTimestamp(self.year, self.month, self.day, self.hour, self.minute, self.second), + }, +} diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/.gitignore b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/.gitignore new file mode 100644 index 0000000000..d7951d909b --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/.gitignore @@ -0,0 +1,2 @@ +Gemfile.lock +_site diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/Gemfile b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/Gemfile new file mode 100644 index 0000000000..75d9835fa2 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/Gemfile @@ -0,0 +1,2 @@ +source "https://rubygems.org" +gem "github-pages", group: :jekyll_plugins diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/README.md b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/README.md new file mode 100644 index 0000000000..fbd33a5f0c --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/README.md @@ -0,0 +1,25 @@ +--- +permalink: / +--- + +# xtd + +```jsonnet +local xtd = import "github.com/jsonnet-libs/xtd/main.libsonnet" +``` + +`xtd` aims to collect useful functions not included in the Jsonnet standard library (`std`). + +This package serves as a test field for functions intended to be contributed to `std` +in the future, but also provides a place for less general, yet useful utilities. + + +* [aggregate](aggregate.md) +* [array](array.md) +* [ascii](ascii.md) +* [camelcase](camelcase.md) +* [date](date.md) +* [inspect](inspect.md) +* [jsonpath](jsonpath.md) +* [string](string.md) +* [url](url.md) \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/_config.yml b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/_config.yml new file mode 100644 index 0000000000..d18a288c42 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/_config.yml @@ -0,0 +1,2 @@ +theme: jekyll-theme-cayman +baseurl: /xtd diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/aggregate.md b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/aggregate.md new file mode 100644 index 0000000000..a877ddf24a --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/aggregate.md @@ -0,0 +1,74 @@ +--- +permalink: /aggregate/ +--- + +# aggregate + +```jsonnet +local aggregate = import "github.com/jsonnet-libs/xtd/aggregate.libsonnet" +``` + +`aggregate` implements helper functions to aggregate arrays of objects into objects with arrays. + +Example: + +```jsonnet +local apps = [ + { + appid: 'id1', + name: 'yo', + id: i, + } + for i in std.range(0, 10) +]; + +aggregate.byKeys(apps, ['appid', 'name']); +``` + +Output: + +```json +{ + "id1": { + "yo": [ + { + "appid": "id1", + "id": 0, + "name": "yo" + }, + { + "appid": "id1", + "id": 1, + "name": "yo" + }, + ... + ] + } +} +``` + + +## Index + +* [`fn byKey(arr, key)`](#fn-bykey) +* [`fn byKeys(arr, keys)`](#fn-bykeys) + +## Fields + +### fn byKey + +```ts +byKey(arr, key) +``` + +`byKey` aggregates an array by the value of `key` + + +### fn byKeys + +```ts +byKeys(arr, keys) +``` + +`byKey` aggregates an array by iterating over `keys`, each item in `keys` nests the +aggregate one layer deeper. diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/array.md b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/array.md new file mode 100644 index 0000000000..f273293a61 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/array.md @@ -0,0 +1,25 @@ +--- +permalink: /array/ +--- + +# array + +```jsonnet +local array = import "github.com/jsonnet-libs/xtd/array.libsonnet" +``` + +`array` implements helper functions for processing arrays. + +## Index + +* [`fn slice(indexable, index, end='null', step=1)`](#fn-slice) + +## Fields + +### fn slice + +```ts +slice(indexable, index, end='null', step=1) +``` + +`slice` works the same as `std.slice` but with support for negative index/end. \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/ascii.md b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/ascii.md new file mode 100644 index 0000000000..9a85053806 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/ascii.md @@ -0,0 +1,43 @@ +--- +permalink: /ascii/ +--- + +# ascii + +```jsonnet +local ascii = import "github.com/jsonnet-libs/xtd/ascii.libsonnet" +``` + +`ascii` implements helper functions for ascii characters + +## Index + +* [`fn isLower(c)`](#fn-islower) +* [`fn isNumber(c)`](#fn-isnumber) +* [`fn isUpper(c)`](#fn-isupper) + +## Fields + +### fn isLower + +```ts +isLower(c) +``` + +`isLower` reports whether ASCII character `c` is a lower case letter + +### fn isNumber + +```ts +isNumber(c) +``` + +`isNumber` reports whether character `c` is a number. + +### fn isUpper + +```ts +isUpper(c) +``` + +`isUpper` reports whether ASCII character `c` is a upper case letter \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/camelcase.md b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/camelcase.md new file mode 100644 index 0000000000..6c521473cd --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/camelcase.md @@ -0,0 +1,41 @@ +--- +permalink: /camelcase/ +--- + +# camelcase + +```jsonnet +local camelcase = import "github.com/jsonnet-libs/xtd/camelcase.libsonnet" +``` + +`camelcase` can split camelCase words into an array of words. + +## Index + +* [`fn split(src)`](#fn-split) +* [`fn toCamelCase(str)`](#fn-tocamelcase) + +## Fields + +### fn split + +```ts +split(src) +``` + +`split` splits a camelcase word and returns an array of words. It also supports +digits. Both lower camel case and upper camel case are supported. It only supports +ASCII characters. +For more info please check: http://en.wikipedia.org/wiki/CamelCase +Based on https://github.com/fatih/camelcase/ + + +### fn toCamelCase + +```ts +toCamelCase(str) +``` + +`toCamelCase` transforms a string to camelCase format, splitting words by the `-`, `_` or spaces. +For example: `hello_world` becomes `helloWorld`. +For more info please check: http://en.wikipedia.org/wiki/CamelCase diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/date.md b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/date.md new file mode 100644 index 0000000000..1fcb9eb43f --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/date.md @@ -0,0 +1,66 @@ +--- +permalink: /date/ +--- + +# date + +```jsonnet +local date = import "github.com/jsonnet-libs/xtd/date.libsonnet" +``` + +`time` provides various date related functions. + +## Index + +* [`fn dayOfWeek(year, month, day)`](#fn-dayofweek) +* [`fn dayOfYear(year, month, day)`](#fn-dayofyear) +* [`fn isLeapYear(year)`](#fn-isleapyear) +* [`fn parseRFC3339(input)`](#fn-parserfc3339) +* [`fn toUnixTimestamp(year, month, day, hour, minute, second)`](#fn-tounixtimestamp) + +## Fields + +### fn dayOfWeek + +```ts +dayOfWeek(year, month, day) +``` + +`dayOfWeek` returns the day of the week for the given date. 0=Sunday, 1=Monday, etc. + +### fn dayOfYear + +```ts +dayOfYear(year, month, day) +``` + +`dayOfYear` calculates the ordinal day of the year based on the given date. The range of outputs is 1-365 +for common years, and 1-366 for leap years. + + +### fn isLeapYear + +```ts +isLeapYear(year) +``` + +`isLeapYear` returns true if the given year is a leap year. + +### fn parseRFC3339 + +```ts +parseRFC3339(input) +``` + +`parseRFC3339` parses an RFC3339-formatted date & time string (like `2020-01-02T03:04:05Z`) into an object containing the 'year', 'month', 'day', 'hour', 'minute' and 'second fields. +This is a limited implementation that does not support timezones (so it requires an UTC input ending in 'Z' or 'z') nor sub-second precision. +The returned object has a `toUnixTimestamp()` method that can be used to obtain the unix timestamp of the parsed date. + + +### fn toUnixTimestamp + +```ts +toUnixTimestamp(year, month, day, hour, minute, second) +``` + +`toUnixTimestamp` calculates the unix timestamp of a given date. diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/inspect.md b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/inspect.md new file mode 100644 index 0000000000..94575ca627 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/inspect.md @@ -0,0 +1,93 @@ +--- +permalink: /inspect/ +--- + +# inspect + +```jsonnet +local inspect = import "github.com/jsonnet-libs/xtd/inspect.libsonnet" +``` + +`inspect` implements helper functions for inspecting Jsonnet + +## Index + +* [`fn diff(input1, input2)`](#fn-diff) +* [`fn filterKubernetesObjects(object, kind='')`](#fn-filterkubernetesobjects) +* [`fn filterObjects(filter_func, x)`](#fn-filterobjects) +* [`fn inspect(object, maxDepth)`](#fn-inspect) + +## Fields + +### fn diff + +```ts +diff(input1, input2) +``` + +`diff` returns a JSON object describing the differences between two inputs. It +attemps to show diffs in nested objects and arrays too. + +Simple example: + +```jsonnet +local input1 = { + same: 'same', + change: 'this', + remove: 'removed', +}; + +local input2 = { + same: 'same', + change: 'changed', + add: 'added', +}; + +diff(input1, input2), +``` + +Output: +```json +{ + "add +": "added", + "change ~": "~[ this , changed ]", + "remove -": "removed" +} +``` + + +### fn filterKubernetesObjects + +```ts +filterKubernetesObjects(object, kind='') +``` + +`filterKubernetesObjects` implements `filterObjects` to return all Kubernetes objects in +an array, assuming that Kubernetes object are characterized by having an +`apiVersion` and `kind` field. + +The `object` argument can either be an object or an array, other types will be +ignored. The `kind` allows to filter out a specific kind, if unset all kinds will +be returned. + + +### fn filterObjects + +```ts +filterObjects(filter_func, x) +``` + +`filterObjects` walks a JSON tree returning all matching objects in an array. + +The `x` argument can either be an object or an array, other types will be +ignored. + + +### fn inspect + +```ts +inspect(object, maxDepth) +``` + +`inspect` reports the structure of a Jsonnet object with a recursion depth of +`maxDepth` (default maxDepth=10). diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/jsonpath.md b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/jsonpath.md new file mode 100644 index 0000000000..94a4a4be64 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/jsonpath.md @@ -0,0 +1,53 @@ +--- +permalink: /jsonpath/ +--- + +# jsonpath + +```jsonnet +local jsonpath = import "github.com/jsonnet-libs/xtd/jsonpath.libsonnet" +``` + +`jsonpath` implements helper functions to use JSONPath expressions. + +## Index + +* [`fn convertBracketToDot(path)`](#fn-convertbrackettodot) +* [`fn getJSONPath(source, path, default='null')`](#fn-getjsonpath) +* [`fn parseFilterExpr(path)`](#fn-parsefilterexpr) + +## Fields + +### fn convertBracketToDot + +```ts +convertBracketToDot(path) +``` + +`convertBracketToDot` converts the bracket notation to dot notation. + +This function does not support escaping brackets/quotes in path keys. + + +### fn getJSONPath + +```ts +getJSONPath(source, path, default='null') +``` + +`getJSONPath` gets the value at `path` from `source` where path is a JSONPath. + +This is a rudimentary implementation supporting the slice operator `[0:3:2]` and +partially supporting filter expressions `?(@.attr==value)`. + + +### fn parseFilterExpr + +```ts +parseFilterExpr(path) +``` + +`parseFilterExpr` returns a filter function `f(x)` for a filter expression `expr`. + + It supports comparisons (<, <=, >, >=) and equality checks (==, !=). If it doesn't + have an operator, it will check if the `expr` value exists. diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/string.md b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/string.md new file mode 100644 index 0000000000..62873e57f9 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/string.md @@ -0,0 +1,26 @@ +--- +permalink: /string/ +--- + +# string + +```jsonnet +local string = import "github.com/jsonnet-libs/xtd/string.libsonnet" +``` + +`string` implements helper functions for processing strings. + +## Index + +* [`fn splitEscape(str, c, escape='\\')`](#fn-splitescape) + +## Fields + +### fn splitEscape + +```ts +splitEscape(str, c, escape='\\') +``` + +`split` works the same as `std.split` but with support for escaping the dividing +string `c`. diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/url.md b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/url.md new file mode 100644 index 0000000000..db898bcc8b --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/docs/url.md @@ -0,0 +1,56 @@ +--- +permalink: /url/ +--- + +# url + +```jsonnet +local url = import "github.com/jsonnet-libs/xtd/url.libsonnet" +``` + +`url` provides functions to deal with URLs + +## Index + +* [`fn encodeQuery(params)`](#fn-encodequery) +* [`fn escapeString(str, excludedChars=[])`](#fn-escapestring) +* [`fn join(splitObj)`](#fn-join) +* [`fn parse(url)`](#fn-parse) + +## Fields + +### fn encodeQuery + +```ts +encodeQuery(params) +``` + +`encodeQuery` takes an object of query parameters and returns them as an escaped `key=value` string + +### fn escapeString + +```ts +escapeString(str, excludedChars=[]) +``` + +`escapeString` escapes the given string so it can be safely placed inside an URL, replacing special characters with `%XX` sequences + +### fn join + +```ts +join(splitObj) +``` + +`join` joins URLs from the object generated from `parse` + +### fn parse + +```ts +parse(url) +``` + +`parse` parses absolute and relative URLs. + +:///;parameters?# + +Inspired by Python's urllib.urlparse, following several RFC specifications. diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/inspect.libsonnet b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/inspect.libsonnet new file mode 100644 index 0000000000..8ac9bf0182 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/inspect.libsonnet @@ -0,0 +1,209 @@ +local d = import 'doc-util/main.libsonnet'; + +{ + local this = self, + + '#': d.pkg( + name='inspect', + url='github.com/jsonnet-libs/xtd/inspect.libsonnet', + help='`inspect` implements helper functions for inspecting Jsonnet', + ), + + '#inspect':: d.fn( + ||| + `inspect` reports the structure of a Jsonnet object with a recursion depth of + `maxDepth` (default maxDepth=10). + |||, + [ + d.arg('object', d.T.object), + d.arg('maxDepth', d.T.number), + //d.arg('depth', d.T.number), // used for recursion, not exposing in docs + ] + ), + inspect(object, maxDepth=10, depth=0): + std.foldl( + function(acc, p) + acc + ( + if std.isObject(object[p]) + && depth != maxDepth + then { [p]+: + this.inspect( + object[p], + maxDepth, + depth + 1 + ) } + else { + [ + (if !std.objectHas(object, p) + then 'hidden_' + else '') + + (if std.isFunction(object[p]) + then 'functions' + else 'fields') + ]+: [p], + } + ), + std.objectFieldsAll(object), + {} + ), + + '#diff':: d.fn( + ||| + `diff` returns a JSON object describing the differences between two inputs. It + attemps to show diffs in nested objects and arrays too. + + Simple example: + + ```jsonnet + local input1 = { + same: 'same', + change: 'this', + remove: 'removed', + }; + + local input2 = { + same: 'same', + change: 'changed', + add: 'added', + }; + + diff(input1, input2), + ``` + + Output: + ```json + { + "add +": "added", + "change ~": "~[ this , changed ]", + "remove -": "removed" + } + ``` + |||, + [ + d.arg('input1', d.T.any), + d.arg('input2', d.T.any), + ] + ), + diff(input1, input2):: + if input1 == input2 + then '' + else if std.isArray(input1) && std.isArray(input2) + then + [ + if input1[i] != input2[i] + then + this.diff( + input1[i], + input2[i] + ) + else input2[i] + for i in std.range(0, std.length(input2) - 1) + if std.length(input1) > i + ] + + (if std.length(input1) < std.length(input2) + then [ + '+ ' + input2[i] + for i in std.range(std.length(input1), std.length(input2) - 1) + ] + else []) + + (if std.length(input1) > std.length(input2) + then [ + '- ' + input1[i] + for i in std.range(std.length(input2), std.length(input1) - 1) + ] + else []) + + else if std.isObject(input1) && std.isObject(input2) + then std.foldl( + function(acc, k) + acc + ( + if k in input1 && input1[k] != input2[k] + then { + [k + ' ~']: + this.diff( + input1[k], + input2[k] + ), + } + else if !(k in input1) + then { + [k + ' +']: input2[k], + } + else {} + ), + std.objectFields(input2), + {}, + ) + + { + [l + ' -']: input1[l] + for l in std.objectFields(input1) + if !(l in input2) + } + + else '~[ %s ]' % std.join(' , ', [std.toString(input1), std.toString(input2)]), + + '#filterObjects':: d.fn( + ||| + `filterObjects` walks a JSON tree returning all matching objects in an array. + + The `x` argument can either be an object or an array, other types will be + ignored. + |||, + args=[ + d.arg('filter_func', d.T.func), + d.arg('x', d.T.any), + ] + ), + filterObjects(filter_func, x): + if std.isObject(x) + then + if filter_func(x) + then [x] + else + std.foldl( + function(acc, o) + acc + self.filterObjects(filter_func, x[o]), + std.objectFields(x), + [] + ) + else if std.isArray(x) + then + std.flattenArrays( + std.map( + function(obj) + self.filterObjects(filter_func, obj), + x + ) + ) + else [], + + '#filterKubernetesObjects':: d.fn( + ||| + `filterKubernetesObjects` implements `filterObjects` to return all Kubernetes objects in + an array, assuming that Kubernetes object are characterized by having an + `apiVersion` and `kind` field. + + The `object` argument can either be an object or an array, other types will be + ignored. The `kind` allows to filter out a specific kind, if unset all kinds will + be returned. + |||, + args=[ + d.arg('object', d.T.any), + d.arg('kind', d.T.string, default=''), + ] + ), + filterKubernetesObjects(object, kind=''): + local objects = self.filterObjects( + function(object) + std.objectHas(object, 'apiVersion') + && std.objectHas(object, 'kind'), + object, + ); + if kind == '' + then objects + else + std.filter( + function(o) o.kind == kind, + objects + ), +} diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/jsonpath.libsonnet b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/jsonpath.libsonnet new file mode 100644 index 0000000000..7722d640bd --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/jsonpath.libsonnet @@ -0,0 +1,142 @@ +local xtd = import './main.libsonnet'; +local d = import 'doc-util/main.libsonnet'; + +{ + '#': d.pkg( + name='jsonpath', + url='github.com/jsonnet-libs/xtd/jsonpath.libsonnet', + help='`jsonpath` implements helper functions to use JSONPath expressions.', + ), + + + '#getJSONPath':: d.fn( + ||| + `getJSONPath` gets the value at `path` from `source` where path is a JSONPath. + + This is a rudimentary implementation supporting the slice operator `[0:3:2]` and + partially supporting filter expressions `?(@.attr==value)`. + |||, + [ + d.arg('source', d.T.any), + d.arg('path', d.T.string,), + d.arg('default', d.T.any, default='null'), + ] + ), + getJSONPath(source, path, default=null): + local _path = self.convertBracketToDot(path); + std.foldl( + function(acc, key) + if acc == null + then acc + else get(acc, key, default), + xtd.string.splitEscape(_path, '.'), + source, + ), + + '#convertBracketToDot':: d.fn( + ||| + `convertBracketToDot` converts the bracket notation to dot notation. + + This function does not support escaping brackets/quotes in path keys. + |||, + [ + d.arg('path', d.T.string,), + ] + ), + convertBracketToDot(path): + if std.length(std.findSubstr('[', path)) > 0 + then + local split = std.split(path, '['); + std.join('.', [ + local a = std.stripChars(i, "[]'"); + std.strReplace(a, '@.', '@\\.') + for i in split + ]) + else path, + + local get(source, key, default) = + if key == '' + || key == '$' + || key == '*' + then source + else if std.isArray(source) + then getFromArray(source, key) + else std.get(source, key, default), + + local getFromArray(arr, key) = + if std.startsWith(key, '?(@\\.') + then + std.filter( + self.parseFilterExpr(std.stripChars(key, '?(@\\.)')), + arr + ) + else if std.length(std.findSubstr(':', key)) >= 1 + then + local split = std.splitLimit(key, ':', 2); + local step = + if std.length(split) < 3 + then 1 + else parseIntOrNull(split[2]); + xtd.array.slice( + arr, + parseIntOrNull(split[0]), + parseIntOrNull(split[1]), + step, + ) + else + arr[std.parseInt(key)], + + local parseIntOrNull(str) = + if str == '' + then null + else std.parseInt(str), + + '#parseFilterExpr':: d.fn( + ||| + `parseFilterExpr` returns a filter function `f(x)` for a filter expression `expr`. + + It supports comparisons (<, <=, >, >=) and equality checks (==, !=). If it doesn't + have an operator, it will check if the `expr` value exists. + |||, + [ + d.arg('path', d.T.string,), + ] + ), + parseFilterExpr(expr): + local operandFunctions = { + '=='(a, b): a == b, + '!='(a, b): a != b, + '<='(a, b): a <= b, + '>='(a, b): a >= b, + '<'(a, b): a < b, + '>'(a, b): a > b, + }; + + local findOperands = std.filter( + function(op) std.length(std.findSubstr(op, expr)) > 0, + std.reverse( // reverse to match '<=' before '<' + std.objectFields(operandFunctions) + ) + ); + + if std.length(findOperands) > 0 + then + local op = findOperands[0]; + local s = [ + std.stripChars(i, ' ') + for i in std.splitLimit(expr, op, 1) + ]; + function(x) + if s[0] in x + then + local left = x[s[0]]; + local right = + if std.isNumber(left) + then std.parseInt(s[1]) // Only parse if comparing numbers + else s[1]; + operandFunctions[op](left, right) + else false + else + // Default to key matching + function(x) (expr in x), +} diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/main.libsonnet b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/main.libsonnet new file mode 100644 index 0000000000..59c4034028 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/main.libsonnet @@ -0,0 +1,24 @@ +local d = import 'doc-util/main.libsonnet'; + +{ + '#': d.pkg( + name='xtd', + url='github.com/jsonnet-libs/xtd/main.libsonnet', + help=||| + `xtd` aims to collect useful functions not included in the Jsonnet standard library (`std`). + + This package serves as a test field for functions intended to be contributed to `std` + in the future, but also provides a place for less general, yet useful utilities. + |||, + ), + + aggregate: (import './aggregate.libsonnet'), + array: (import './array.libsonnet'), + ascii: (import './ascii.libsonnet'), + camelcase: (import './camelcase.libsonnet'), + date: (import './date.libsonnet'), + inspect: (import './inspect.libsonnet'), + jsonpath: (import './jsonpath.libsonnet'), + string: (import './string.libsonnet'), + url: (import './url.libsonnet'), +} diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/string.libsonnet b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/string.libsonnet new file mode 100644 index 0000000000..5514cdeee8 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/string.libsonnet @@ -0,0 +1,35 @@ +local d = import 'doc-util/main.libsonnet'; + +{ + '#': d.pkg( + name='string', + url='github.com/jsonnet-libs/xtd/string.libsonnet', + help='`string` implements helper functions for processing strings.', + ), + + // BelRune is a string of the Ascii character BEL which made computers ring in ancient times. + // We use it as "magic" char to temporarily replace an escaped string as it is a non printable + // character and thereby will unlikely be in a valid key by accident. Only when we include it. + local BelRune = std.char(7), + + '#splitEscape':: d.fn( + ||| + `split` works the same as `std.split` but with support for escaping the dividing + string `c`. + |||, + [ + d.arg('str', d.T.string), + d.arg('c', d.T.string), + d.arg('escape', d.T.string, default='\\'), + ] + ), + splitEscape(str, c, escape='\\'): + std.map( + function(i) + std.strReplace(i, BelRune, escape + c), + std.split( + std.strReplace(str, escape + c, BelRune), + c, + ) + ), +} diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/test/array_test.jsonnet b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/test/array_test.jsonnet new file mode 100644 index 0000000000..65aef8a210 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/test/array_test.jsonnet @@ -0,0 +1,83 @@ +local array = import '../array.libsonnet'; +local test = import 'github.com/jsonnet-libs/testonnet/main.libsonnet'; + +local arr = std.range(0, 10); + +test.new(std.thisFile) + ++ test.case.new( + name='first two', + test=test.expect.eq( + actual=array.slice( + arr, + index=0, + end=2, + ), + expected=[0, 1], + ) +) ++ test.case.new( + name='last two', + test=test.expect.eq( + actual=array.slice( + arr, + index=1, + end=3, + ), + expected=[1, 2], + ) +) ++ test.case.new( + name='until end', + test=test.expect.eq( + actual=array.slice( + arr, + index=1 + ), + expected=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], + ) +) ++ test.case.new( + name='from beginning', + test=test.expect.eq( + actual=array.slice( + arr, + index=0, + end=2 + ), + expected=[0, 1], + ) +) ++ test.case.new( + name='negative start', + test=test.expect.eq( + actual=array.slice( + arr, + index=-2 + ), + expected=[9, 10], + ) +) ++ test.case.new( + name='negative end', + test=test.expect.eq( + actual=array.slice( + arr, + index=0, + end=-1 + ), + expected=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], + ) +) ++ test.case.new( + name='step', + test=test.expect.eq( + actual=array.slice( + arr, + index=0, + end=5, + step=2 + ), + expected=[0, 2, 4], + ) +) diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/test/camelcase_test.jsonnet b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/test/camelcase_test.jsonnet new file mode 100644 index 0000000000..2dcadc018d --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/test/camelcase_test.jsonnet @@ -0,0 +1,193 @@ +local xtd = import '../main.libsonnet'; +local test = import 'github.com/jsonnet-libs/testonnet/main.libsonnet'; + +test.new(std.thisFile) + ++ test.case.new( + name='split: nostring', + test=test.expect.eq( + actual=xtd.camelcase.split(''), + expected=[''], + ) +) ++ test.case.new( + name='split: lowercase', + test=test.expect.eq( + actual=xtd.camelcase.split('lowercase'), + expected=['lowercase'], + ) +) ++ test.case.new( + name='split: Class', + test=test.expect.eq( + actual=xtd.camelcase.split('Class'), + expected=['Class'], + ) +) ++ test.case.new( + name='split: MyClass', + test=test.expect.eq( + actual=xtd.camelcase.split('MyClass'), + expected=['My', 'Class'], + ) +) ++ test.case.new( + name='split: MyC', + test=test.expect.eq( + actual=xtd.camelcase.split('MyC'), + expected=['My', 'C'], + ) +) ++ test.case.new( + name='split: HTML', + test=test.expect.eq( + actual=xtd.camelcase.split('HTML'), + expected=['HTML'], + ) +) ++ test.case.new( + name='split: PDFLoader', + test=test.expect.eq( + actual=xtd.camelcase.split('PDFLoader'), + expected=['PDF', 'Loader'], + ) +) ++ test.case.new( + name='split: AString', + test=test.expect.eq( + actual=xtd.camelcase.split('AString'), + expected=['A', 'String'], + ) +) ++ test.case.new( + name='split: SimpleXMLParser', + test=test.expect.eq( + actual=xtd.camelcase.split('SimpleXMLParser'), + expected=['Simple', 'XML', 'Parser'], + ) +) ++ test.case.new( + name='split: vimRPCPlugin', + test=test.expect.eq( + actual=xtd.camelcase.split('vimRPCPlugin'), + expected=['vim', 'RPC', 'Plugin'], + ) +) ++ test.case.new( + name='split: GL11Version', + test=test.expect.eq( + actual=xtd.camelcase.split('GL11Version'), + expected=['GL', '11', 'Version'], + ) +) ++ test.case.new( + name='split: 99Bottles', + test=test.expect.eq( + actual=xtd.camelcase.split('99Bottles'), + expected=['99', 'Bottles'], + ) +) ++ test.case.new( + name='split: May5', + test=test.expect.eq( + actual=xtd.camelcase.split('May5'), + expected=['May', '5'], + ) +) ++ test.case.new( + name='split: BFG9000', + test=test.expect.eq( + actual=xtd.camelcase.split('BFG9000'), + expected=['BFG', '9000'], + ) +) ++ test.case.new( + name='split: Two spaces', + test=test.expect.eq( + actual=xtd.camelcase.split('Two spaces'), + expected=['Two', ' ', 'spaces'], + ) +) ++ test.case.new( + name='split: Multiple Random spaces', + test=test.expect.eq( + actual=xtd.camelcase.split('Multiple Random spaces'), + expected=['Multiple', ' ', 'Random', ' ', 'spaces'], + ) +) ++ test.case.new( + name='toCamelCase: empty string', + test=test.expect.eq( + actual=xtd.camelcase.toCamelCase(''), + expected='', + ) +) ++ test.case.new( + name='toCamelCase: lowercase', + test=test.expect.eq( + actual=xtd.camelcase.toCamelCase('lowercase'), + expected='lowercase', + ) +) ++ test.case.new( + name='toCamelCase: underscores', + test=test.expect.eq( + actual=xtd.camelcase.toCamelCase('lower_case'), + expected='lowerCase', + ) +) ++ test.case.new( + name='toCamelCase: dashes', + test=test.expect.eq( + actual=xtd.camelcase.toCamelCase('lower-case'), + expected='lowerCase', + ) +) ++ test.case.new( + name='toCamelCase: spaces', + test=test.expect.eq( + actual=xtd.camelcase.toCamelCase('lower case'), + expected='lowerCase', + ) +) ++ test.case.new( + name='toCamelCase: mixed', + test=test.expect.eq( + actual=xtd.camelcase.toCamelCase('lower_case-mixed'), + expected='lowerCaseMixed', + ) +) ++ test.case.new( + name='toCamelCase: multiple spaces', + test=test.expect.eq( + actual=xtd.camelcase.toCamelCase('lower case'), + expected='lowerCase', + ) +) ++ test.case.new( + name='toCamelCase: PascalCase', + test=test.expect.eq( + actual=xtd.camelcase.toCamelCase('PascalCase'), + expected='pascalCase', + ) +) + +// TODO: find or create is(Upper|Lower) for non-ascii characters +// Something like this for Jsonnet: +// https://cs.opensource.google/go/go/+/refs/tags/go1.17.3:src/unicode/tables.go +//+ test.case.new( +// name='BöseÜberraschung', +// test=test.expect.eq( +// actual=xtd.camelcase.split('BöseÜberraschung'), +// expected=['Böse', 'Überraschung'], +// ) +//) + +// This doesn't even render in Jsonnet +//+ test.case.new( +// name="BadUTF8\xe2\xe2\xa1", +// test=test.expect.eq( +// actual=xtd.camelcase.split("BadUTF8\xe2\xe2\xa1"), +// expected=["BadUTF8\xe2\xe2\xa1"], +// ) +//) diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/test/date_test.jsonnet b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/test/date_test.jsonnet new file mode 100644 index 0000000000..974642883d --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/test/date_test.jsonnet @@ -0,0 +1,219 @@ +local xtd = import '../main.libsonnet'; +local test = import 'github.com/jsonnet-libs/testonnet/main.libsonnet'; + +test.new(std.thisFile) + ++ test.case.new( + name='Leap Year commonYear', + test=test.expect.eq( + actual=xtd.date.isLeapYear(1995), + expected=false, + ) +) + ++ test.case.new( + name='Leap Year fourYearCycle', + test=test.expect.eq( + actual=xtd.date.isLeapYear(1996), + expected=true, + ) +) + ++ test.case.new( + name='Leap Year fourHundredYearCycle', + test=test.expect.eq( + actual=xtd.date.isLeapYear(2000), + expected=true, + ) +) + ++ test.case.new( + name='Leap Year hundredYearCycle', + test=test.expect.eq( + actual=xtd.date.isLeapYear(2100), + expected=false, + ) +) + ++ test.case.new( + name='Day Of Week leapYearStart', + test=test.expect.eq( + actual=xtd.date.dayOfWeek(2000, 1, 1), + expected=6, + ) +) + ++ test.case.new( + name='Day Of Week leapYearEnd', + test=test.expect.eq( + actual=xtd.date.dayOfWeek(2000, 12, 31), + expected=0, + ) +) + ++ test.case.new( + name='Day Of Week commonYearStart', + test=test.expect.eq( + actual=xtd.date.dayOfWeek(1995, 1, 1), + expected=0, + ) +) + ++ test.case.new( + name='Day Of Week commonYearEnd', + test=test.expect.eq( + actual=xtd.date.dayOfWeek(2003, 12, 31), + expected=3, + ) +) + ++ test.case.new( + name='Day Of Week leapYearMid', + test=test.expect.eq( + actual=xtd.date.dayOfWeek(2024, 7, 19), + expected=5, + ) +) + ++ test.case.new( + name='Day Of Week commonYearMid', + test=test.expect.eq( + actual=xtd.date.dayOfWeek(2023, 6, 15), + expected=4, + ) +) ++ test.case.new( + name='Day Of Year leapYearStart', + test=test.expect.eq( + actual=xtd.date.dayOfYear(2000, 1, 1), + expected=1, + ) +) + ++ test.case.new( + name='Day Of Year leapYearEnd', + test=test.expect.eq( + actual=xtd.date.dayOfYear(2000, 12, 31), + expected=366, + ) +) + ++ test.case.new( + name='Day Of Year commonYearStart', + test=test.expect.eq( + actual=xtd.date.dayOfYear(1995, 1, 1), + expected=1, + ) +) + ++ test.case.new( + name='Day Of Year commonYearEnd', + test=test.expect.eq( + actual=xtd.date.dayOfYear(2003, 12, 31), + expected=365, + ) +) + ++ test.case.new( + name='Day Of Year leapYearMid', + test=test.expect.eq( + actual=xtd.date.dayOfYear(2024, 7, 19), + expected=201, + ) +) + ++ test.case.new( + name='Day Of Year commonYearMid', + test=test.expect.eq( + actual=xtd.date.dayOfYear(2023, 6, 15), + expected=166, + ) +) + ++ test.case.new( + name='toUnixTimestamp of 1970-01-01 00:00:00 (zero)', + test=test.expect.eq( + actual=xtd.date.toUnixTimestamp(1970, 1, 1, 0, 0, 0), + expected=0, + ), +) + ++ test.case.new( + name='toUnixTimestamp of 1970-01-02 00:00:00 (one day)', + test=test.expect.eq( + actual=xtd.date.toUnixTimestamp(1970, 1, 2, 0, 0, 0), + expected=86400, + ), +) + ++ test.case.new( + name='toUnixTimestamp of 1971-01-01 00:00:00 (one year)', + test=test.expect.eq( + actual=xtd.date.toUnixTimestamp(1971, 1, 1, 0, 0, 0), + expected=365 * 24 * 3600, + ), +) + ++ test.case.new( + name='toUnixTimestamp of 1972-03-01 00:00:00 (month of leap year)', + test=test.expect.eq( + actual=xtd.date.toUnixTimestamp(1972, 3, 1, 0, 0, 0), + expected=2 * 365 * 24 * 3600 + 31 * 24 * 3600 + 29 * 24 * 3600, + ), +) + ++ test.case.new( + name='toUnixTimestamp of 1974-01-01 00:00:00 (incl leap year)', + test=test.expect.eq( + actual=xtd.date.toUnixTimestamp(1974, 1, 1, 0, 0, 0), + expected=(4 * 365 + 1) * 24 * 3600, + ), +) + ++ test.case.new( + name='toUnixTimestamp of 2020-01-02 03:04:05 (full date)', + test=test.expect.eq( + actual=xtd.date.toUnixTimestamp(2020, 1, 2, 3, 4, 5), + expected=1577934245, + ), +) + ++ test.case.new( + name='parseRFC3339 of 1970-01-01T00:00:00Z (standard unix zero)', + test=test.expect.eq( + actual=xtd.date.parseRFC3339('1970-01-01T00:00:00Z'), + expected={ year: 1970, month: 1, day: 1, hour: 0, minute: 0, second: 0 }, + ), +) + ++ test.case.new( + name='parseRFC3339 of 2020-01-02T03:04:05Z (non-zero date)', + test=test.expect.eq( + actual=xtd.date.parseRFC3339('2020-01-02T03:04:05Z'), + expected={ year: 2020, month: 1, day: 2, hour: 3, minute: 4, second: 5 }, + ), +) + ++ test.case.new( + name='parseRFC3339 of 2020-01-02 03:04:05Z (space separator)', + test=test.expect.eq( + actual=xtd.date.parseRFC3339('2020-01-02 03:04:05Z'), + expected={ year: 2020, month: 1, day: 2, hour: 3, minute: 4, second: 5 }, + ), +) + ++ test.case.new( + name='parseRFC3339 of 2020-01-02t03:04:05Z (lowercase t separator and lowercase z)', + test=test.expect.eq( + actual=xtd.date.parseRFC3339('2020-01-02t03:04:05z'), + expected={ year: 2020, month: 1, day: 2, hour: 3, minute: 4, second: 5 }, + ), +) + ++ test.case.new( + name='parseRFC3339(..).toUnixTimestamp()', + test=test.expect.eq( + actual=xtd.date.parseRFC3339('2020-01-02T03:04:05Z').toUnixTimestamp(), + expected=1577934245, + ), +) diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/test/inspect_test.jsonnet b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/test/inspect_test.jsonnet new file mode 100644 index 0000000000..54510ea05d --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/test/inspect_test.jsonnet @@ -0,0 +1,152 @@ +local xtd = import '../main.libsonnet'; +local test = import 'github.com/jsonnet-libs/testonnet/main.libsonnet'; + +test.new(std.thisFile) + ++ test.case.new( + name='emptyobject', + test=test.expect.eq( + actual=xtd.inspect.inspect({}), + expected={} + ) +) + ++ test.case.new( + name='flatObject', + test=test.expect.eq( + actual=xtd.inspect.inspect({ + key: 'value', + hidden_key:: 'value', + func(value): value, + hidden_func(value):: value, + }), + expected={ + fields: ['key'], + hidden_fields: ['hidden_key'], + functions: ['func'], + hidden_functions: ['hidden_func'], + } + ) +) + ++ test.case.new( + name='nestedObject', + test=test.expect.eq( + actual=xtd.inspect.inspect({ + nested: { + key: 'value', + hidden_key:: 'value', + func(value): value, + hidden_func(value):: value, + }, + key: 'value', + hidden_func(value):: value, + }), + expected={ + nested: { + fields: ['key'], + hidden_fields: ['hidden_key'], + functions: ['func'], + hidden_functions: ['hidden_func'], + }, + fields: ['key'], + hidden_functions: ['hidden_func'], + } + ) +) + ++ test.case.new( + name='maxRecursionDepth', + test=test.expect.eq( + actual=xtd.inspect.inspect({ + key: 'value', + nested: { + key: 'value', + nested: { + key: 'value', + }, + }, + }, maxDepth=1), + expected={ + fields: ['key'], + nested: { + fields: ['key', 'nested'], + }, + } + ) +) + ++ test.case.new( + name='noDiff', + test=test.expect.eq( + actual=xtd.inspect.diff('', ''), + expected='' + ) +) ++ test.case.new( + name='typeDiff', + test=test.expect.eq( + actual=xtd.inspect.diff('string', true), + expected='~[ string , true ]' + ) +) ++ ( + local input1 = { + same: 'same', + change: 'this', + remove: 'removed', + }; + local input2 = { + same: 'same', + change: 'changed', + add: 'added', + }; + test.case.new( + name='objectDiff', + test=test.expect.eq( + actual=xtd.inspect.diff(input1, input2), + expected={ + 'add +': 'added', + 'change ~': '~[ this , changed ]', + 'remove -': 'removed', + } + ) + ) +) + ++ ( + local input1 = [ + 'same', + 'this', + [ + 'same', + 'this', + ], + 'remove', + ]; + local input2 = [ + 'same', + 'changed', + [ + 'same', + 'changed', + 'added', + ], + ]; + test.case.new( + name='arrayDiff', + test=test.expect.eq( + actual=xtd.inspect.diff(input1, input2), + expected=[ + 'same', + '~[ this , changed ]', + [ + 'same', + '~[ this , changed ]', + '+ added', + ], + '- remove', + ] + ) + ) +) diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/test/jsonnetfile.json b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/test/jsonnetfile.json new file mode 100644 index 0000000000..ce9ad4d5ac --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/test/jsonnetfile.json @@ -0,0 +1,15 @@ +{ + "version": 1, + "dependencies": [ + { + "source": { + "git": { + "remote": "https://github.com/jsonnet-libs/testonnet.git", + "subdir": "" + } + }, + "version": "master" + } + ], + "legacyImports": true +} diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/test/jsonpath_test.jsonnet b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/test/jsonpath_test.jsonnet new file mode 100644 index 0000000000..8c1106b1df --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/test/jsonpath_test.jsonnet @@ -0,0 +1,305 @@ +local jsonpath = import '../jsonpath.libsonnet'; +local test = import 'github.com/jsonnet-libs/testonnet/main.libsonnet'; + +test.new(std.thisFile) + +// Root ++ test.case.new( + name='root $', + test=test.expect.eq( + actual=jsonpath.getJSONPath({ key: 'content' }, '$'), + expected={ key: 'content' }, + ) +) ++ test.case.new( + name='root (empty path)', + test=test.expect.eq( + actual=jsonpath.getJSONPath({ key: 'content' }, ''), + expected={ key: 'content' }, + ) +) ++ test.case.new( + name='root .', + test=test.expect.eq( + actual=jsonpath.getJSONPath({ key: 'content' }, '.'), + expected={ key: 'content' }, + ) +) + +// Single key ++ test.case.new( + name='path without dot prefix', + test=test.expect.eq( + actual=jsonpath.getJSONPath({ key: 'content' }, 'key'), + expected='content', + ) +) ++ test.case.new( + name='single key', + test=test.expect.eq( + actual=jsonpath.getJSONPath({ key: 'content' }, '.key'), + expected='content', + ) +) ++ test.case.new( + name='single bracket key', + test=test.expect.eq( + actual=jsonpath.getJSONPath({ key: 'content' }, '[key]'), + expected='content', + ) +) ++ test.case.new( + name='single bracket key with $', + test=test.expect.eq( + actual=jsonpath.getJSONPath({ key: 'content' }, '$[key]'), + expected='content', + ) +) ++ test.case.new( + name='single array index', + test=test.expect.eq( + actual=jsonpath.getJSONPath(['content'], '.[0]'), + expected='content', + ) +) ++ test.case.new( + name='single array index without dot prefix', + test=test.expect.eq( + actual=jsonpath.getJSONPath(['content'], '[0]'), + expected='content', + ) +) + +// Nested ++ test.case.new( + name='nested key', + test=test.expect.eq( + actual=jsonpath.getJSONPath( + { key1: { key2: { key3: 'content' } } }, + '.key1.key2.key3' + ), + expected='content', + ) +) ++ test.case.new( + name='nested bracket key', + test=test.expect.eq( + actual=jsonpath.getJSONPath( + { key1: { key2: { key3: 'content' } } }, + '.key1.key2[key3]' + ), + expected='content', + ) +) ++ test.case.new( + name='nested bracket key (quoted)', + test=test.expect.eq( + actual=jsonpath.getJSONPath( + { key1: { key2: { key3: 'content' } } }, + ".key1.key2['key3']" + ), + expected='content', + ) +) ++ test.case.new( + name='nested bracket star key', + test=test.expect.eq( + actual=jsonpath.getJSONPath( + { key1: { key2: { key3: 'content' } } }, + '.key1.key2[*]' + ), + expected={ key3: 'content' }, + ) +) ++ test.case.new( + name='nested array index', + test=test.expect.eq( + actual=jsonpath.getJSONPath( + { key1: { key2: ['content1', 'content2'] } }, + '.key1.key2[1]' + ), + expected='content2', + ) +) ++ test.case.new( + name='nested array index with $', + test=test.expect.eq( + actual=jsonpath.getJSONPath( + { key1: { key2: ['content1', 'content2'] } }, + '$.key1.key2[1]' + ), + expected='content2', + ) +) ++ test.case.new( + name='nested array index without brackets', + test=test.expect.eq( + actual=jsonpath.getJSONPath( + { key1: { key2: ['content1', 'content2'] } }, + '.key1.key2.1' + ), + expected='content2', + ) +) ++ test.case.new( + name='nested array star index', + test=test.expect.eq( + actual=jsonpath.getJSONPath( + { key1: { key2: ['content1', 'content2'] } }, + '.key1.key2[*]' + ), + expected=['content1', 'content2'], + ) +) ++ test.case.new( + name='nested bracket keys and array index combo', + test=test.expect.eq( + actual=jsonpath.getJSONPath( + { key1: { key2: ['content1', 'content2'] } }, + '$.[key1][key2][1]' + ), + expected='content2', + ) +) ++ test.case.new( + name='all keys in bracket and quoted', + test=test.expect.eq( + actual=jsonpath.getJSONPath( + { key1: { key2: ['content1', 'content2'] } }, + "$['key1']['key2']" + ), + expected=['content1', 'content2'], + ) +) + +// index range/slice ++ test.case.new( + name='array with index range (first two)', + test=test.expect.eq( + actual=jsonpath.getJSONPath( + { key: ['content1', 'content2', 'content3'] }, + 'key[0:2]' + ), + expected=['content1', 'content2'], + ) +) ++ test.case.new( + name='array with index range (last two)', + test=test.expect.eq( + actual=jsonpath.getJSONPath( + { key: ['content1', 'content2', 'content3'] }, + 'key[1:3]' + ), + expected=['content2', 'content3'], + ) +) ++ test.case.new( + name='array with index range (until end)', + test=test.expect.eq( + actual=jsonpath.getJSONPath( + { key: ['content1', 'content2', 'content3'] }, + 'key[1:]' + ), + expected=['content2', 'content3'], + ) +) ++ test.case.new( + name='array with index range (from beginning)', + test=test.expect.eq( + actual=jsonpath.getJSONPath( + { key: ['content1', 'content2', 'content3'] }, + 'key[:2]' + ), + expected=['content1', 'content2'], + ) +) ++ test.case.new( + name='array with index range (negative start)', + test=test.expect.eq( + actual=jsonpath.getJSONPath( + { key: ['content1', 'content2', 'content3'] }, + 'key[-2:]' + ), + expected=['content2', 'content3'], + ) +) ++ test.case.new( + name='array with index range (negative end)', + test=test.expect.eq( + actual=jsonpath.getJSONPath( + { key: ['content1', 'content2', 'content3'] }, + 'key[:-1]' + ), + expected=['content1', 'content2'], + ) +) ++ test.case.new( + name='array with index range (step)', + test=test.expect.eq( + actual=jsonpath.getJSONPath( + { key: [ + 'content%s' % i + for i in std.range(1, 10) + ] }, + 'key[:5:2]' + ), + expected=['content1', 'content3', 'content5'], + ) +) + +// filter expr ++ test.case.new( + name='array with filter expression - string', + test=test.expect.eq( + actual=jsonpath.getJSONPath( + { key: [ + { + key: 'content%s' % i, + } + for i in std.range(1, 10) + ] }, + '.key[?(@.key==content2)]' + ), + expected=[{ + key: 'content2', + }], + ) +) ++ test.case.new( + name='array with filter expression - number', + test=test.expect.eq( + actual=jsonpath.getJSONPath( + { key: [ + { + count: i, + } + for i in std.range(1, 10) + ] }, + '.key[?(@.count<=2)]' + ), + expected=[{ + count: 1, + }, { + count: 2, + }], + ) +) ++ test.case.new( + name='array with filter expression - has key', + test=test.expect.eq( + actual=jsonpath.getJSONPath( + { key: [ + { + key1: 'value', + }, + { + key2: 'value', + }, + ] }, + '.key[?(@.key1)]' + ), + expected=[{ + key1: 'value', + }], + ) +) diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/test/url_test.jsonnet b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/test/url_test.jsonnet new file mode 100644 index 0000000000..b2393a27e7 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/test/url_test.jsonnet @@ -0,0 +1,209 @@ +local xtd = import '../main.libsonnet'; +local test = import 'github.com/jsonnet-libs/testonnet/main.libsonnet'; + +test.new(std.thisFile) ++ test.case.new( + name='empty', + test=test.expect.eq( + actual=xtd.url.escapeString(''), + expected='', + ) +) + ++ test.case.new( + name='abc', + test=test.expect.eq( + actual=xtd.url.escapeString('abc'), + expected='abc', + ) +) + ++ test.case.new( + name='space', + test=test.expect.eq( + actual=xtd.url.escapeString('one two'), + expected='one%20two', + ) +) + ++ test.case.new( + name='percent', + test=test.expect.eq( + actual=xtd.url.escapeString('10%'), + expected='10%25', + ) +) + ++ test.case.new( + name='complex', + test=test.expect.eq( + actual=xtd.url.escapeString(" ?&=#+%!<>#\"{}|\\^[]`☺\t:/@$'()*,;"), + expected='%20%3F%26%3D%23%2B%25%21%3C%3E%23%22%7B%7D%7C%5C%5E%5B%5D%60%E2%98%BA%09%3A%2F%40%24%27%28%29%2A%2C%3B', + ) +) + ++ test.case.new( + name='exclusions', + test=test.expect.eq( + actual=xtd.url.escapeString('hello, world', [',']), + expected='hello,%20world', + ) +) + ++ test.case.new( + name='multiple exclusions', + test=test.expect.eq( + actual=xtd.url.escapeString('hello, world,&', [',', '&']), + expected='hello,%20world,&', + ) +) + ++ test.case.new( + name='empty', + test=test.expect.eq( + actual=xtd.url.encodeQuery({}), + expected='', + ) +) + ++ test.case.new( + name='simple', + test=test.expect.eq( + actual=xtd.url.encodeQuery({ q: 'puppies', oe: 'utf8' }), + expected='oe=utf8&q=puppies', + ) +) + +// url.parse ++ test.case.new( + name='Full absolute URL', + test=test.expect.eqJson( + actual=xtd.url.parse('https://example.com/path/to/location;type=person?name=john#address'), + expected={ + scheme: 'https', + netloc: 'example.com', + hostname: 'example.com', + path: '/path/to/location', + params: 'type=person', + query: 'name=john', + fragment: 'address', + }, + ) +) + ++ test.case.new( + name='URL with fragment before params and query', + test=test.expect.eqJson( + actual=xtd.url.parse('https://example.com/path/to/location#address;type=person?name=john'), + expected={ + scheme: 'https', + netloc: 'example.com', + hostname: 'example.com', + path: '/path/to/location', + fragment: 'address;type=person?name=john', + }, + ) +) + ++ test.case.new( + name='URL without query', + test=test.expect.eqJson( + actual=xtd.url.parse('https://example.com/path/to/location;type=person#address'), + expected={ + scheme: 'https', + netloc: 'example.com', + hostname: 'example.com', + path: '/path/to/location', + params: 'type=person', + fragment: 'address', + }, + ) +) + ++ test.case.new( + name='URL without params', + test=test.expect.eqJson( + actual=xtd.url.parse('https://example.com/path/to/location?name=john#address'), + expected={ + scheme: 'https', + netloc: 'example.com', + hostname: 'example.com', + path: '/path/to/location', + query: 'name=john', + fragment: 'address', + }, + ) +) + ++ test.case.new( + name='URL with empty fragment', + test=test.expect.eqJson( + actual=xtd.url.parse('https://example.com/path/to/location#'), + expected={ + scheme: 'https', + netloc: 'example.com', + hostname: 'example.com', + path: '/path/to/location', + fragment: '', + }, + ) +) + ++ test.case.new( + name='host with port', + test=test.expect.eqJson( + actual=xtd.url.parse('//example.com:80'), + expected={ + netloc: 'example.com:80', + hostname: 'example.com', + port: '80', + }, + ) +) + ++ test.case.new( + name='mailto', + test=test.expect.eqJson( + actual=xtd.url.parse('mailto:john@example.com'), + expected={ + scheme: 'mailto', + path: 'john@example.com', + }, + ) +) + ++ test.case.new( + name='UserInfo', + test=test.expect.eqJson( + actual=xtd.url.parse('ftp://admin:password@example.com'), + + expected={ + hostname: 'example.com', + netloc: 'admin:password@example.com', + scheme: 'ftp', + username: 'admin', + password: 'password', + } + , + ) +) + ++ test.case.new( + name='Relative URL only', + test=test.expect.eqJson( + actual=xtd.url.parse('/path/to/location'), + expected={ + path: '/path/to/location', + }, + ) +) + ++ test.case.new( + name='URL fragment only', + test=test.expect.eqJson( + actual=xtd.url.parse('#fragment_only'), + expected={ + fragment: 'fragment_only', + }, + ) +) diff --git a/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/url.libsonnet b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/url.libsonnet new file mode 100644 index 0000000000..32d1a30255 --- /dev/null +++ b/docs/node-observ-lib/vendor/github.com/jsonnet-libs/xtd/url.libsonnet @@ -0,0 +1,111 @@ +local d = import 'doc-util/main.libsonnet'; + +{ + '#': d.pkg( + name='url', + url='github.com/jsonnet-libs/xtd/url.libsonnet', + help='`url` provides functions to deal with URLs', + ), + + '#escapeString': d.fn( + '`escapeString` escapes the given string so it can be safely placed inside an URL, replacing special characters with `%XX` sequences', + args=[ + d.arg('str', d.T.string), + d.arg('excludedChars', d.T.array, default=[]), + ], + ), + escapeString(str, excludedChars=[]):: + local allowedChars = '0123456789abcdefghijklmnopqrstuvwqxyzABCDEFGHIJKLMNOPQRSTUVWQXYZ'; + local utf8(char) = std.foldl(function(a, b) a + '%%%02X' % b, std.encodeUTF8(char), ''); + local escapeChar(char) = if std.member(excludedChars, char) || std.member(allowedChars, char) then char else utf8(char); + std.join('', std.map(escapeChar, std.stringChars(str))), + + '#encodeQuery': d.fn( + '`encodeQuery` takes an object of query parameters and returns them as an escaped `key=value` string', + args=[d.arg('params', d.T.object)], + ), + encodeQuery(params):: + local fmtParam(p) = '%s=%s' % [self.escapeString(p), self.escapeString(params[p])]; + std.join('&', std.map(fmtParam, std.objectFields(params))), + + '#parse': d.fn( + ||| + `parse` parses absolute and relative URLs. + + :///;parameters?# + + Inspired by Python's urllib.urlparse, following several RFC specifications. + |||, + args=[d.arg('url', d.T.string)], + ), + parse(url): + local hasFragment = std.member(url, '#'); + local fragmentSplit = std.splitLimit(url, '#', 1); + local fragment = fragmentSplit[1]; + + local hasQuery = std.member(fragmentSplit[0], '?'); + local querySplit = std.splitLimit(fragmentSplit[0], '?', 1); + local query = querySplit[1]; + + local hasParams = std.member(querySplit[0], ';'); + local paramsSplit = std.splitLimit(querySplit[0], ';', 1); + local params = paramsSplit[1]; + + local hasNetLoc = std.member(paramsSplit[0], '//'); + local netLocSplit = std.splitLimit(paramsSplit[0], '//', 1); + local netLoc = std.splitLimit(netLocSplit[1], '/', 1)[0]; + + local hasScheme = std.member(netLocSplit[0], ':'); + local schemeSplit = std.splitLimit(netLocSplit[0], ':', 1); + local scheme = schemeSplit[0]; + + local path = + if hasNetLoc && std.member(netLocSplit[1], '/') + then '/' + std.splitLimit(netLocSplit[1], '/', 1)[1] + else if hasScheme + then schemeSplit[1] + else netLocSplit[0]; + local hasPath = (path != ''); + + local hasUserInfo = hasNetLoc && std.member(netLoc, '@'); + local userInfoSplit = std.reverse(std.splitLimitR(netLoc, '@', 1)); + local userInfo = userInfoSplit[1]; + + local hasPassword = hasUserInfo && std.member(userInfo, ':'); + local passwordSplit = std.splitLimitR(userInfo, ':', 1); + local username = passwordSplit[0]; + local password = passwordSplit[1]; + + local hasPort = hasNetLoc && std.length(std.findSubstr(':', userInfoSplit[0])) > 0; + local portSplit = std.splitLimitR(userInfoSplit[0], ':', 1); + local host = portSplit[0]; + local port = portSplit[1]; + + { + [if hasScheme then 'scheme']: scheme, + [if hasNetLoc then 'netloc']: netLoc, + [if hasPath then 'path']: path, + [if hasParams then 'params']: params, + [if hasQuery then 'query']: query, + [if hasFragment then 'fragment']: fragment, + + [if hasUserInfo then 'username']: username, + [if hasPassword then 'password']: password, + [if hasNetLoc then 'hostname']: host, + [if hasPort then 'port']: port, + }, + + '#join': d.fn( + '`join` joins URLs from the object generated from `parse`', + args=[d.arg('splitObj', d.T.object)], + ), + join(splitObj): + std.join('', [ + if 'scheme' in splitObj then splitObj.scheme + ':' else '', + if 'netloc' in splitObj then '//' + splitObj.netloc else '', + if 'path' in splitObj then splitObj.path else '', + if 'params' in splitObj then ';' + splitObj.params else '', + if 'query' in splitObj then '?' + splitObj.query else '', + if 'fragment' in splitObj then '#' + splitObj.fragment else '', + ]), +} diff --git a/docs/node-observ-lib/vendor/grafonnet-v10.0.0 b/docs/node-observ-lib/vendor/grafonnet-v10.0.0 new file mode 120000 index 0000000000..3749c7b1cd --- /dev/null +++ b/docs/node-observ-lib/vendor/grafonnet-v10.0.0 @@ -0,0 +1 @@ +github.com/grafana/grafonnet/gen/grafonnet-v10.0.0 \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/logs-lib b/docs/node-observ-lib/vendor/logs-lib new file mode 120000 index 0000000000..1cb359d54d --- /dev/null +++ b/docs/node-observ-lib/vendor/logs-lib @@ -0,0 +1 @@ +github.com/grafana/jsonnet-libs/logs-lib \ No newline at end of file diff --git a/docs/node-observ-lib/vendor/xtd b/docs/node-observ-lib/vendor/xtd new file mode 120000 index 0000000000..68b106aa33 --- /dev/null +++ b/docs/node-observ-lib/vendor/xtd @@ -0,0 +1 @@ +github.com/jsonnet-libs/xtd \ No newline at end of file