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

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

@@ -0,0 +1,24 @@
+import { CredentialsResponseElement, _CredentialsResponseElementTransformation } from './credentials-response-element';
+/**
+ * A list of credentials sets for Synthetic monitors.
+ */
+export interface CredentialsList {
+    totalCount?: number;
+    pageSize?: number;
+    nextPageKey?: string;
+    /**
+     * A list of credentials sets for Synthetic monitors.
+     */
+    credentials: CredentialsResponseElement[];
+}
+/** @ignore */
+export declare namespace _CredentialsListTransformation {
+    interface AsJson {
+        totalCount?: number;
+        pageSize?: number;
+        nextPageKey?: string;
+        credentials: _CredentialsResponseElementTransformation.AsJson[];
+    }
+    function fromJson(model: AsJson): CredentialsList;
+    function toJson(model: CredentialsList): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/credentials-response-element-scope.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The scope of the credentials set.
+ */
+export declare enum CredentialsResponseElementScope {
+    All = "ALL",
+    Extension = "EXTENSION",
+    Synthetic = "SYNTHETIC",
+    Unknown = "UNKNOWN",
+    AppEngine = "APP_ENGINE"
+}
+/** @ignore */
+export declare namespace _CredentialsResponseElementScopeTransformation {
+    type AsJson = CredentialsResponseElementScope;
+    const toJson: (value: CredentialsResponseElementScope) => AsJson;
+    const fromJson: (value: AsJson) => CredentialsResponseElementScope;
+}

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

@@ -0,0 +1,16 @@
+/**
+ * The type of the credentials set.
+ */
+export declare enum CredentialsResponseElementType {
+    Certificate = "CERTIFICATE",
+    PublicCertificate = "PUBLIC_CERTIFICATE",
+    Token = "TOKEN",
+    Unknown = "UNKNOWN",
+    UsernamePassword = "USERNAME_PASSWORD"
+}
+/** @ignore */
+export declare namespace _CredentialsResponseElementTypeTransformation {
+    type AsJson = CredentialsResponseElementType;
+    const toJson: (value: CredentialsResponseElementType) => AsJson;
+    const fromJson: (value: AsJson) => CredentialsResponseElementType;
+}

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

@@ -0,0 +1,52 @@
+import { CredentialUsageHandler, _CredentialUsageHandlerTransformation } from './credential-usage-handler';
+import { CredentialsResponseElementScope, _CredentialsResponseElementScopeTransformation } from './credentials-response-element-scope';
+import { CredentialsResponseElementType, _CredentialsResponseElementTypeTransformation } from './credentials-response-element-type';
+import { ExternalVaultConfig, _ExternalVaultConfigTransformation } from './external-vault-config';
+/**
+ * Metadata of the credentials set.
+ */
+export interface CredentialsResponseElement {
+    /**
+     * The name of the credentials set.
+     */
+    name: string;
+    /**
+     * The ID of the credentials set.
+     */
+    id?: string;
+    /**
+     * A short description of the credentials set.
+     */
+    description: string;
+    /**
+     * The owner of the credential (user for which used API token was created).
+     */
+    owner: string;
+    /**
+     * Flag indicating that this credential is visible only to the owner.
+     */
+    ownerAccessOnly: boolean;
+    scope?: CredentialsResponseElementScope;
+    externalVault?: ExternalVaultConfig;
+    /**
+     * The list contains summary data related to the use of credentials.
+     */
+    credentialUsageSummary: CredentialUsageHandler[];
+    type: CredentialsResponseElementType;
+}
+/** @ignore */
+export declare namespace _CredentialsResponseElementTransformation {
+    interface AsJson {
+        name: string;
+        id?: string;
+        description: string;
+        owner: string;
+        ownerAccessOnly: boolean;
+        scope?: _CredentialsResponseElementScopeTransformation.AsJson;
+        externalVault?: _ExternalVaultConfigTransformation.AsJson;
+        credentialUsageSummary: _CredentialUsageHandlerTransformation.AsJson[];
+        type: _CredentialsResponseElementTypeTransformation.AsJson;
+    }
+    function fromJson(model: AsJson): CredentialsResponseElement;
+    function toJson(model: CredentialsResponseElement): AsJson;
+}

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

@@ -0,0 +1,16 @@
+/**
+ * The scope of the credentials set.
+ */
+export declare enum CredentialsScope {
+    All = "ALL",
+    Extension = "EXTENSION",
+    Synthetic = "SYNTHETIC",
+    Unknown = "UNKNOWN",
+    AppEngine = "APP_ENGINE"
+}
+/** @ignore */
+export declare namespace _CredentialsScopeTransformation {
+    type AsJson = CredentialsScope;
+    const toJson: (value: CredentialsScope) => AsJson;
+    const fromJson: (value: AsJson) => CredentialsScope;
+}

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

@@ -0,0 +1,20 @@
+/**
+ * Defines the actual set of fields depending on the value. See one of the following objects:
+ *
+ * * `CERTIFICATE` -> CertificateCredentials
+ * * `PUBLIC_CERTIFICATE` -> PublicCertificateCredentials
+ * * `USERNAME_PASSWORD` -> UserPasswordCredentials
+ * * `TOKEN` -> TokenCredentials
+ */
+export declare enum CredentialsType {
+    Certificate = "CERTIFICATE",
+    PublicCertificate = "PUBLIC_CERTIFICATE",
+    Token = "TOKEN",
+    UsernamePassword = "USERNAME_PASSWORD"
+}
+/** @ignore */
+export declare namespace _CredentialsTypeTransformation {
+    type AsJson = CredentialsType;
+    const toJson: (value: CredentialsType) => AsJson;
+    const fromJson: (value: AsJson) => CredentialsType;
+}

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

@@ -0,0 +1,48 @@
+import { CertificateCredentials } from './certificate-credentials';
+import { CredentialsScope, _CredentialsScopeTransformation } from './credentials-scope';
+import { CredentialsType, _CredentialsTypeTransformation } from './credentials-type';
+import { PublicCertificateCredentials } from './public-certificate-credentials';
+import { TokenCredentials } from './token-credentials';
+import { UserPasswordCredentials } from './user-password-credentials';
+/**
+ * A set of credentials for synthetic monitors.
+ *
+ * The actual set of fields depends on the type of credentials. Find the list of actual objects in the description of the **type** field or see [Credential vault API - JSON models](https://dt-url.net/2sa3sen).
+ */
+export interface Credentials {
+    /**
+     * The name of the credentials set.
+     */
+    name: string;
+    /**
+     * The ID of the credentials set.
+     */
+    id?: string;
+    /**
+     * A short description of the credentials set.
+     */
+    description?: string;
+    /**
+     * The credentials set is available to every user (`false`) or to owner only (`true`).
+     */
+    ownerAccessOnly?: boolean;
+    scope: CredentialsScope;
+    type?: CredentialsType;
+}
+/** @ignore */
+export declare namespace _CredentialsTransformation {
+    function isCertificateCredentials(model: Credentials): model is CertificateCredentials;
+    function isPublicCertificateCredentials(model: Credentials): model is PublicCertificateCredentials;
+    function isUserPasswordCredentials(model: Credentials): model is UserPasswordCredentials;
+    function isTokenCredentials(model: Credentials): model is TokenCredentials;
+    interface AsJson {
+        name: string;
+        id?: string;
+        description?: string;
+        ownerAccessOnly?: boolean;
+        scope: _CredentialsScopeTransformation.AsJson;
+        type?: _CredentialsTypeTransformation.AsJson;
+    }
+    function fromJson(model: AsJson, includeChildProps?: boolean): Credentials;
+    function toJson(model: Credentials, includeChildProps?: boolean): AsJson;
+}

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

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

package/types/packages/client/classic-environment-v2/src/lib/models/custom-device-creation-properties.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The list of key-value pair properties that will be shown beneath the infographics of your custom device.
+ */
+export interface CustomDeviceCreationProperties {
+    [propName: string]: string | undefined;
+}
+/** @ignore */
+export declare namespace _CustomDeviceCreationPropertiesTransformation {
+    interface AsJson {
+        [propName: string]: string | undefined;
+    }
+    function fromJson(model: AsJson): CustomDeviceCreationProperties;
+    function toJson(model: CustomDeviceCreationProperties): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/custom-device-creation-result.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The short representation of a newly created custom device.
+ */
+export interface CustomDeviceCreationResult {
+    /**
+     * The Dynatrace entity ID of the custom device.
+     */
+    entityId?: string;
+    /**
+     * The Dynatrace entity ID of the custom device group.
+     */
+    groupId?: string;
+}
+/** @ignore */
+export declare namespace _CustomDeviceCreationResultTransformation {
+    interface AsJson {
+        entityId?: string;
+        groupId?: string;
+    }
+    function fromJson(model: AsJson): CustomDeviceCreationResult;
+    function toJson(model: CustomDeviceCreationResult): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/custom-device-creation.d.ts

@@ -0,0 +1,96 @@
+import { CustomDeviceCreationProperties, _CustomDeviceCreationPropertiesTransformation } from './custom-device-creation-properties';
+/**
+ * Configuration of a custom device.
+ */
+export interface CustomDeviceCreation {
+    /**
+     * The internal ID of the custom device.
+     *
+     *  If you use the ID of an existing device, the respective parameters will be updated.
+     */
+    customDeviceId: string;
+    /**
+     * The name of the custom device to be displayed in the user interface.
+     */
+    displayName: string;
+    /**
+     * User defined group ID of entity.
+     *
+     * The group ID helps to keep a consistent picture of device-group relations. One of many cases where a proper group is important is service detection: you can define which custom devices should lead to the same service by defining the same group ID for them.
+     *
+     * If you set a group ID, it will be hashed into the Dynatrace entity ID of the custom device. In that case the custom device can only be part of one custom device group.
+     *
+     * If you don't set the group ID, Dynatrace will create it based on the ID or type of the custom device. Also, the group will not be hashed into the device ID which means the device may switch groups.
+     */
+    group?: string;
+    /**
+     * The list of IP addresses that belong to the custom device.
+     *
+     * These addresses are used to automatically discover the horizontal communication relationship between this component and all other observed components within Smartscape. Once a connection is discovered, it is automatically mapped and shown within Smartscape.
+     *
+     * If you send a value (including an empty value), the existing values will be overwritten.
+     *
+     * If you send `null` or omit this field, the existing values will be kept.
+     */
+    ipAddresses?: string[];
+    /**
+     * The list of ports the custom devices listens to.
+     *
+     * These ports are used to discover the horizontal communication relationship between this component and all other observed components within Smartscape.
+     *
+     * Once a connection is discovered, it is automatically mapped and shown within Smartscape.
+     *
+     * If ports are specified, you should also add at least one IP address or a DNS name for the custom device.
+     *
+     * If you send a value, the existing values will be overwritten.
+     *
+     * If you send `null`, or an empty value, or omit this field, the existing values will be kept.
+     */
+    listenPorts?: number[];
+    /**
+     * The technology type definition of the custom device.
+     *
+     * It must be the same technology type of the metric you're reporting.
+     *
+     * If you send a value, the existing value will be overwritten.
+     *
+     * If you send `null`, empty or omit this field, the existing value will be kept.
+     */
+    type?: string;
+    /**
+     * The icon to be displayed for your custom component within Smartscape. Provide the full URL of the icon file.
+     */
+    faviconUrl?: string;
+    /**
+     * The URL of a configuration web page for the custom device, such as a login page for a firewall or router.
+     */
+    configUrl?: string;
+    properties?: CustomDeviceCreationProperties;
+    /**
+     * The list of DNS names related to the custom device.
+     *
+     * These names are used to automatically discover the horizontal communication relationship between this component and all other observed components within Smartscape. Once a connection is discovered, it is automatically mapped and shown within Smartscape.
+     *
+     * If you send a value, the existing values will be overwritten.
+     *
+     * If you send `null` or an empty value; or omit this field, the existing values will be kept.
+     */
+    dnsNames?: string[];
+}
+/** @ignore */
+export declare namespace _CustomDeviceCreationTransformation {
+    interface AsJson {
+        customDeviceId: string;
+        displayName: string;
+        group?: string;
+        ipAddresses?: string[];
+        listenPorts?: number[];
+        type?: string;
+        faviconUrl?: string;
+        configUrl?: string;
+        properties?: _CustomDeviceCreationPropertiesTransformation.AsJson;
+        dnsNames?: string[];
+    }
+    function fromJson(model: AsJson): CustomDeviceCreation;
+    function toJson(model: CustomDeviceCreation): AsJson;
+}

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

@@ -0,0 +1,23 @@
+import { METag, _METagTransformation } from './me-tag';
+/**
+ * A list of custom tags.
+ */
+export interface CustomEntityTags {
+    /**
+     * A list of custom tags.
+     */
+    tags: METag[];
+    /**
+     * The total number of tags in the response.
+     */
+    totalCount?: number;
+}
+/** @ignore */
+export declare namespace _CustomEntityTagsTransformation {
+    interface AsJson {
+        tags: _METagTransformation.AsJson[];
+        totalCount?: number;
+    }
+    function fromJson(model: AsJson): CustomEntityTags;
+    function toJson(model: CustomEntityTags): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/custom-log-line.d.ts

@@ -0,0 +1,27 @@
+/**
+ * A custom script log line
+ */
+export interface CustomLogLine {
+    /**
+     * A timestamp of this log message
+     */
+    timestamp?: number;
+    /**
+     * Log level of the message
+     */
+    logLevel?: string;
+    /**
+     * The message
+     */
+    message?: string;
+}
+/** @ignore */
+export declare namespace _CustomLogLineTransformation {
+    interface AsJson {
+        timestamp?: number;
+        logLevel?: string;
+        message?: string;
+    }
+    function fromJson(model: AsJson): CustomLogLine;
+    function toJson(model: CustomLogLine): AsJson;
+}

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

@@ -0,0 +1,14 @@
+/**
+ * When to reset datasource value in the UI on filter change.
+ */
+export declare enum DatasourceDefinitionResetValue {
+    Always = "ALWAYS",
+    InvalidOnly = "INVALID_ONLY",
+    Never = "NEVER"
+}
+/** @ignore */
+export declare namespace _DatasourceDefinitionResetValueTransformation {
+    type AsJson = DatasourceDefinitionResetValue;
+    const toJson: (value: DatasourceDefinitionResetValue) => AsJson;
+    const fromJson: (value: AsJson) => DatasourceDefinitionResetValue;
+}

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

@@ -0,0 +1,40 @@
+import { DatasourceDefinitionResetValue, _DatasourceDefinitionResetValueTransformation } from './datasource-definition-reset-value';
+/**
+ * Configuration of a datasource for a property.
+ */
+export interface DatasourceDefinition {
+    /**
+     * The properties to filter the datasource options on.
+     */
+    filterProperties: string[];
+    /**
+     * Whether to validate input to only allow values returned by the datasource.
+     */
+    validate: boolean;
+    /**
+     * Whether this datasource expects full setting payload as the context.
+     */
+    fullContext: boolean;
+    /**
+     * If true, the datasource should use the api to filter the results instead of client-side filtering.
+     */
+    useApiSearch: boolean;
+    resetValue?: DatasourceDefinitionResetValue;
+    /**
+     * The identifier of a custom data source of the property's value.
+     */
+    identifier: string;
+}
+/** @ignore */
+export declare namespace _DatasourceDefinitionTransformation {
+    interface AsJson {
+        filterProperties: string[];
+        validate: boolean;
+        fullContext: boolean;
+        useApiSearch: boolean;
+        resetValue?: _DatasourceDefinitionResetValueTransformation.AsJson;
+        identifier: string;
+    }
+    function fromJson(model: AsJson): DatasourceDefinition;
+    function toJson(model: DatasourceDefinition): AsJson;
+}

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

@@ -0,0 +1,12 @@
+/**
+ * The type of the advice.
+ */
+export declare enum DavisSecurityAdviceAdviceType {
+    Upgrade = "UPGRADE"
+}
+/** @ignore */
+export declare namespace _DavisSecurityAdviceAdviceTypeTransformation {
+    type AsJson = DavisSecurityAdviceAdviceType;
+    const toJson: (value: DavisSecurityAdviceAdviceType) => AsJson;
+    const fromJson: (value: AsJson) => DavisSecurityAdviceAdviceType;
+}

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

@@ -0,0 +1,32 @@
+import { DavisSecurityAdvice, _DavisSecurityAdviceTransformation } from './davis-security-advice';
+/**
+ * A list of advice from the Davis security advisor.
+ */
+export interface DavisSecurityAdviceList {
+    /**
+     * 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;
+    advices?: DavisSecurityAdvice[];
+}
+/** @ignore */
+export declare namespace _DavisSecurityAdviceListTransformation {
+    interface AsJson {
+        totalCount: number;
+        pageSize?: number;
+        nextPageKey?: string;
+        advices?: _DavisSecurityAdviceTransformation.AsJson[];
+    }
+    function fromJson(model: AsJson): DavisSecurityAdviceList;
+    function toJson(model: DavisSecurityAdviceList): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/davis-security-advice-technology.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The technology of the vulnerable component.
+ */
+export declare enum DavisSecurityAdviceTechnology {
+    Dotnet = "DOTNET",
+    Go = "GO",
+    Java = "JAVA",
+    Kubernetes = "KUBERNETES",
+    NodeJs = "NODE_JS",
+    Php = "PHP"
+}
+/** @ignore */
+export declare namespace _DavisSecurityAdviceTechnologyTransformation {
+    type AsJson = DavisSecurityAdviceTechnology;
+    const toJson: (value: DavisSecurityAdviceTechnology) => AsJson;
+    const fromJson: (value: AsJson) => DavisSecurityAdviceTechnology;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/davis-security-advice.d.ts

@@ -0,0 +1,53 @@
+import { DavisSecurityAdviceAdviceType, _DavisSecurityAdviceAdviceTypeTransformation } from './davis-security-advice-advice-type';
+import { DavisSecurityAdviceTechnology, _DavisSecurityAdviceTechnologyTransformation } from './davis-security-advice-technology';
+/**
+ * Security advice from the Davis security advisor.
+ */
+export interface DavisSecurityAdvice {
+    /**
+     * The name of the advice.
+     */
+    name?: string;
+    /**
+     * The vulnerable component to which advice applies.
+     */
+    vulnerableComponent?: string;
+    technology?: DavisSecurityAdviceTechnology;
+    adviceType?: DavisSecurityAdviceAdviceType;
+    /**
+     * IDs of `critical` level [security problems](https://dt-url.net/p103u1h) caused by vulnerable component.
+     */
+    critical?: string[];
+    /**
+     * IDs of `high` level [security problems](https://dt-url.net/p103u1h) caused by vulnerable component.
+     */
+    high?: string[];
+    /**
+     * IDs of `medium` level [security problems](https://dt-url.net/p103u1h) caused by vulnerable component.
+     */
+    medium?: string[];
+    /**
+     * IDs of `low` level [security problems](https://dt-url.net/p103u1h) caused by vulnerable component.
+     */
+    low?: string[];
+    /**
+     * IDs of `none` level [security problems](https://dt-url.net/p103u1h) caused by vulnerable component.
+     */
+    none?: string[];
+}
+/** @ignore */
+export declare namespace _DavisSecurityAdviceTransformation {
+    interface AsJson {
+        name?: string;
+        vulnerableComponent?: string;
+        technology?: _DavisSecurityAdviceTechnologyTransformation.AsJson;
+        adviceType?: _DavisSecurityAdviceAdviceTypeTransformation.AsJson;
+        critical?: string[];
+        high?: string[];
+        medium?: string[];
+        low?: string[];
+        none?: string[];
+    }
+    function fromJson(model: AsJson): DavisSecurityAdvice;
+    function toJson(model: DavisSecurityAdvice): AsJson;
+}

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

@@ -0,0 +1,17 @@
+/**
+ * Deleted custom tag.
+ */
+export interface DeletedEntityTags {
+    /**
+     * The number of monitored entities where the tag has been deleted.
+     */
+    matchedEntitiesCount?: number;
+}
+/** @ignore */
+export declare namespace _DeletedEntityTagsTransformation {
+    interface AsJson {
+        matchedEntitiesCount?: number;
+    }
+    function fromJson(model: AsJson): DeletedEntityTags;
+    function toJson(model: DeletedEntityTags): AsJson;
+}

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

@@ -0,0 +1,55 @@
+import { SettingsValue, _SettingsValueTransformation } from './settings-value';
+/**
+ * An effective settings value.
+ */
+export interface EffectiveSettingsValue {
+    /**
+     * The version of the schema on which the object is based.
+     */
+    schemaVersion?: string;
+    /**
+     * The timestamp of the last modification.
+     */
+    modified?: number;
+    /**
+     * The external identifier of the settings object.
+     */
+    externalId?: string;
+    /**
+     * The user (identified by a user ID or a public token ID) who performed that most recent modification.
+     */
+    author?: string;
+    /**
+     * The schema on which the object is based.
+     */
+    schemaId?: string;
+    /**
+     * The origin of the settings value.
+     */
+    origin?: string;
+    /**
+     * The timestamp of the creation.
+     */
+    created?: number;
+    value?: SettingsValue;
+    /**
+     * A short summary of settings.
+     */
+    summary?: string;
+}
+/** @ignore */
+export declare namespace _EffectiveSettingsValueTransformation {
+    interface AsJson {
+        schemaVersion?: string;
+        modified?: number;
+        externalId?: string;
+        author?: string;
+        schemaId?: string;
+        origin?: string;
+        created?: number;
+        value?: _SettingsValueTransformation.AsJson;
+        summary?: string;
+    }
+    function fromJson(model: AsJson): EffectiveSettingsValue;
+    function toJson(model: EffectiveSettingsValue): AsJson;
+}