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

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

@@ -0,0 +1,20 @@
+import { EventIngestResultStatus, _EventIngestResultStatusTransformation } from './event-ingest-result-status';
+/**
+ * The result of a created event report.
+ */
+export interface EventIngestResult {
+    status?: EventIngestResultStatus;
+    /**
+     * The correlation ID of the created event.
+     */
+    correlationId?: string;
+}
+/** @ignore */
+export declare namespace _EventIngestResultTransformation {
+    interface AsJson {
+        status?: _EventIngestResultStatusTransformation.AsJson;
+        correlationId?: string;
+    }
+    function fromJson(model: AsJson): EventIngestResult;
+    function toJson(model: EventIngestResult): AsJson;
+}

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

@@ -0,0 +1,23 @@
+import { EventIngestResult, _EventIngestResultTransformation } from './event-ingest-result';
+/**
+ * The results of an event ingest.
+ */
+export interface EventIngestResults {
+    /**
+     * The number of created event reports.
+     */
+    reportCount?: number;
+    /**
+     * The result of each created event report.
+     */
+    eventIngestResults?: EventIngestResult[];
+}
+/** @ignore */
+export declare namespace _EventIngestResultsTransformation {
+    interface AsJson {
+        reportCount?: number;
+        eventIngestResults?: _EventIngestResultTransformation.AsJson[];
+    }
+    function fromJson(model: AsJson): EventIngestResults;
+    function toJson(model: EventIngestResults): AsJson;
+}

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

@@ -0,0 +1,59 @@
+import { EventIngestEventType, _EventIngestEventTypeTransformation } from './event-ingest-event-type';
+import { EventIngestProperties, _EventIngestPropertiesTransformation } from './event-ingest-properties';
+/**
+ * The configuration of an event to be ingested.
+ */
+export interface EventIngest {
+    eventType: EventIngestEventType;
+    /**
+     * The title of the event.
+     */
+    title: string;
+    /**
+     * The start time of the event, in UTC milliseconds.
+     *
+     * If not set, the current timestamp is used.
+     *
+     * Depending on the event type, the start time must not lie in the future more than 5 minutes for trigger events and 7 days for info events.
+     */
+    startTime?: number;
+    /**
+     * The end time of the event, in UTC milliseconds.
+     *
+     * If not set, the start time plus timeout is used.
+     */
+    endTime?: number;
+    /**
+     * The timeout of the event, in minutes.
+     *
+     * If not set, 15 is used.
+     *
+     * The timeout will automatically be capped to a maximum of 360 minutes (6 hours).
+     *
+     * Problem-opening events can be refreshed and therefore kept open by sending the same payload again.
+     */
+    timeout?: number;
+    /**
+     * The [entity selector](https://dt-url.net/apientityselector), defining a set of Dynatrace entities to be associated with the event.
+     *
+     * Only entities that have been active within the last 24 hours can be selected.
+     *
+     *  If not set, the event is associated with the environment (`dt.entity.environment`) entity.
+     */
+    entitySelector?: string;
+    properties?: EventIngestProperties;
+}
+/** @ignore */
+export declare namespace _EventIngestTransformation {
+    interface AsJson {
+        eventType: _EventIngestEventTypeTransformation.AsJson;
+        title: string;
+        startTime?: number;
+        endTime?: number;
+        timeout?: number;
+        entitySelector?: string;
+        properties?: _EventIngestPropertiesTransformation.AsJson;
+    }
+    function fromJson(model: AsJson): EventIngest;
+    function toJson(model: EventIngest): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/event-list.d.ts

@@ -0,0 +1,40 @@
+import { Event, _EventTransformation } from './event';
+/**
+ * A list of events.
+ */
+export interface EventList {
+    /**
+     * A list of warnings.
+     */
+    warnings?: string[];
+    /**
+     * A list of events.
+     */
+    events?: Event[];
+    /**
+     * The number of entries per page.
+     */
+    pageSize?: number;
+    /**
+     * The cursor for the next page of results. Has the value of `null` on the last page.
+     *
+     * Use it in the **nextPageKey** query parameter to obtain subsequent pages of the result.
+     */
+    nextPageKey?: string;
+    /**
+     * The total number of entries in the result.
+     */
+    totalCount: number;
+}
+/** @ignore */
+export declare namespace _EventListTransformation {
+    interface AsJson {
+        warnings?: string[];
+        events?: _EventTransformation.AsJson[];
+        pageSize?: number;
+        nextPageKey?: string;
+        totalCount: number;
+    }
+    function fromJson(model: AsJson): EventList;
+    function toJson(model: EventList): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/event-property-detail.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Configuration of an event property.
+ */
+export interface EventPropertyDetail {
+    /**
+     * The display name of the event property.
+     */
+    displayName?: string;
+    /**
+     * Indicates whether the property may be set during event ingestion.
+     */
+    writable?: boolean;
+    /**
+     * The event property key.
+     */
+    key?: string;
+    /**
+     * A short description of the event property.
+     */
+    description?: string;
+}
+/** @ignore */
+export declare namespace _EventPropertyDetailTransformation {
+    interface AsJson {
+        displayName?: string;
+        writable?: boolean;
+        key?: string;
+        description?: string;
+    }
+    function fromJson(model: AsJson): EventPropertyDetail;
+    function toJson(model: EventPropertyDetail): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/event-property-details.d.ts

@@ -0,0 +1,35 @@
+import { EventPropertyDetail, _EventPropertyDetailTransformation } from './event-property-detail';
+/**
+ * A list of event properties.
+ */
+export interface EventPropertyDetails {
+    /**
+     * A list of event properties.
+     */
+    eventProperties?: EventPropertyDetail[];
+    /**
+     * The number of entries per page.
+     */
+    pageSize?: number;
+    /**
+     * The cursor for the next page of results. Has the value of `null` on the last page.
+     *
+     * Use it in the **nextPageKey** query parameter to obtain subsequent pages of the result.
+     */
+    nextPageKey?: string;
+    /**
+     * The total number of entries in the result.
+     */
+    totalCount: number;
+}
+/** @ignore */
+export declare namespace _EventPropertyDetailsTransformation {
+    interface AsJson {
+        eventProperties?: _EventPropertyDetailTransformation.AsJson[];
+        pageSize?: number;
+        nextPageKey?: string;
+        totalCount: number;
+    }
+    function fromJson(model: AsJson): EventPropertyDetails;
+    function toJson(model: EventPropertyDetails): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/event-property.d.ts

@@ -0,0 +1,22 @@
+/**
+ * A property of an event.
+ */
+export interface EventProperty {
+    /**
+     * The value of the event property.
+     */
+    value?: string;
+    /**
+     * The key of the event property.
+     */
+    key?: string;
+}
+/** @ignore */
+export declare namespace _EventPropertyTransformation {
+    interface AsJson {
+        value?: string;
+        key?: string;
+    }
+    function fromJson(model: AsJson): EventProperty;
+    function toJson(model: EventProperty): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/event-status.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The status of the event.
+ */
+export declare enum EventStatus {
+    Closed = "CLOSED",
+    Open = "OPEN"
+}
+/** @ignore */
+export declare namespace _EventStatusTransformation {
+    type AsJson = EventStatus;
+    const toJson: (value: EventStatus) => AsJson;
+    const fromJson: (value: AsJson) => EventStatus;
+}

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

@@ -0,0 +1,35 @@
+import { EventType, _EventTypeTransformation } from './event-type';
+/**
+ * A list of event types.
+ */
+export interface EventTypeList {
+    /**
+     * A list of event types.
+     */
+    eventTypeInfos?: EventType[];
+    /**
+     * The number of entries per page.
+     */
+    pageSize?: number;
+    /**
+     * The cursor for the next page of results. Has the value of `null` on the last page.
+     *
+     * Use it in the **nextPageKey** query parameter to obtain subsequent pages of the result.
+     */
+    nextPageKey?: string;
+    /**
+     * The total number of entries in the result.
+     */
+    totalCount: number;
+}
+/** @ignore */
+export declare namespace _EventTypeListTransformation {
+    interface AsJson {
+        eventTypeInfos?: _EventTypeTransformation.AsJson[];
+        pageSize?: number;
+        nextPageKey?: string;
+        totalCount: number;
+    }
+    function fromJson(model: AsJson): EventTypeList;
+    function toJson(model: EventTypeList): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/event-type-severity-level.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The severity level associated with the event type.
+ */
+export declare enum EventTypeSeverityLevel {
+    Availability = "AVAILABILITY",
+    CustomAlert = "CUSTOM_ALERT",
+    Error = "ERROR",
+    Info = "INFO",
+    MonitoringUnavailable = "MONITORING_UNAVAILABLE",
+    Performance = "PERFORMANCE",
+    ResourceContention = "RESOURCE_CONTENTION"
+}
+/** @ignore */
+export declare namespace _EventTypeSeverityLevelTransformation {
+    type AsJson = EventTypeSeverityLevel;
+    const toJson: (value: EventTypeSeverityLevel) => AsJson;
+    const fromJson: (value: AsJson) => EventTypeSeverityLevel;
+}

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

@@ -0,0 +1,30 @@
+import { EventTypeSeverityLevel, _EventTypeSeverityLevelTransformation } from './event-type-severity-level';
+/**
+ * Configuration of an event type.
+ */
+export interface EventType {
+    severityLevel?: EventTypeSeverityLevel;
+    /**
+     * The display name of the event type.
+     */
+    displayName?: string;
+    /**
+     * The event type.
+     */
+    type?: string;
+    /**
+     * A short description of the event type.
+     */
+    description?: string;
+}
+/** @ignore */
+export declare namespace _EventTypeTransformation {
+    interface AsJson {
+        severityLevel?: _EventTypeSeverityLevelTransformation.AsJson;
+        displayName?: string;
+        type?: string;
+        description?: string;
+    }
+    function fromJson(model: AsJson): EventType;
+    function toJson(model: EventType): AsJson;
+}

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

@@ -0,0 +1,96 @@
+import { EntityStub, _EntityStubTransformation } from './entity-stub';
+import { EventProperty, _EventPropertyTransformation } from './event-property';
+import { EventStatus, _EventStatusTransformation } from './event-status';
+import { ManagementZone, _ManagementZoneTransformation } from './management-zone';
+import { METag, _METagTransformation } from './me-tag';
+/**
+ * Configuration of an event.
+ */
+export interface Event {
+    /**
+     * The alerting status during a [maintenance](https://dt-url.net/b2123rg0):
+     *
+     *  * `false`: Alerting works as usual.
+     * * `true`: Alerting is disabled.
+     */
+    suppressAlert?: boolean;
+    /**
+     * If `true`, the event happens [frequently](https://dt-url.net/4da3kdg).
+     *
+     *  A frequent event doesn't raise a problem.
+     */
+    frequentEvent?: boolean;
+    /**
+     * If `true`, the event happened while the monitored system was under maintenance.
+     */
+    underMaintenance?: boolean;
+    /**
+     * The problem detection status during a [maintenance](https://dt-url.net/b2123rg0):
+     *
+     *  * `false`: Problem detection works as usual.
+     * * `true`: Problem detection is disabled.
+     */
+    suppressProblem?: boolean;
+    /**
+     * A list of all management zones that the event belongs to.
+     */
+    managementZones?: ManagementZone[];
+    entityId?: EntityStub;
+    /**
+     * The ID of the event.
+     */
+    eventId?: string;
+    /**
+     * A list of tags of the related entity.
+     */
+    entityTags?: METag[];
+    /**
+     * The type of the event.
+     */
+    eventType?: string;
+    /**
+     * A list of event properties.
+     */
+    properties?: EventProperty[];
+    status?: EventStatus;
+    /**
+     * The timestamp when the event was raised, in UTC milliseconds.
+     */
+    startTime?: number;
+    /**
+     * The timestamp when the event was closed, in UTC milliseconds.
+     *
+     *  Has the value of `null` if the event is still active.
+     */
+    endTime?: number;
+    /**
+     * The title of the event.
+     */
+    title?: string;
+    /**
+     * The correlation ID of the event.
+     */
+    correlationId?: string;
+}
+/** @ignore */
+export declare namespace _EventTransformation {
+    interface AsJson {
+        suppressAlert?: boolean;
+        frequentEvent?: boolean;
+        underMaintenance?: boolean;
+        suppressProblem?: boolean;
+        managementZones?: _ManagementZoneTransformation.AsJson[];
+        entityId?: _EntityStubTransformation.AsJson;
+        eventId?: string;
+        entityTags?: _METagTransformation.AsJson[];
+        eventType?: string;
+        properties?: _EventPropertyTransformation.AsJson[];
+        status?: _EventStatusTransformation.AsJson;
+        startTime?: number;
+        endTime?: number;
+        title?: string;
+        correlationId?: string;
+    }
+    function fromJson(model: AsJson): Event;
+    function toJson(model: Event): AsJson;
+}

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

@@ -0,0 +1,23 @@
+import { Evidence, _EvidenceTransformation } from './evidence';
+/**
+ * The evidence details of a problem.
+ */
+export interface EvidenceDetails {
+    /**
+     * The total number of evidence of a problem.
+     */
+    totalCount: number;
+    /**
+     * A list of all evidence.
+     */
+    details: Evidence[];
+}
+/** @ignore */
+export declare namespace _EvidenceDetailsTransformation {
+    interface AsJson {
+        totalCount: number;
+        details: _EvidenceTransformation.AsJson[];
+    }
+    function fromJson(model: AsJson): EvidenceDetails;
+    function toJson(model: EvidenceDetails): AsJson;
+}

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

@@ -0,0 +1,22 @@
+/**
+ * Defines the actual set of fields depending on the value. See one of the following objects:
+ *
+ * * `EVENT` -> EventEvidence
+ * * `METRIC` -> MetricEvidence
+ * * `TRANSACTIONAL` -> TransactionalEvidence
+ * * `MAINTENANCE_WINDOW` -> MaintenanceWindowEvidence
+ * * `AVAILABILITY_EVIDENCE` -> AvailabilityEvidence
+ */
+export declare enum EvidenceEvidenceType {
+    AvailabilityEvidence = "AVAILABILITY_EVIDENCE",
+    Event = "EVENT",
+    MaintenanceWindow = "MAINTENANCE_WINDOW",
+    Metric = "METRIC",
+    Transactional = "TRANSACTIONAL"
+}
+/** @ignore */
+export declare namespace _EvidenceEvidenceTypeTransformation {
+    type AsJson = EvidenceEvidenceType;
+    const toJson: (value: EvidenceEvidenceType) => AsJson;
+    const fromJson: (value: AsJson) => EvidenceEvidenceType;
+}

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

@@ -0,0 +1,47 @@
+import { AvailabilityEvidence } from './availability-evidence';
+import { EntityStub, _EntityStubTransformation } from './entity-stub';
+import { EventEvidence } from './event-evidence';
+import { EvidenceEvidenceType, _EvidenceEvidenceTypeTransformation } from './evidence-evidence-type';
+import { MaintenanceWindowEvidence } from './maintenance-window-evidence';
+import { MetricEvidence } from './metric-evidence';
+import { TransactionalEvidence } from './transactional-evidence';
+/**
+ * An evidence of a root cause.
+ *
+ *  The actual set of fields depends on the type of the evidence. Find the list of actual objects in the description of the **evidenceType** field or see [Problems API v2 - JSON models](https://dt-url.net/we03sp2).
+ */
+export interface Evidence {
+    evidenceType: EvidenceEvidenceType;
+    /**
+     * The display name of the evidence.
+     */
+    displayName: string;
+    entity: EntityStub;
+    groupingEntity?: EntityStub;
+    /**
+     * The evidence is (`true`) or is not (`false`) a part of the root cause.
+     */
+    rootCauseRelevant: boolean;
+    /**
+     * The start time of the evidence, in UTC milliseconds.
+     */
+    startTime: number;
+}
+/** @ignore */
+export declare namespace _EvidenceTransformation {
+    function isEventEvidence(model: Evidence): model is EventEvidence;
+    function isMetricEvidence(model: Evidence): model is MetricEvidence;
+    function isTransactionalEvidence(model: Evidence): model is TransactionalEvidence;
+    function isMaintenanceWindowEvidence(model: Evidence): model is MaintenanceWindowEvidence;
+    function isAvailabilityEvidence(model: Evidence): model is AvailabilityEvidence;
+    interface AsJson {
+        evidenceType: _EvidenceEvidenceTypeTransformation.AsJson;
+        displayName: string;
+        entity: _EntityStubTransformation.AsJson;
+        groupingEntity?: _EntityStubTransformation.AsJson;
+        rootCauseRelevant: boolean;
+        startTime: number;
+    }
+    function fromJson(model: AsJson, includeChildProps?: boolean): Evidence;
+    function toJson(model: Evidence, includeChildProps?: boolean): AsJson;
+}

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

@@ -0,0 +1,38 @@
+import { ExecutionStep, _ExecutionStepTransformation } from './execution-step';
+/**
+ * Contains extended monitor's execution details.
+ */
+export interface ExecutionFullResults {
+    /**
+     * Execution status.
+     */
+    status?: string;
+    /**
+     * Failure message.
+     */
+    failureMessage?: string;
+    /**
+     * Error code.
+     */
+    errorCode?: string;
+    /**
+     * Number executed steps.
+     */
+    executionStepCount?: number;
+    /**
+     * Details about the monitor's step execution.
+     */
+    executionSteps?: ExecutionStep[];
+}
+/** @ignore */
+export declare namespace _ExecutionFullResultsTransformation {
+    interface AsJson {
+        status?: string;
+        failureMessage?: string;
+        errorCode?: string;
+        executionStepCount?: number;
+        executionSteps?: _ExecutionStepTransformation.AsJson[];
+    }
+    function fromJson(model: AsJson): ExecutionFullResults;
+    function toJson(model: ExecutionFullResults): AsJson;
+}

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

@@ -0,0 +1,112 @@
+/**
+ * Contains basic results of the monitor's on-demand execution.
+ */
+export interface ExecutionSimpleResults {
+    /**
+     * Execution status.
+     */
+    status?: string;
+    /**
+     * Failure message.
+     */
+    failureMessage?: string;
+    /**
+     * Error code.
+     */
+    errorCode?: string;
+    /**
+     * Response status code.
+     */
+    responseStatusCode?: number;
+    /**
+     * Number of the executed steps by Synthetic engine
+     */
+    executedSteps?: number;
+    /**
+     * Synthetic engine id on which monitor was executed.
+     */
+    engineId?: number;
+    /**
+     * Informs whether is HTTP error.
+     */
+    httperror?: boolean;
+    /**
+     * Informs whether is Chrome error.
+     */
+    chromeError?: boolean;
+    /**
+     * Flag informs whether request was executed on public location.
+     */
+    publicLocation?: boolean;
+    /**
+     * Request's response size in bytes.
+     */
+    responseSize?: number;
+    /**
+     * A flag indicating that the response payload size limit of 10MB has been exceeded.
+     */
+    responseBodySizeLimitExceeded?: boolean;
+    /**
+     * An expiry date of the first SSL certificate from the certificate chain.
+     */
+    peerCertificateExpiryDate?: number;
+    /**
+     * A total time measured in milliseconds.
+     */
+    totalTime?: number;
+    /**
+     * A hostname resolution time measured in milliseconds.
+     */
+    hostNameResolutionTime?: number;
+    /**
+     * A TCP connect time measured in milliseconds.
+     */
+    tcpConnectTime?: number;
+    /**
+     * A TLS handshake time measured in milliseconds.
+     */
+    tlsHandshakeTime?: number;
+    /**
+     * A time to first byte measured in milliseconds.
+     */
+    timeToFirstByte?: number;
+    /**
+     * Total number of milliseconds spent on handling all redirect requests, measured in milliseconds.
+     */
+    redirectionTime?: number;
+    /**
+     * Number of redirects.
+     */
+    redirectsCount?: number;
+    /**
+     * Start timestamp.
+     */
+    startTimestamp?: number;
+}
+/** @ignore */
+export declare namespace _ExecutionSimpleResultsTransformation {
+    interface AsJson {
+        status?: string;
+        failureMessage?: string;
+        errorCode?: string;
+        responseStatusCode?: number;
+        executedSteps?: number;
+        engineId?: number;
+        httperror?: boolean;
+        chromeError?: boolean;
+        publicLocation?: boolean;
+        responseSize?: number;
+        responseBodySizeLimitExceeded?: boolean;
+        peerCertificateExpiryDate?: number;
+        totalTime?: number;
+        hostNameResolutionTime?: number;
+        tcpConnectTime?: number;
+        tlsHandshakeTime?: number;
+        timeToFirstByte?: number;
+        redirectionTime?: number;
+        redirectsCount?: number;
+        startTimestamp?: number;
+    }
+    function fromJson(model: AsJson): ExecutionSimpleResults;
+    function toJson(model: ExecutionSimpleResults): AsJson;
+}