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

package/types/packages/client/classic-environment-v2/src/lib/models/remediation-assessment-data-assets.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The reachability of related data assets by affected entities.
+ */
+export declare enum RemediationAssessmentDataAssets {
+    NotAvailable = "NOT_AVAILABLE",
+    NotDetected = "NOT_DETECTED",
+    Reachable = "REACHABLE"
+}
+/** @ignore */
+export declare namespace _RemediationAssessmentDataAssetsTransformation {
+    type AsJson = RemediationAssessmentDataAssets;
+    const toJson: (value: RemediationAssessmentDataAssets) => AsJson;
+    const fromJson: (value: AsJson) => RemediationAssessmentDataAssets;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/remediation-assessment-exposure.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The level of exposure of affected entities.
+ */
+export declare enum RemediationAssessmentExposure {
+    NotAvailable = "NOT_AVAILABLE",
+    NotDetected = "NOT_DETECTED",
+    PublicNetwork = "PUBLIC_NETWORK"
+}
+/** @ignore */
+export declare namespace _RemediationAssessmentExposureTransformation {
+    type AsJson = RemediationAssessmentExposure;
+    const toJson: (value: RemediationAssessmentExposure) => AsJson;
+    const fromJson: (value: AsJson) => RemediationAssessmentExposure;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/remediation-assessment-vulnerable-function-usage.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The usage of vulnerable functions
+ */
+export declare enum RemediationAssessmentVulnerableFunctionUsage {
+    InUse = "IN_USE",
+    NotAvailable = "NOT_AVAILABLE",
+    NotInUse = "NOT_IN_USE"
+}
+/** @ignore */
+export declare namespace _RemediationAssessmentVulnerableFunctionUsageTransformation {
+    type AsJson = RemediationAssessmentVulnerableFunctionUsage;
+    const toJson: (value: RemediationAssessmentVulnerableFunctionUsage) => AsJson;
+    const fromJson: (value: AsJson) => RemediationAssessmentVulnerableFunctionUsage;
+}

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

@@ -0,0 +1,42 @@
+import { RemediationAssessmentDataAssets, _RemediationAssessmentDataAssetsTransformation } from './remediation-assessment-data-assets';
+import { RemediationAssessmentExposure, _RemediationAssessmentExposureTransformation } from './remediation-assessment-exposure';
+import { RemediationAssessmentVulnerableFunctionUsage, _RemediationAssessmentVulnerableFunctionUsageTransformation } from './remediation-assessment-vulnerable-function-usage';
+import { VulnerableFunction, _VulnerableFunctionTransformation } from './vulnerable-function';
+/**
+ * Assessment of the remediation item.
+ */
+export interface RemediationAssessment {
+    exposure?: RemediationAssessmentExposure;
+    dataAssets?: RemediationAssessmentDataAssets;
+    /**
+     * The number of related data assets.
+     */
+    numberOfDataAssets?: number;
+    vulnerableFunctionUsage?: RemediationAssessmentVulnerableFunctionUsage;
+    /**
+     * A list of vulnerable functions that are in use.
+     */
+    vulnerableFunctionsInUse?: VulnerableFunction[];
+    /**
+     * A list of vulnerable functions that are not in use.
+     */
+    vulnerableFunctionsNotInUse?: VulnerableFunction[];
+    /**
+     * A list of vulnerable functions that are not available.
+     */
+    vulnerableFunctionsNotAvailable?: VulnerableFunction[];
+}
+/** @ignore */
+export declare namespace _RemediationAssessmentTransformation {
+    interface AsJson {
+        exposure?: _RemediationAssessmentExposureTransformation.AsJson;
+        dataAssets?: _RemediationAssessmentDataAssetsTransformation.AsJson;
+        numberOfDataAssets?: number;
+        vulnerableFunctionUsage?: _RemediationAssessmentVulnerableFunctionUsageTransformation.AsJson;
+        vulnerableFunctionsInUse?: _VulnerableFunctionTransformation.AsJson[];
+        vulnerableFunctionsNotInUse?: _VulnerableFunctionTransformation.AsJson[];
+        vulnerableFunctionsNotAvailable?: _VulnerableFunctionTransformation.AsJson[];
+    }
+    function fromJson(model: AsJson): RemediationAssessment;
+    function toJson(model: RemediationAssessment): AsJson;
+}

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

@@ -0,0 +1,18 @@
+import { RemediationItem, _RemediationItemTransformation } from './remediation-item';
+/**
+ * A list of remediation items.
+ */
+export interface RemediationItemList {
+    /**
+     * A list of remediation items.
+     */
+    remediationItems?: RemediationItem[];
+}
+/** @ignore */
+export declare namespace _RemediationItemListTransformation {
+    interface AsJson {
+        remediationItems?: _RemediationItemTransformation.AsJson[];
+    }
+    function fromJson(model: AsJson): RemediationItemList;
+    function toJson(model: RemediationItemList): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/remediation-item-mute-state-change-reason.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The reason for the mute state change.
+ */
+export declare enum RemediationItemMuteStateChangeReason {
+    Affected = "AFFECTED",
+    ConfigurationNotAffected = "CONFIGURATION_NOT_AFFECTED",
+    FalsePositive = "FALSE_POSITIVE",
+    Ignore = "IGNORE",
+    InitialState = "INITIAL_STATE",
+    Other = "OTHER",
+    VulnerableCodeNotInUse = "VULNERABLE_CODE_NOT_IN_USE"
+}
+/** @ignore */
+export declare namespace _RemediationItemMuteStateChangeReasonTransformation {
+    type AsJson = RemediationItemMuteStateChangeReason;
+    const toJson: (value: RemediationItemMuteStateChangeReason) => AsJson;
+    const fromJson: (value: AsJson) => RemediationItemMuteStateChangeReason;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/remediation-item-mute-state-change.d.ts

@@ -0,0 +1,25 @@
+import { RemediationItemMuteStateChangeReason, _RemediationItemMuteStateChangeReasonTransformation } from './remediation-item-mute-state-change-reason';
+/**
+ * An updated configuration of the remediation item's mute state.
+ */
+export interface RemediationItemMuteStateChange {
+    /**
+     * The desired mute state of the remediation item.
+     */
+    muted: boolean;
+    reason: RemediationItemMuteStateChangeReason;
+    /**
+     * A comment about the mute state change reason.
+     */
+    comment: string;
+}
+/** @ignore */
+export declare namespace _RemediationItemMuteStateChangeTransformation {
+    interface AsJson {
+        muted: boolean;
+        reason: _RemediationItemMuteStateChangeReasonTransformation.AsJson;
+        comment: string;
+    }
+    function fromJson(model: AsJson): RemediationItemMuteStateChange;
+    function toJson(model: RemediationItemMuteStateChange): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/remediation-item-mute-state-reason.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The reason for the most recent mute state change.
+ */
+export declare enum RemediationItemMuteStateReason {
+    Affected = "AFFECTED",
+    ConfigurationNotAffected = "CONFIGURATION_NOT_AFFECTED",
+    FalsePositive = "FALSE_POSITIVE",
+    Ignore = "IGNORE",
+    InitialState = "INITIAL_STATE",
+    Other = "OTHER",
+    VulnerableCodeNotInUse = "VULNERABLE_CODE_NOT_IN_USE"
+}
+/** @ignore */
+export declare namespace _RemediationItemMuteStateReasonTransformation {
+    type AsJson = RemediationItemMuteStateReason;
+    const toJson: (value: RemediationItemMuteStateReason) => AsJson;
+    const fromJson: (value: AsJson) => RemediationItemMuteStateReason;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/remediation-item-mute-state.d.ts

@@ -0,0 +1,35 @@
+import { RemediationItemMuteStateReason, _RemediationItemMuteStateReasonTransformation } from './remediation-item-mute-state-reason';
+/**
+ * The mute state of a remediation item of a security problem.
+ */
+export interface RemediationItemMuteState {
+    /**
+     * The remediation is (`true`) or is not (`false`) muted.
+     */
+    muted?: boolean;
+    /**
+     * The user who last changed the mute state.
+     */
+    user?: string;
+    /**
+     * The timestamp (UTC milliseconds) of the last update of the mute state.
+     */
+    lastUpdatedTimestamp?: number;
+    reason?: RemediationItemMuteStateReason;
+    /**
+     * A short comment about the most recent mute state change.
+     */
+    comment?: string;
+}
+/** @ignore */
+export declare namespace _RemediationItemMuteStateTransformation {
+    interface AsJson {
+        muted?: boolean;
+        user?: string;
+        lastUpdatedTimestamp?: number;
+        reason?: _RemediationItemMuteStateReasonTransformation.AsJson;
+        comment?: string;
+    }
+    function fromJson(model: AsJson): RemediationItemMuteState;
+    function toJson(model: RemediationItemMuteState): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/remediation-item-vulnerability-state.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The current state of related entities for the vulnerability.
+ */
+export declare enum RemediationItemVulnerabilityState {
+    Resolved = "RESOLVED",
+    Vulnerable = "VULNERABLE"
+}
+/** @ignore */
+export declare namespace _RemediationItemVulnerabilityStateTransformation {
+    type AsJson = RemediationItemVulnerabilityState;
+    const toJson: (value: RemediationItemVulnerabilityState) => AsJson;
+    const fromJson: (value: AsJson) => RemediationItemVulnerabilityState;
+}

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

@@ -0,0 +1,57 @@
+import { RemediationAssessment, _RemediationAssessmentTransformation } from './remediation-assessment';
+import { RemediationItemMuteState, _RemediationItemMuteStateTransformation } from './remediation-item-mute-state';
+import { RemediationItemVulnerabilityState, _RemediationItemVulnerabilityStateTransformation } from './remediation-item-vulnerability-state';
+import { RemediationProgress, _RemediationProgressTransformation } from './remediation-progress';
+import { VulnerableComponent, _VulnerableComponentTransformation } from './vulnerable-component';
+/**
+ * A possible remediation for a security problem.
+ */
+export interface RemediationItem {
+    /**
+     * The ID of the remediation item.
+     */
+    id?: string;
+    /**
+     * A list of related entities, represented by entity IDs.
+     */
+    entityIds?: string[];
+    /**
+     * The name of the entity.
+     */
+    name?: string;
+    /**
+     * The timestamp when the entity has first been related to the vulnerability.
+     */
+    firstAffectedTimestamp?: number;
+    assessment?: RemediationAssessment;
+    /**
+     * The timestamp (UTC milliseconds) when the vulnerability has been resolved for related entities.
+     */
+    resolvedTimestamp?: number;
+    vulnerabilityState?: RemediationItemVulnerabilityState;
+    muteState?: RemediationItemMuteState;
+    /**
+     * A list of vulnerable components of the remediation item.
+     *
+     * A vulnerable component is what causes the security problem.
+     */
+    vulnerableComponents?: VulnerableComponent[];
+    remediationProgress?: RemediationProgress;
+}
+/** @ignore */
+export declare namespace _RemediationItemTransformation {
+    interface AsJson {
+        id?: string;
+        entityIds?: string[];
+        name?: string;
+        firstAffectedTimestamp?: number;
+        assessment?: _RemediationAssessmentTransformation.AsJson;
+        resolvedTimestamp?: number;
+        vulnerabilityState?: _RemediationItemVulnerabilityStateTransformation.AsJson;
+        muteState?: _RemediationItemMuteStateTransformation.AsJson;
+        vulnerableComponents?: _VulnerableComponentTransformation.AsJson[];
+        remediationProgress?: _RemediationProgressTransformation.AsJson;
+    }
+    function fromJson(model: AsJson): RemediationItem;
+    function toJson(model: RemediationItem): AsJson;
+}

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

@@ -0,0 +1,22 @@
+/**
+ * The progress of this remediation item. It contains affected and unaffected entities.
+ */
+export interface RemediationProgress {
+    /**
+     * A list of related entities that are affected by the security problem.
+     */
+    affectedEntities?: string[];
+    /**
+     * A list of related entities that are affected by the security problem.
+     */
+    unaffectedEntities?: string[];
+}
+/** @ignore */
+export declare namespace _RemediationProgressTransformation {
+    interface AsJson {
+        affectedEntities?: string[];
+        unaffectedEntities?: string[];
+    }
+    function fromJson(model: AsJson): RemediationProgress;
+    function toJson(model: RemediationProgress): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/risk-assessment-assessment-accuracy.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The level of available information on which this assessment has been done.
+ */
+export declare enum RiskAssessmentAssessmentAccuracy {
+    Full = "FULL",
+    NotAvailable = "NOT_AVAILABLE",
+    Reduced = "REDUCED"
+}
+/** @ignore */
+export declare namespace _RiskAssessmentAssessmentAccuracyTransformation {
+    type AsJson = RiskAssessmentAssessmentAccuracy;
+    const toJson: (value: RiskAssessmentAssessmentAccuracy) => AsJson;
+    const fromJson: (value: AsJson) => RiskAssessmentAssessmentAccuracy;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/risk-assessment-base-risk-level.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The risk level from the CVSS score.
+ */
+export declare enum RiskAssessmentBaseRiskLevel {
+    Critical = "CRITICAL",
+    High = "HIGH",
+    Low = "LOW",
+    Medium = "MEDIUM",
+    None = "NONE"
+}
+/** @ignore */
+export declare namespace _RiskAssessmentBaseRiskLevelTransformation {
+    type AsJson = RiskAssessmentBaseRiskLevel;
+    const toJson: (value: RiskAssessmentBaseRiskLevel) => AsJson;
+    const fromJson: (value: AsJson) => RiskAssessmentBaseRiskLevel;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/risk-assessment-data-assets.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The reachability of related data assets by affected entities.
+ */
+export declare enum RiskAssessmentDataAssets {
+    NotAvailable = "NOT_AVAILABLE",
+    NotDetected = "NOT_DETECTED",
+    Reachable = "REACHABLE"
+}
+/** @ignore */
+export declare namespace _RiskAssessmentDataAssetsTransformation {
+    type AsJson = RiskAssessmentDataAssets;
+    const toJson: (value: RiskAssessmentDataAssets) => AsJson;
+    const fromJson: (value: AsJson) => RiskAssessmentDataAssets;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/risk-assessment-exposure.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The level of exposure of affected entities.
+ */
+export declare enum RiskAssessmentExposure {
+    NotAvailable = "NOT_AVAILABLE",
+    NotDetected = "NOT_DETECTED",
+    PublicNetwork = "PUBLIC_NETWORK"
+}
+/** @ignore */
+export declare namespace _RiskAssessmentExposureTransformation {
+    type AsJson = RiskAssessmentExposure;
+    const toJson: (value: RiskAssessmentExposure) => AsJson;
+    const fromJson: (value: AsJson) => RiskAssessmentExposure;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/risk-assessment-public-exploit.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The availability status of public exploits.
+ */
+export declare enum RiskAssessmentPublicExploit {
+    Available = "AVAILABLE",
+    NotAvailable = "NOT_AVAILABLE"
+}
+/** @ignore */
+export declare namespace _RiskAssessmentPublicExploitTransformation {
+    type AsJson = RiskAssessmentPublicExploit;
+    const toJson: (value: RiskAssessmentPublicExploit) => AsJson;
+    const fromJson: (value: AsJson) => RiskAssessmentPublicExploit;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/risk-assessment-risk-level.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The Davis risk level.
+ *
+ *  It is calculated by Dynatrace on the basis of CVSS score.
+ */
+export declare enum RiskAssessmentRiskLevel {
+    Critical = "CRITICAL",
+    High = "HIGH",
+    Low = "LOW",
+    Medium = "MEDIUM",
+    None = "NONE"
+}
+/** @ignore */
+export declare namespace _RiskAssessmentRiskLevelTransformation {
+    type AsJson = RiskAssessmentRiskLevel;
+    const toJson: (value: RiskAssessmentRiskLevel) => AsJson;
+    const fromJson: (value: AsJson) => RiskAssessmentRiskLevel;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/risk-assessment-snapshot-exposure.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The level of exposure of affected entities.
+ */
+export declare enum RiskAssessmentSnapshotExposure {
+    NotAvailable = "NOT_AVAILABLE",
+    NotDetected = "NOT_DETECTED",
+    PublicNetwork = "PUBLIC_NETWORK"
+}
+/** @ignore */
+export declare namespace _RiskAssessmentSnapshotExposureTransformation {
+    type AsJson = RiskAssessmentSnapshotExposure;
+    const toJson: (value: RiskAssessmentSnapshotExposure) => AsJson;
+    const fromJson: (value: AsJson) => RiskAssessmentSnapshotExposure;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/risk-assessment-snapshot-public-exploit.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The availability status of public exploits.
+ */
+export declare enum RiskAssessmentSnapshotPublicExploit {
+    Available = "AVAILABLE",
+    NotAvailable = "NOT_AVAILABLE"
+}
+/** @ignore */
+export declare namespace _RiskAssessmentSnapshotPublicExploitTransformation {
+    type AsJson = RiskAssessmentSnapshotPublicExploit;
+    const toJson: (value: RiskAssessmentSnapshotPublicExploit) => AsJson;
+    const fromJson: (value: AsJson) => RiskAssessmentSnapshotPublicExploit;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/risk-assessment-snapshot-risk-level.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The Davis risk level.
+ *
+ *  It is calculated by Dynatrace on the basis of CVSS score.
+ */
+export declare enum RiskAssessmentSnapshotRiskLevel {
+    Critical = "CRITICAL",
+    High = "HIGH",
+    Low = "LOW",
+    Medium = "MEDIUM",
+    None = "NONE"
+}
+/** @ignore */
+export declare namespace _RiskAssessmentSnapshotRiskLevelTransformation {
+    type AsJson = RiskAssessmentSnapshotRiskLevel;
+    const toJson: (value: RiskAssessmentSnapshotRiskLevel) => AsJson;
+    const fromJson: (value: AsJson) => RiskAssessmentSnapshotRiskLevel;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/risk-assessment-snapshot-vulnerable-function-usage.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The state of vulnerable code execution.
+ */
+export declare enum RiskAssessmentSnapshotVulnerableFunctionUsage {
+    InUse = "IN_USE",
+    NotAvailable = "NOT_AVAILABLE",
+    NotInUse = "NOT_IN_USE"
+}
+/** @ignore */
+export declare namespace _RiskAssessmentSnapshotVulnerableFunctionUsageTransformation {
+    type AsJson = RiskAssessmentSnapshotVulnerableFunctionUsage;
+    const toJson: (value: RiskAssessmentSnapshotVulnerableFunctionUsage) => AsJson;
+    const fromJson: (value: AsJson) => RiskAssessmentSnapshotVulnerableFunctionUsage;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/risk-assessment-snapshot.d.ts

@@ -0,0 +1,41 @@
+import { RiskAssessmentSnapshotExposure, _RiskAssessmentSnapshotExposureTransformation } from './risk-assessment-snapshot-exposure';
+import { RiskAssessmentSnapshotPublicExploit, _RiskAssessmentSnapshotPublicExploitTransformation } from './risk-assessment-snapshot-public-exploit';
+import { RiskAssessmentSnapshotRiskLevel, _RiskAssessmentSnapshotRiskLevelTransformation } from './risk-assessment-snapshot-risk-level';
+import { RiskAssessmentSnapshotVulnerableFunctionUsage, _RiskAssessmentSnapshotVulnerableFunctionUsageTransformation } from './risk-assessment-snapshot-vulnerable-function-usage';
+/**
+ * A snapshot of the risk assessment of a security problem.
+ */
+export interface RiskAssessmentSnapshot {
+    riskLevel?: RiskAssessmentSnapshotRiskLevel;
+    /**
+     * The Davis risk score (1-10).
+     *
+     *  It is calculated by Dynatrace on the basis of CVSS score.
+     */
+    riskScore?: number;
+    /**
+     * The number of currently affected entities.
+     */
+    numberOfAffectedEntities?: number;
+    /**
+     * The number of data assets that are currently reachable by affected entities.
+     */
+    numberOfReachableDataAssets?: number;
+    publicExploit?: RiskAssessmentSnapshotPublicExploit;
+    exposure?: RiskAssessmentSnapshotExposure;
+    vulnerableFunctionUsage?: RiskAssessmentSnapshotVulnerableFunctionUsage;
+}
+/** @ignore */
+export declare namespace _RiskAssessmentSnapshotTransformation {
+    interface AsJson {
+        riskLevel?: _RiskAssessmentSnapshotRiskLevelTransformation.AsJson;
+        riskScore?: number;
+        numberOfAffectedEntities?: number;
+        numberOfReachableDataAssets?: number;
+        publicExploit?: _RiskAssessmentSnapshotPublicExploitTransformation.AsJson;
+        exposure?: _RiskAssessmentSnapshotExposureTransformation.AsJson;
+        vulnerableFunctionUsage?: _RiskAssessmentSnapshotVulnerableFunctionUsageTransformation.AsJson;
+    }
+    function fromJson(model: AsJson): RiskAssessmentSnapshot;
+    function toJson(model: RiskAssessmentSnapshot): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/risk-assessment-vulnerable-function-usage.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The state of vulnerable code execution.
+ */
+export declare enum RiskAssessmentVulnerableFunctionUsage {
+    InUse = "IN_USE",
+    NotAvailable = "NOT_AVAILABLE",
+    NotInUse = "NOT_IN_USE"
+}
+/** @ignore */
+export declare namespace _RiskAssessmentVulnerableFunctionUsageTransformation {
+    type AsJson = RiskAssessmentVulnerableFunctionUsage;
+    const toJson: (value: RiskAssessmentVulnerableFunctionUsage) => AsJson;
+    const fromJson: (value: AsJson) => RiskAssessmentVulnerableFunctionUsage;
+}

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

@@ -0,0 +1,55 @@
+import { RiskAssessmentAssessmentAccuracy, _RiskAssessmentAssessmentAccuracyTransformation } from './risk-assessment-assessment-accuracy';
+import { RiskAssessmentBaseRiskLevel, _RiskAssessmentBaseRiskLevelTransformation } from './risk-assessment-base-risk-level';
+import { RiskAssessmentDataAssets, _RiskAssessmentDataAssetsTransformation } from './risk-assessment-data-assets';
+import { RiskAssessmentExposure, _RiskAssessmentExposureTransformation } from './risk-assessment-exposure';
+import { RiskAssessmentPublicExploit, _RiskAssessmentPublicExploitTransformation } from './risk-assessment-public-exploit';
+import { RiskAssessmentRiskLevel, _RiskAssessmentRiskLevelTransformation } from './risk-assessment-risk-level';
+import { RiskAssessmentVulnerableFunctionUsage, _RiskAssessmentVulnerableFunctionUsageTransformation } from './risk-assessment-vulnerable-function-usage';
+/**
+ * Risk assessment of a security problem.
+ */
+export interface RiskAssessment {
+    riskLevel?: RiskAssessmentRiskLevel;
+    /**
+     * The Davis risk score (1-10).
+     *
+     *  It is calculated by Dynatrace on the basis of CVSS score.
+     */
+    riskScore?: number;
+    /**
+     * The attack vector calculated by Dynatrace based on the CVSS attack vector.
+     */
+    riskVector?: string;
+    baseRiskLevel?: RiskAssessmentBaseRiskLevel;
+    /**
+     * The risk score (1-10) from the CVSS score.
+     */
+    baseRiskScore?: number;
+    /**
+     * The original attack vector of the CVSS assessment.
+     */
+    baseRiskVector?: string;
+    exposure?: RiskAssessmentExposure;
+    dataAssets?: RiskAssessmentDataAssets;
+    publicExploit?: RiskAssessmentPublicExploit;
+    vulnerableFunctionUsage?: RiskAssessmentVulnerableFunctionUsage;
+    assessmentAccuracy?: RiskAssessmentAssessmentAccuracy;
+}
+/** @ignore */
+export declare namespace _RiskAssessmentTransformation {
+    interface AsJson {
+        riskLevel?: _RiskAssessmentRiskLevelTransformation.AsJson;
+        riskScore?: number;
+        riskVector?: string;
+        baseRiskLevel?: _RiskAssessmentBaseRiskLevelTransformation.AsJson;
+        baseRiskScore?: number;
+        baseRiskVector?: string;
+        exposure?: _RiskAssessmentExposureTransformation.AsJson;
+        dataAssets?: _RiskAssessmentDataAssetsTransformation.AsJson;
+        publicExploit?: _RiskAssessmentPublicExploitTransformation.AsJson;
+        vulnerableFunctionUsage?: _RiskAssessmentVulnerableFunctionUsageTransformation.AsJson;
+        assessmentAccuracy?: _RiskAssessmentAssessmentAccuracyTransformation.AsJson;
+    }
+    function fromJson(model: AsJson): RiskAssessment;
+    function toJson(model: RiskAssessment): AsJson;
+}

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

@@ -0,0 +1,17 @@
+export declare enum RollupType {
+    Auto = "AUTO",
+    Avg = "AVG",
+    Count = "COUNT",
+    Max = "MAX",
+    Median = "MEDIAN",
+    Min = "MIN",
+    Percentile = "PERCENTILE",
+    Sum = "SUM",
+    Value = "VALUE"
+}
+/** @ignore */
+export declare namespace _RollupTypeTransformation {
+    type AsJson = RollupType;
+    const toJson: (value: RollupType) => AsJson;
+    const fromJson: (value: AsJson) => RollupType;
+}

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

@@ -0,0 +1,17 @@
+import { RollupType, _RollupTypeTransformation } from './rollup-type';
+/**
+ * A way of viewing a series as a single value for the purpose of sorting or series-based filters.
+ */
+export interface Rollup {
+    type?: RollupType;
+    parameter?: number;
+}
+/** @ignore */
+export declare namespace _RollupTransformation {
+    interface AsJson {
+        type?: _RollupTypeTransformation.AsJson;
+        parameter?: number;
+    }
+    function fromJson(model: AsJson): Rollup;
+    function toJson(model: Rollup): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/schema-definition-rest-dto-enums.d.ts

@@ -0,0 +1,15 @@
+import { EnumType } from './enum-type';
+/**
+ * A list of definitions of enum properties.
+ */
+export interface SchemaDefinitionRestDtoEnums {
+    [propName: string]: EnumType | undefined;
+}
+/** @ignore */
+export declare namespace _SchemaDefinitionRestDtoEnumsTransformation {
+    interface AsJson {
+        [propName: string]: EnumType | undefined;
+    }
+    function fromJson(model: AsJson): SchemaDefinitionRestDtoEnums;
+    function toJson(model: SchemaDefinitionRestDtoEnums): AsJson;
+}

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

@@ -0,0 +1,14 @@
+/**
+ * Metadata of the setting.
+ */
+export interface SchemaDefinitionRestDtoMetadata {
+    [propName: string]: string | undefined;
+}
+/** @ignore */
+export declare namespace _SchemaDefinitionRestDtoMetadataTransformation {
+    interface AsJson {
+        [propName: string]: string | undefined;
+    }
+    function fromJson(model: AsJson): SchemaDefinitionRestDtoMetadata;
+    function toJson(model: SchemaDefinitionRestDtoMetadata): AsJson;
+}