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

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

@@ -0,0 +1,91 @@
+import { AlertingProfileStub, _AlertingProfileStubTransformation } from './alerting-profile-stub';
+import { CommentsList, _CommentsListTransformation } from './comments-list';
+import { EntityStub, _EntityStubTransformation } from './entity-stub';
+import { EvidenceDetails, _EvidenceDetailsTransformation } from './evidence-details';
+import { ImpactAnalysis, _ImpactAnalysisTransformation } from './impact-analysis';
+import { LinkedProblem, _LinkedProblemTransformation } from './linked-problem';
+import { ManagementZone, _ManagementZoneTransformation } from './management-zone';
+import { METag, _METagTransformation } from './me-tag';
+import { ProblemImpactLevel, _ProblemImpactLevelTransformation } from './problem-impact-level';
+import { ProblemSeverityLevel, _ProblemSeverityLevelTransformation } from './problem-severity-level';
+import { ProblemStatus, _ProblemStatusTransformation } from './problem-status';
+/**
+ * The properties of a problem.
+ */
+export interface Problem {
+    /**
+     * A list of all entities that are affected by the problem.
+     */
+    affectedEntities: EntityStub[];
+    linkedProblemInfo?: LinkedProblem;
+    rootCauseEntity?: EntityStub;
+    /**
+     * A list of all entities that are impacted by the problem.
+     */
+    impactedEntities: EntityStub[];
+    /**
+     * A list of alerting profiles that match the problem.
+     */
+    problemFilters: AlertingProfileStub[];
+    evidenceDetails?: EvidenceDetails;
+    recentComments?: CommentsList;
+    impactAnalysis?: ImpactAnalysis;
+    impactLevel: ProblemImpactLevel;
+    /**
+     * The display ID of the problem.
+     */
+    displayId: string;
+    /**
+     * A list of all management zones that the problem belongs to.
+     */
+    managementZones: ManagementZone[];
+    severityLevel: ProblemSeverityLevel;
+    /**
+     * A list of all entity tags of the problem.
+     */
+    entityTags?: METag[];
+    /**
+     * The ID of the problem.
+     */
+    problemId: string;
+    status: ProblemStatus;
+    /**
+     * The start timestamp of the problem, in UTC milliseconds.
+     */
+    startTime: number;
+    /**
+     * The end timestamp of the problem, in UTC milliseconds.
+     *
+     *  Has `-1` value, if the problem is still open.
+     */
+    endTime: number;
+    /**
+     * The name of the problem, displayed in the UI.
+     */
+    title: string;
+}
+/** @ignore */
+export declare namespace _ProblemTransformation {
+    interface AsJson {
+        affectedEntities: _EntityStubTransformation.AsJson[];
+        linkedProblemInfo?: _LinkedProblemTransformation.AsJson;
+        rootCauseEntity?: _EntityStubTransformation.AsJson;
+        impactedEntities: _EntityStubTransformation.AsJson[];
+        problemFilters: _AlertingProfileStubTransformation.AsJson[];
+        evidenceDetails?: _EvidenceDetailsTransformation.AsJson;
+        recentComments?: _CommentsListTransformation.AsJson;
+        impactAnalysis?: _ImpactAnalysisTransformation.AsJson;
+        impactLevel: _ProblemImpactLevelTransformation.AsJson;
+        displayId: string;
+        managementZones: _ManagementZoneTransformation.AsJson[];
+        severityLevel: _ProblemSeverityLevelTransformation.AsJson;
+        entityTags?: _METagTransformation.AsJson[];
+        problemId: string;
+        status: _ProblemStatusTransformation.AsJson;
+        startTime: number;
+        endTime: number;
+        title: string;
+    }
+    function fromJson(model: AsJson): Problem;
+    function toJson(model: Problem): AsJson;
+}

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

@@ -0,0 +1,40 @@
+import { Problem, _ProblemTransformation } from './problem';
+/**
+ * A list of problems.
+ */
+export interface Problems {
+    /**
+     * The total number of entries in the result.
+     */
+    totalCount: number;
+    /**
+     * 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 result entries.
+     */
+    problems: Problem[];
+    /**
+     * A list of warnings
+     */
+    warnings?: string[];
+}
+/** @ignore */
+export declare namespace _ProblemsTransformation {
+    interface AsJson {
+        totalCount: number;
+        pageSize?: number;
+        nextPageKey?: string;
+        problems: _ProblemTransformation.AsJson[];
+        warnings?: string[];
+    }
+    function fromJson(model: AsJson): Problems;
+    function toJson(model: Problems): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/process-group-vulnerable-functions.d.ts

@@ -0,0 +1,33 @@
+import { VulnerableFunction, _VulnerableFunctionTransformation } from './vulnerable-function';
+/**
+ * The vulnerable functions of a process group including their usage.
+ */
+export interface ProcessGroupVulnerableFunctions {
+    /**
+     * The process group identifier.
+     */
+    processGroup?: string;
+    /**
+     * A list of vulnerable functions in use.
+     */
+    functionsInUse?: VulnerableFunction[];
+    /**
+     * A list of vulnerable functions not in use.
+     */
+    functionsNotInUse?: VulnerableFunction[];
+    /**
+     * A list of vulnerable functions with unknown state.
+     */
+    functionsNotAvailable?: VulnerableFunction[];
+}
+/** @ignore */
+export declare namespace _ProcessGroupVulnerableFunctionsTransformation {
+    interface AsJson {
+        processGroup?: string;
+        functionsInUse?: _VulnerableFunctionTransformation.AsJson[];
+        functionsNotInUse?: _VulnerableFunctionTransformation.AsJson[];
+        functionsNotAvailable?: _VulnerableFunctionTransformation.AsJson[];
+    }
+    function fromJson(model: AsJson): ProcessGroupVulnerableFunctions;
+    function toJson(model: ProcessGroupVulnerableFunctions): AsJson;
+}

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

@@ -0,0 +1,14 @@
+/**
+   * The default value to be used when no value is provided.
+
+If a non-singleton has the value of `null`, it means an empty collection.
+   * This is just an alias for a type any.
+   * @typedef {any} PropertyDefinitionDefault
+   */
+export declare type PropertyDefinitionDefault = any;
+/** @ignore */
+export declare namespace _PropertyDefinitionDefaultTransformation {
+    type AsJson = any;
+    function fromJson(model: AsJson): PropertyDefinitionDefault;
+    function toJson(model: PropertyDefinitionDefault): AsJson;
+}

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

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

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

@@ -0,0 +1,14 @@
+/**
+ * Modification policy of the property.
+ */
+export declare enum PropertyDefinitionModificationPolicy {
+    Always = "ALWAYS",
+    Default = "DEFAULT",
+    Never = "NEVER"
+}
+/** @ignore */
+export declare namespace _PropertyDefinitionModificationPolicyTransformation {
+    type AsJson = PropertyDefinitionModificationPolicy;
+    const toJson: (value: PropertyDefinitionModificationPolicy) => AsJson;
+    const fromJson: (value: AsJson) => PropertyDefinitionModificationPolicy;
+}

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

@@ -0,0 +1,12 @@
+/**
+ * The type of the property's value.
+ * This is just an alias for a type any.
+ * @typedef {any} PropertyDefinitionType
+ */
+export declare type PropertyDefinitionType = any;
+/** @ignore */
+export declare namespace _PropertyDefinitionTypeTransformation {
+    type AsJson = any;
+    function fromJson(model: AsJson): PropertyDefinitionType;
+    function toJson(model: PropertyDefinitionType): AsJson;
+}

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

@@ -0,0 +1,84 @@
+import { Constraint, _ConstraintTransformation } from './constraint';
+import { DatasourceDefinition, _DatasourceDefinitionTransformation } from './datasource-definition';
+import { Item, _ItemTransformation } from './item';
+import { Precondition, _PreconditionTransformation } from './precondition';
+import { PropertyDefinitionDefault, _PropertyDefinitionDefaultTransformation } from './property-definition-default';
+import { PropertyDefinitionMetadata, _PropertyDefinitionMetadataTransformation } from './property-definition-metadata';
+import { PropertyDefinitionModificationPolicy, _PropertyDefinitionModificationPolicyTransformation } from './property-definition-modification-policy';
+import { PropertyDefinitionType, _PropertyDefinitionTypeTransformation } from './property-definition-type';
+import { UiCustomization, _UiCustomizationTransformation } from './ui-customization';
+/**
+ * Configuration of a property in a settings schema.
+ */
+export interface PropertyDefinition {
+    /**
+     * The type referenced by the property value
+     */
+    referencedType?: string;
+    /**
+     * An extended description and/or links to documentation.
+     */
+    documentation?: string;
+    /**
+     * The maximum number of **objects** in a collection property.
+     *
+     *  Has the value of `1` for singletons.
+     */
+    maxObjects: number;
+    uiCustomization?: UiCustomization;
+    precondition?: Precondition;
+    datasource?: DatasourceDefinition;
+    /**
+     * The minimum number of **objects** in a collection property.
+     */
+    minObjects?: number;
+    modificationPolicy?: PropertyDefinitionModificationPolicy;
+    items?: Item;
+    /**
+     * The subtype of the property's value.
+     */
+    subType?: string;
+    /**
+     * The display name of the property.
+     */
+    displayName?: string;
+    default?: PropertyDefinitionDefault;
+    type: PropertyDefinitionType;
+    /**
+     * A short description of the property.
+     */
+    description?: string;
+    metadata?: PropertyDefinitionMetadata;
+    /**
+     * A list of constraints limiting the values to be accepted.
+     */
+    constraints?: Constraint[];
+    /**
+     * The value can (`true`) or can't (`false`) be `null`.
+     */
+    nullable: boolean;
+}
+/** @ignore */
+export declare namespace _PropertyDefinitionTransformation {
+    interface AsJson {
+        referencedType?: string;
+        documentation?: string;
+        maxObjects: number;
+        uiCustomization?: _UiCustomizationTransformation.AsJson;
+        precondition?: _PreconditionTransformation.AsJson;
+        datasource?: _DatasourceDefinitionTransformation.AsJson;
+        minObjects?: number;
+        modificationPolicy?: _PropertyDefinitionModificationPolicyTransformation.AsJson;
+        items?: _ItemTransformation.AsJson;
+        subType?: string;
+        displayName?: string;
+        default?: _PropertyDefinitionDefaultTransformation.AsJson;
+        type: _PropertyDefinitionTypeTransformation.AsJson;
+        description?: string;
+        metadata?: _PropertyDefinitionMetadataTransformation.AsJson;
+        constraints?: _ConstraintTransformation.AsJson[];
+        nullable: boolean;
+    }
+    function fromJson(model: AsJson): PropertyDefinition;
+    function toJson(model: PropertyDefinition): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/public-certificate-credentials.d.ts

@@ -0,0 +1,28 @@
+import { Credentials, _CredentialsTransformation } from './credentials';
+/**
+ * A credentials set of the `PUBLIC_CERTIFICATE` type.
+ */
+export interface PublicCertificateCredentials extends Credentials {
+    /**
+     * The certificate in the string format.
+     */
+    certificate?: string;
+    /**
+     * The password of the credential (not supported).
+     */
+    password?: string;
+    /**
+     * The certificate format.
+     */
+    certificateFormat?: string;
+}
+/** @ignore */
+export declare namespace _PublicCertificateCredentialsTransformation {
+    interface AsJson extends _CredentialsTransformation.AsJson {
+        certificate?: string;
+        password?: string;
+        certificateFormat?: string;
+    }
+    function fromJson(model: AsJson): PublicCertificateCredentials;
+    function toJson(model: PublicCertificateCredentials): AsJson;
+}

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

@@ -0,0 +1,19 @@
+/**
+ * A list of related attacks of the security problem.
+ *
+ * Related attacks are attacks on the exposed security problem.
+ */
+export interface RelatedAttacksList {
+    /**
+     * A list of related attack ids.
+     */
+    attacks?: string[];
+}
+/** @ignore */
+export declare namespace _RelatedAttacksListTransformation {
+    interface AsJson {
+        attacks?: string[];
+    }
+    function fromJson(model: AsJson): RelatedAttacksList;
+    function toJson(model: RelatedAttacksList): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/related-container-image.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Related container image of a security problem.
+ */
+export interface RelatedContainerImage {
+    /**
+     * The image ID of the related container image.
+     */
+    imageId?: string;
+    /**
+     * The image name of the related container image.
+     */
+    imageName?: string;
+    /**
+     * The number of affected entities.
+     */
+    numberOfAffectedEntities?: number;
+    /**
+     * A list of affected entities.
+     */
+    affectedEntities?: string[];
+}
+/** @ignore */
+export declare namespace _RelatedContainerImageTransformation {
+    interface AsJson {
+        imageId?: string;
+        imageName?: string;
+        numberOfAffectedEntities?: number;
+        affectedEntities?: string[];
+    }
+    function fromJson(model: AsJson): RelatedContainerImage;
+    function toJson(model: RelatedContainerImage): AsJson;
+}

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

@@ -0,0 +1,48 @@
+import { RelatedEntity, _RelatedEntityTransformation } from './related-entity';
+import { RelatedService, _RelatedServiceTransformation } from './related-service';
+/**
+ * A list of related entities of the security problem.
+ *
+ * A related entity is a monitored entity that is directly or indirectly related to an *affected entity* (for example, it could be a host where an affected process runs).
+ *
+ * Each related entity contains a list of corresponding affected entities (for example, an affected process running on this host).
+ */
+export interface RelatedEntitiesList {
+    /**
+     * A list of related applications.
+     */
+    applications?: RelatedEntity[];
+    /**
+     * A list of related services.
+     */
+    services?: RelatedService[];
+    /**
+     * A list of related hosts.
+     */
+    hosts?: RelatedEntity[];
+    /**
+     * A list of related databases.
+     */
+    databases?: string[];
+    /**
+     * A list of related Kubernetes workloads.
+     */
+    kubernetesWorkloads?: RelatedEntity[];
+    /**
+     * A list of related Kubernetes clusters.
+     */
+    kubernetesClusters?: RelatedEntity[];
+}
+/** @ignore */
+export declare namespace _RelatedEntitiesListTransformation {
+    interface AsJson {
+        applications?: _RelatedEntityTransformation.AsJson[];
+        services?: _RelatedServiceTransformation.AsJson[];
+        hosts?: _RelatedEntityTransformation.AsJson[];
+        databases?: string[];
+        kubernetesWorkloads?: _RelatedEntityTransformation.AsJson[];
+        kubernetesClusters?: _RelatedEntityTransformation.AsJson[];
+    }
+    function fromJson(model: AsJson): RelatedEntitiesList;
+    function toJson(model: RelatedEntitiesList): AsJson;
+}

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

@@ -0,0 +1,27 @@
+/**
+ * An entity related to a security problem.
+ */
+export interface RelatedEntity {
+    /**
+     * The Dynatrace entity ID of the entity.
+     */
+    id?: string;
+    /**
+     * The number of affected entities related to the entity.
+     */
+    numberOfAffectedEntities?: number;
+    /**
+     * A list of affected entities related to the entity.
+     */
+    affectedEntities?: string[];
+}
+/** @ignore */
+export declare namespace _RelatedEntityTransformation {
+    interface AsJson {
+        id?: string;
+        numberOfAffectedEntities?: number;
+        affectedEntities?: string[];
+    }
+    function fromJson(model: AsJson): RelatedEntity;
+    function toJson(model: RelatedEntity): AsJson;
+}

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

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

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

@@ -0,0 +1,30 @@
+import { RelatedServiceExposure, _RelatedServiceExposureTransformation } from './related-service-exposure';
+/**
+ * A service related to a security problem.
+ */
+export interface RelatedService {
+    /**
+     * The Dynatrace entity ID of the entity.
+     */
+    id?: string;
+    /**
+     * The number of affected entities related to the entity.
+     */
+    numberOfAffectedEntities?: number;
+    /**
+     * A list of affected entities related to the entity.
+     */
+    affectedEntities?: string[];
+    exposure?: RelatedServiceExposure;
+}
+/** @ignore */
+export declare namespace _RelatedServiceTransformation {
+    interface AsJson {
+        id?: string;
+        numberOfAffectedEntities?: number;
+        affectedEntities?: string[];
+        exposure?: _RelatedServiceExposureTransformation.AsJson;
+    }
+    function fromJson(model: AsJson): RelatedService;
+    function toJson(model: RelatedService): AsJson;
+}

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

@@ -0,0 +1,33 @@
+/**
+ * Contains data related to a single instance of a release.
+ * An instance is a Process Group Instance and has an optional build version.
+ */
+export interface ReleaseInstance {
+    /**
+     * The build version
+     */
+    buildVersion?: string;
+    /**
+     * List of Security vulnerabilities Ids
+     */
+    securityVulnerabilities?: string[];
+    /**
+     * The entity id of the instance.
+     */
+    entityId?: string;
+    /**
+     * List of event Ids of open problems
+     */
+    problems?: string[];
+}
+/** @ignore */
+export declare namespace _ReleaseInstanceTransformation {
+    interface AsJson {
+        buildVersion?: string;
+        securityVulnerabilities?: string[];
+        entityId?: string;
+        problems?: string[];
+    }
+    function fromJson(model: AsJson): ReleaseInstance;
+    function toJson(model: ReleaseInstance): AsJson;
+}

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

@@ -0,0 +1,89 @@
+import { ReleaseInstance, _ReleaseInstanceTransformation } from './release-instance';
+import { SoftwareTechs, _SoftwareTechsTransformation } from './software-techs';
+/**
+ * Contains data related to a single release of a component.
+ * A Release is a combination of a component and a version.
+ * A Component can be any form of deployable that can be associated with a version.
+ * In the first draft, a Component is always a Service.
+ *
+ * The tuple <name, product, stage, version> is always unique.
+ */
+export interface Release {
+    /**
+     * The entity id of correlating release.
+     */
+    releaseEntityId?: string;
+    /**
+     * The entity has one or more security vulnerabilities
+     */
+    affectedBySecurityVulnerabilities?: boolean;
+    /**
+     * The count of bytes per second of the entity
+     */
+    throughput?: number;
+    /**
+     * The software technologies of the release
+     */
+    softwareTechs?: SoftwareTechs[];
+    /**
+     * The number of security vulnerabilities of the entity
+     */
+    securityVulnerabilitiesCount?: number;
+    /**
+     * The entity has one or more problems
+     */
+    affectedByProblems?: boolean;
+    /**
+     * Indicates that the security vulnerabilities feature is enabled
+     */
+    securityVulnerabilitiesEnabled?: boolean;
+    /**
+     * The product name
+     */
+    product?: string;
+    /**
+     * The instances entityIds included in this release
+     */
+    instances?: ReleaseInstance[];
+    /**
+     * The related PGI is still running/monitored
+     */
+    running?: boolean;
+    /**
+     * The identified release version
+     */
+    version?: string;
+    /**
+     * The entity name
+     */
+    name?: string;
+    /**
+     * The number of problems of the entity
+     */
+    problemCount?: number;
+    /**
+     * The stage name
+     */
+    stage?: string;
+}
+/** @ignore */
+export declare namespace _ReleaseTransformation {
+    interface AsJson {
+        releaseEntityId?: string;
+        affectedBySecurityVulnerabilities?: boolean;
+        throughput?: number;
+        softwareTechs?: _SoftwareTechsTransformation.AsJson[];
+        securityVulnerabilitiesCount?: number;
+        affectedByProblems?: boolean;
+        securityVulnerabilitiesEnabled?: boolean;
+        product?: string;
+        instances?: _ReleaseInstanceTransformation.AsJson[];
+        running?: boolean;
+        version?: string;
+        name?: string;
+        problemCount?: number;
+        stage?: string;
+    }
+    function fromJson(model: AsJson): Release;
+    function toJson(model: Release): AsJson;
+}

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

@@ -0,0 +1,40 @@
+import { Release, _ReleaseTransformation } from './release';
+/**
+ * A list of releases.
+ */
+export interface Releases {
+    /**
+     * A list of releases.
+     */
+    releases?: Release[];
+    /**
+     * Number of releases with problems.
+     */
+    releasesWithProblems?: number;
+    /**
+     * 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 _ReleasesTransformation {
+    interface AsJson {
+        releases?: _ReleaseTransformation.AsJson[];
+        releasesWithProblems?: number;
+        pageSize?: number;
+        nextPageKey?: string;
+        totalCount: number;
+    }
+    function fromJson(model: AsJson): Releases;
+    function toJson(model: Releases): AsJson;
+}