@dynatrace-sdk/client-classic-environment-v2 0.6.1

package/types/packages/client/classic-environment-v2/src/lib/models/metric-descriptor.d.ts

@@ -0,0 +1,166 @@
+import { MetricDefaultAggregation, _MetricDefaultAggregationTransformation } from './metric-default-aggregation';
+import { MetricDescriptorAggregationTypesItem, _MetricDescriptorAggregationTypesItemTransformation } from './metric-descriptor-aggregation-types-item';
+import { MetricDescriptorTransformationsItem, _MetricDescriptorTransformationsItemTransformation } from './metric-descriptor-transformations-item';
+import { MetricDescriptorUnitDisplayFormat, _MetricDescriptorUnitDisplayFormatTransformation } from './metric-descriptor-unit-display-format';
+import { MetricDimensionCardinality, _MetricDimensionCardinalityTransformation } from './metric-dimension-cardinality';
+import { MetricDimensionDefinition, _MetricDimensionDefinitionTransformation } from './metric-dimension-definition';
+import { MetricValueType, _MetricValueTypeTransformation } from './metric-value-type';
+/**
+ * The descriptor of a metric.
+ */
+export interface MetricDescriptor {
+    /**
+     * The metric is (`true`) or is not (`false`) impact relevant.
+     *
+     *  An impact-relevant metric is highly dependent on other metrics and changes because an underlying root-cause metric has changed.
+     *
+     *  [Metric expressions](https://dt-url.net/metricExpression) don't return this field.
+     */
+    impactRelevant?: boolean;
+    /**
+     * The minimum allowed value of the metric.
+     *
+     *  [Metric expressions](https://dt-url.net/metricExpression) don't return this field.
+     */
+    minimumValue?: number;
+    /**
+     * The maximum allowed value of the metric.
+     *
+     *  [Metric expressions](https://dt-url.net/metricExpression) don't return this field.
+     */
+    maximumValue?: number;
+    /**
+     * The latency of the metric, in minutes.
+     *
+     *  The latency is the expected reporting delay (for example, caused by constraints of cloud vendors or other third-party data sources) between the observation of a metric data point and its availability in Dynatrace.
+     *
+     * The allowed value range is from 1 to 60 minutes.
+     *
+     *  [Metric expressions](https://dt-url.net/metricExpression) don't return this field.
+     */
+    latency?: number;
+    /**
+     * If 'true', resolution=Inf can be applied to the metric query.
+     */
+    resolutionInfSupported?: boolean;
+    unitDisplayFormat?: MetricDescriptorUnitDisplayFormat;
+    /**
+     * The cardinalities of MINT metric dimensions.
+     */
+    dimensionCardinalities?: MetricDimensionCardinality[];
+    /**
+     * The metric is (`true`) or is not (`false`) root cause relevant.
+     *
+     *  A root-cause relevant metric represents a strong indicator for a faulty component.
+     *
+     *  [Metric expressions](https://dt-url.net/metricExpression) don't return this field.
+     */
+    rootCauseRelevant?: boolean;
+    defaultAggregation?: MetricDefaultAggregation;
+    /**
+     * The fine metric division (for example, process group and process ID for some process-related metric).
+     *
+     * For [ingested metrics](https://dt-url.net/5d63ic1), dimensions that doesn't have have any data within the last 15 days are omitted.
+     */
+    dimensionDefinitions?: MetricDimensionDefinition[];
+    /**
+     * The timestamp when the metric was last written.
+     *
+     * Has the value of `null` for metric expressions or if the data has never been written.
+     */
+    lastWritten?: number;
+    /**
+     * If `true` the usage of metric consumes [Davis data units](https://dt-url.net/ddu).
+     *
+     *  [Metric expressions](https://dt-url.net/metricExpression) don't return this field.
+     */
+    dduBillable?: boolean;
+    metricValueType?: MetricValueType;
+    /**
+     * The tags applied to the metric.
+     *
+     *  [Metric expressions](https://dt-url.net/metricExpression) don't return this field.
+     */
+    tags?: string[];
+    /**
+     * List of admissible primary entity types for this metric. Can be used for the `type` predicate in the `entitySelector`.
+     */
+    entityType?: string[];
+    /**
+     * Indicates whether the metric expression resolves to a scalar (`true`) or to a series (`false`).
+     * A scalar result always contains one data point. The amount of data points in a series result depends on the resolution you're using.
+     */
+    scalar?: boolean;
+    /**
+     * The fully qualified key of the metric.
+     *
+     * If a transformation has been used it is reflected in the metric key.
+     */
+    metricId: string;
+    /**
+     * The metric selector that is used when querying a func: metric.
+     */
+    metricSelector?: string;
+    /**
+     * The list of allowed aggregations for this metric.
+     */
+    aggregationTypes?: MetricDescriptorAggregationTypesItem[];
+    /**
+     * The timestamp of metric creation.
+     *
+     * Built-in metrics and metric expressions have the value of `null`.
+     */
+    created?: number;
+    /**
+     * The name of the metric in the user interface.
+     */
+    displayName?: string;
+    /**
+     * A short description of the metric.
+     */
+    description?: string;
+    /**
+     * Transform operators that could be appended to the current transformation list.
+     */
+    transformations?: MetricDescriptorTransformationsItem[];
+    /**
+     * The unit of the metric.
+     */
+    unit?: string;
+    /**
+     * A list of potential warnings that affect this ID. For example deprecated feature usage etc.
+     */
+    warnings?: string[];
+}
+/** @ignore */
+export declare namespace _MetricDescriptorTransformation {
+    interface AsJson {
+        impactRelevant?: boolean;
+        minimumValue?: number;
+        maximumValue?: number;
+        latency?: number;
+        resolutionInfSupported?: boolean;
+        unitDisplayFormat?: _MetricDescriptorUnitDisplayFormatTransformation.AsJson;
+        dimensionCardinalities?: _MetricDimensionCardinalityTransformation.AsJson[];
+        rootCauseRelevant?: boolean;
+        defaultAggregation?: _MetricDefaultAggregationTransformation.AsJson;
+        dimensionDefinitions?: _MetricDimensionDefinitionTransformation.AsJson[];
+        lastWritten?: number;
+        dduBillable?: boolean;
+        metricValueType?: _MetricValueTypeTransformation.AsJson;
+        tags?: string[];
+        entityType?: string[];
+        scalar?: boolean;
+        metricId: string;
+        metricSelector?: string;
+        aggregationTypes?: _MetricDescriptorAggregationTypesItemTransformation.AsJson[];
+        created?: number;
+        displayName?: string;
+        description?: string;
+        transformations?: _MetricDescriptorTransformationsItemTransformation.AsJson[];
+        unit?: string;
+        warnings?: string[];
+    }
+    function fromJson(model: AsJson): MetricDescriptor;
+    function toJson(model: MetricDescriptor): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/metric-dimension-cardinality.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The dimension cardinalities of a metric.
+ */
+export interface MetricDimensionCardinality {
+    /**
+     * The relative cardinality of the dimension expressed as percentage
+     */
+    relative: number;
+    /**
+     * The key of the dimension.
+     *
+     *  It must be unique within the metric.
+     */
+    key: string;
+    /**
+     * The cardinality estimate of the dimension.
+     */
+    estimate: number;
+}
+/** @ignore */
+export declare namespace _MetricDimensionCardinalityTransformation {
+    interface AsJson {
+        relative: number;
+        key: string;
+        estimate: number;
+    }
+    function fromJson(model: AsJson): MetricDimensionCardinality;
+    function toJson(model: MetricDimensionCardinality): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/metric-dimension-definition-type.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The type of the dimension.
+ */
+export declare enum MetricDimensionDefinitionType {
+    Entity = "ENTITY",
+    Number = "NUMBER",
+    Other = "OTHER",
+    String = "STRING",
+    Void = "VOID"
+}
+/** @ignore */
+export declare namespace _MetricDimensionDefinitionTypeTransformation {
+    type AsJson = MetricDimensionDefinitionType;
+    const toJson: (value: MetricDimensionDefinitionType) => AsJson;
+    const fromJson: (value: AsJson) => MetricDimensionDefinitionType;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/metric-dimension-definition.d.ts

@@ -0,0 +1,39 @@
+import { MetricDimensionDefinitionType, _MetricDimensionDefinitionTypeTransformation } from './metric-dimension-definition-type';
+/**
+ * The dimension of a metric.
+ */
+export interface MetricDimensionDefinition {
+    /**
+     * The display name of the dimension.
+     */
+    displayName: string;
+    /**
+     * The name of the dimension.
+     */
+    name: string;
+    /**
+     * The key of the dimension.
+     *
+     *  It must be unique within the metric.
+     */
+    key: string;
+    type: MetricDimensionDefinitionType;
+    /**
+     * The unique 0-based index of the dimension.
+     *
+     *  Appending transformations such as :names or :parents may change the indexes of dimensions. `null` is used for the dimensions of a metric with flexible dimensions, which can be referenced with their dimension key, but do not have an intrinsic order that could be used for the index.
+     */
+    index: number;
+}
+/** @ignore */
+export declare namespace _MetricDimensionDefinitionTransformation {
+    interface AsJson {
+        displayName: string;
+        name: string;
+        key: string;
+        type: _MetricDimensionDefinitionTypeTransformation.AsJson;
+        index: number;
+    }
+    function fromJson(model: AsJson): MetricDimensionDefinition;
+    function toJson(model: MetricDimensionDefinition): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/metric-dto.d.ts

@@ -0,0 +1,20 @@
+import { MetricMetadataDto, _MetricMetadataDtoTransformation } from './metric-metadata-dto';
+/**
+ * Metric gathered by an extension
+ */
+export interface MetricDto {
+    /**
+     * Metric key
+     */
+    key?: string;
+    metadata?: MetricMetadataDto;
+}
+/** @ignore */
+export declare namespace _MetricDtoTransformation {
+    interface AsJson {
+        key?: string;
+        metadata?: _MetricMetadataDtoTransformation.AsJson;
+    }
+    function fromJson(model: AsJson): MetricDto;
+    function toJson(model: MetricDto): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/metric-evidence.d.ts

@@ -0,0 +1,42 @@
+import { Evidence, _EvidenceTransformation } from './evidence';
+/**
+ * The metric evidence of the problem.
+ *
+ * A change of metric behavior that indicates the problem and/or is its root cause.
+ */
+export interface MetricEvidence extends Evidence {
+    /**
+     * The metric's value after the problem start.
+     */
+    valueAfterChangePoint?: number;
+    /**
+     * The metric's value before the problem start.
+     */
+    valueBeforeChangePoint?: number;
+    /**
+     * The ID of the metric.
+     */
+    metricId?: string;
+    /**
+     * The end time of the evidence, in UTC milliseconds.
+     *
+     * The value `null` indicates that the evidence is still open.
+     */
+    endTime?: number;
+    /**
+     * The unit of the metric.
+     */
+    unit?: string;
+}
+/** @ignore */
+export declare namespace _MetricEvidenceTransformation {
+    interface AsJson extends _EvidenceTransformation.AsJson {
+        valueAfterChangePoint?: number;
+        valueBeforeChangePoint?: number;
+        metricId?: string;
+        endTime?: number;
+        unit?: string;
+    }
+    function fromJson(model: AsJson): MetricEvidence;
+    function toJson(model: MetricEvidence): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/metric-ingest-error.d.ts

@@ -0,0 +1,16 @@
+import { InvalidLine, _InvalidLineTransformation } from './invalid-line';
+export interface MetricIngestError {
+    invalidLines?: InvalidLine[];
+    message?: string;
+    code?: number;
+}
+/** @ignore */
+export declare namespace _MetricIngestErrorTransformation {
+    interface AsJson {
+        invalidLines?: _InvalidLineTransformation.AsJson[];
+        message?: string;
+        code?: number;
+    }
+    function fromJson(model: AsJson): MetricIngestError;
+    function toJson(model: MetricIngestError): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/metric-metadata-dto.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Metric metadata
+ */
+export interface MetricMetadataDto {
+    /**
+     * The name of the metric in the user interface
+     */
+    displayName?: string;
+    /**
+     * A short description of the metric
+     */
+    description?: string;
+    /**
+     * The unit of the metric
+     */
+    unit?: string;
+}
+/** @ignore */
+export declare namespace _MetricMetadataDtoTransformation {
+    interface AsJson {
+        displayName?: string;
+        description?: string;
+        unit?: string;
+    }
+    function fromJson(model: AsJson): MetricMetadataDto;
+    function toJson(model: MetricMetadataDto): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/metric-series-collection.d.ts

@@ -0,0 +1,46 @@
+import { AppliedFilter, _AppliedFilterTransformation } from './applied-filter';
+import { MetricSeries, _MetricSeriesTransformation } from './metric-series';
+/**
+ * Data points of a metric.
+ */
+export interface MetricSeriesCollection {
+    /**
+     * A list of filtered metric keys along with filters that have been applied to these keys, from the `optionalFilter` parameter.
+     */
+    appliedOptionalFilters?: AppliedFilter[];
+    /**
+     * The ratio of queried data points divided by the maximum number of data points per metric that are allowed in a single query.
+     */
+    dataPointCountRatio: number;
+    /**
+     * The ratio of queried dimension tuples divided by the maximum number of dimension tuples allowed in a single query.
+     */
+    dimensionCountRatio: number;
+    /**
+     * The key of the metric.
+     *
+     * If any transformation is applied, it is included here.
+     */
+    metricId: string;
+    /**
+     * Data points of the metric.
+     */
+    data: MetricSeries[];
+    /**
+     * A list of potential warnings that affect this ID. For example deprecated feature usage etc.
+     */
+    warnings?: string[];
+}
+/** @ignore */
+export declare namespace _MetricSeriesCollectionTransformation {
+    interface AsJson {
+        appliedOptionalFilters?: _AppliedFilterTransformation.AsJson[];
+        dataPointCountRatio: number;
+        dimensionCountRatio: number;
+        metricId: string;
+        data: _MetricSeriesTransformation.AsJson[];
+        warnings?: string[];
+    }
+    function fromJson(model: AsJson): MetricSeriesCollection;
+    function toJson(model: MetricSeriesCollection): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/metric-series-dimension-map.d.ts

@@ -0,0 +1,11 @@
+export interface MetricSeriesDimensionMap {
+    [propName: string]: string | undefined;
+}
+/** @ignore */
+export declare namespace _MetricSeriesDimensionMapTransformation {
+    interface AsJson {
+        [propName: string]: string | undefined;
+    }
+    function fromJson(model: AsJson): MetricSeriesDimensionMap;
+    function toJson(model: MetricSeriesDimensionMap): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/metric-series.d.ts

@@ -0,0 +1,38 @@
+import { MetricSeriesDimensionMap, _MetricSeriesDimensionMapTransformation } from './metric-series-dimension-map';
+/**
+ * Data points per dimension of a metric.
+ *
+ * The data is represented by two arrays of the same length: **timestamps** and **values**. Entries of the same index from both arrays form a timestamped data point.
+ */
+export interface MetricSeries {
+    dimensionMap: MetricSeriesDimensionMap;
+    /**
+     * A list of timestamps of data points.
+     *
+     * The value of data point for each time from this array is located in **values** array at the same index.
+     */
+    timestamps: number[];
+    /**
+     * The ordered list of dimensions to which the data point list belongs.
+     *
+     *  Each metric can have a certain number of dimensions. Dimensions exceeding this number are aggregated into one, which is shown as `null` here.
+     */
+    dimensions: string[];
+    /**
+     * A list of values of data points.
+     *
+     * The timestamp of data point for each value from this array is located in **timestamps** array at the same index.
+     */
+    values: number[];
+}
+/** @ignore */
+export declare namespace _MetricSeriesTransformation {
+    interface AsJson {
+        dimensionMap: _MetricSeriesDimensionMapTransformation.AsJson;
+        timestamps: number[];
+        dimensions: string[];
+        values: number[];
+    }
+    function fromJson(model: AsJson): MetricSeries;
+    function toJson(model: MetricSeries): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/metric-value-type-type.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The metric value type
+ */
+export declare enum MetricValueTypeType {
+    Error = "error",
+    Score = "score",
+    Unknown = "unknown"
+}
+/** @ignore */
+export declare namespace _MetricValueTypeTypeTransformation {
+    type AsJson = MetricValueTypeType;
+    const toJson: (value: MetricValueTypeType) => AsJson;
+    const fromJson: (value: AsJson) => MetricValueTypeType;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/metric-value-type.d.ts

@@ -0,0 +1,18 @@
+import { FormDataRequestBody, FormDataResponseBody } from '@dynatrace-sdk/http-client';
+import { MetricValueTypeType, _MetricValueTypeTypeTransformation } from './metric-value-type-type';
+/**
+ * The value type for the metric.
+ */
+export interface MetricValueType {
+    type: MetricValueTypeType;
+}
+/** @ignore */
+export declare namespace _MetricValueTypeTransformation {
+    interface AsJson {
+        type: _MetricValueTypeTypeTransformation.AsJson;
+    }
+    function fromJson(model: AsJson): MetricValueType;
+    function toJson(model: MetricValueType): AsJson;
+    function fromFormData(formData: FormDataResponseBody): MetricValueType;
+    function toFormData(model: MetricValueType): FormDataRequestBody;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/minimal-extension.d.ts

@@ -0,0 +1,22 @@
+/**
+ * A list of extensions.
+ */
+export interface MinimalExtension {
+    /**
+     * Extension name
+     */
+    extensionName?: string;
+    /**
+     * Extension version
+     */
+    version?: string;
+}
+/** @ignore */
+export declare namespace _MinimalExtensionTransformation {
+    interface AsJson {
+        extensionName?: string;
+        version?: string;
+    }
+    function fromJson(model: AsJson): MinimalExtension;
+    function toJson(model: MinimalExtension): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/mobile-impact.d.ts

@@ -0,0 +1,13 @@
+import { Impact, _ImpactTransformation } from './impact';
+/**
+ * Analysis of problem impact to a mobile application.
+ */
+export interface MobileImpact extends Impact {
+}
+/** @ignore */
+export declare namespace _MobileImpactTransformation {
+    interface AsJson extends _ImpactTransformation.AsJson {
+    }
+    function fromJson(model: AsJson): MobileImpact;
+    function toJson(model: MobileImpact): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/monitor-execution-results.d.ts

@@ -0,0 +1,23 @@
+import { LocationExecutionResults, _LocationExecutionResultsTransformation } from './location-execution-results';
+/**
+ * Results of the execution of all HTTP monitor's requests.
+ */
+export interface MonitorExecutionResults {
+    /**
+     * Monitor id.
+     */
+    monitorId?: string;
+    /**
+     * The list with the results of the requests executed on assigned locations.
+     */
+    locationsExecutionResults?: LocationExecutionResults[];
+}
+/** @ignore */
+export declare namespace _MonitorExecutionResultsTransformation {
+    interface AsJson {
+        monitorId?: string;
+        locationsExecutionResults?: _LocationExecutionResultsTransformation.AsJson[];
+    }
+    function fromJson(model: AsJson): MonitorExecutionResults;
+    function toJson(model: MonitorExecutionResults): AsJson;
+}