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

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

@@ -0,0 +1,170 @@
+import { SloBurnRate, _SloBurnRateTransformation } from './slo-burn-rate';
+import { SLOEvaluationType, _SLOEvaluationTypeTransformation } from './slo-evaluation-type';
+import { SLOStatus, _SLOStatusTransformation } from './slo-status';
+/**
+ * Parameters of a service-level objective (SLO).
+ */
+export interface SLO {
+    /**
+     * The entity filter for fetching the number of problems related to an SLO. Auto-generated in case no filter has been added to the SLO.
+     */
+    problemFilters?: string[];
+    /**
+     * The error budget burn rate key for a metric expression.
+     */
+    burnRateMetricKey?: string;
+    /**
+     * The error budget key for a metric expression.
+     */
+    errorBudgetMetricKey?: string;
+    /**
+     * The normalized error budget key for a metric expression.
+     */
+    normalizedErrorBudgetMetricKey?: string;
+    /**
+     * The numerator value used to evaluate the SLO when **useRateMetric** is set to `false`.
+     */
+    numeratorValue?: number;
+    /**
+     * The denominator value used to evaluate the SLO when **useRateMetric** is set to `false`.
+     */
+    denominatorValue?: number;
+    /**
+     * Number of OPEN problems related to the SLO.
+     *
+     * Has the value of `-1` if there's an error with fetching SLO related problems.
+     */
+    relatedOpenProblems?: number;
+    /**
+     * Total number of problems related to the SLO.
+     *
+     * Has the value of `-1` if there's an error with fetching SLO related problems.
+     */
+    relatedTotalProblems?: number;
+    /**
+     * The calculated value of the SLO. Has the value of the evaluated SLO or the value of `-1`:
+     *
+     * * If there is an error with the SLO calculation; in that case check the value of the **error** property.
+     * * If the evaluate parameter has not been set to `true`; in that case the **error** property will contain no error.
+     */
+    evaluatedPercentage?: number;
+    /**
+     * The error budget of the calculated SLO.
+     *
+     * The error budget is the difference between the calculated and target values. A positive number means all is good; a negative number means trouble.
+     */
+    errorBudget?: number;
+    /**
+     * The percentage-based metric expression for the calculation of the SLO.
+     */
+    metricExpression?: string;
+    /**
+     * The type of the metric to use for SLO calculation:
+     *
+     * * `true`: An existing percentage-based metric.
+     * * `false`: A ratio of two metrics.
+     *
+     * For a list of available metrics, see [Built-in metric page](https://dt-url.net/be03kow) or try the [GET metrics](https://dt-url.net/8e43kxf) API call.
+     */
+    useRateMetric?: boolean;
+    /**
+     * The percentage-based metric for the calculation of the SLO.
+     *
+     * Required when the **useRateMetric** is set to `true`.
+     */
+    metricRate?: string;
+    /**
+     * The metric for the count of successes (the numerator in rate calculation).
+     *
+     * Required when the **useRateMetric** is set to `false`.
+     */
+    metricNumerator?: string;
+    /**
+     * The total count metric (the denominator in rate calculation).
+     *
+     * Required when the **useRateMetric** is set to `false`.
+     */
+    metricDenominator?: string;
+    evaluationType?: SLOEvaluationType;
+    errorBudgetBurnRate?: SloBurnRate;
+    /**
+     * The timeframe for the SLO evaluation. Use the syntax of the global timeframe selector.
+     */
+    timeframe?: string;
+    /**
+     * The key for a metric expression. Once created, metric keys can't be changed
+     */
+    metricKey?: string;
+    /**
+     * The entity filter for the SLO evaluation. Use the [syntax of entity selector](https://dt-url.net/entityselector).
+     */
+    filter?: string;
+    /**
+     * The name of the SLO.
+     */
+    name?: string;
+    /**
+     * The ID of the SLO
+     */
+    id?: string;
+    /**
+     * The target value of the SLO.
+     */
+    target?: number;
+    /**
+     * A short description of the SLO.
+     */
+    description?: string;
+    /**
+     * The SLO is enabled (`true`) or disabled (`false`).
+     */
+    enabled?: boolean;
+    status?: SLOStatus;
+    /**
+     * The error of the SLO calculation.
+     *
+     * If the value differs from `NONE` there's something wrong with the SLO calculation.
+     */
+    error?: string;
+    /**
+     * The warning value of the SLO.
+     *
+     *  At warning state the SLO is still fulfilled but is getting close to failure.
+     */
+    warning?: number;
+}
+/** @ignore */
+export declare namespace _SLOTransformation {
+    interface AsJson {
+        problemFilters?: string[];
+        burnRateMetricKey?: string;
+        errorBudgetMetricKey?: string;
+        normalizedErrorBudgetMetricKey?: string;
+        numeratorValue?: number;
+        denominatorValue?: number;
+        relatedOpenProblems?: number;
+        relatedTotalProblems?: number;
+        evaluatedPercentage?: number;
+        errorBudget?: number;
+        metricExpression?: string;
+        useRateMetric?: boolean;
+        metricRate?: string;
+        metricNumerator?: string;
+        metricDenominator?: string;
+        evaluationType?: _SLOEvaluationTypeTransformation.AsJson;
+        errorBudgetBurnRate?: _SloBurnRateTransformation.AsJson;
+        timeframe?: string;
+        metricKey?: string;
+        filter?: string;
+        name?: string;
+        id?: string;
+        target?: number;
+        description?: string;
+        enabled?: boolean;
+        status?: _SLOStatusTransformation.AsJson;
+        error?: string;
+        warning?: number;
+    }
+    function fromJson(model: AsJson): SLO;
+    function toJson(model: SLO): AsJson;
+}

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

@@ -0,0 +1,32 @@
+/**
+ * Contains information about the used software technology.
+ */
+export interface SoftwareTechs {
+    /**
+     * The type of the technology.
+     */
+    technology?: string;
+    /**
+     * The edition of the technology.
+     */
+    edition?: string;
+    /**
+     * The verbatim type of the technology.
+     */
+    verbatimType?: string;
+    /**
+     * The version of the technology.
+     */
+    version?: string;
+}
+/** @ignore */
+export declare namespace _SoftwareTechsTransformation {
+    interface AsJson {
+        technology?: string;
+        edition?: string;
+        verbatimType?: string;
+        version?: string;
+    }
+    function fromJson(model: AsJson): SoftwareTechs;
+    function toJson(model: SoftwareTechs): AsJson;
+}

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

@@ -0,0 +1,13 @@
+import { AbstractSloAlertDto, _AbstractSloAlertDtoTransformation } from './abstract-slo-alert-dto';
+/**
+ * Parameters of a status alert.
+ */
+export interface StatusAlert extends AbstractSloAlertDto {
+}
+/** @ignore */
+export declare namespace _StatusAlertTransformation {
+    interface AsJson extends _AbstractSloAlertDtoTransformation.AsJson {
+    }
+    function fromJson(model: AsJson): StatusAlert;
+    function toJson(model: StatusAlert): AsJson;
+}

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

@@ -0,0 +1,15 @@
+import { FormDataRequestBody, FormDataResponseBody } from '@dynatrace-sdk/http-client';
+import { Success, _SuccessTransformation } from './success';
+export interface SuccessEnvelope {
+    details?: Success;
+}
+/** @ignore */
+export declare namespace _SuccessEnvelopeTransformation {
+    interface AsJson {
+        details?: _SuccessTransformation.AsJson;
+    }
+    function fromJson(model: AsJson): SuccessEnvelope;
+    function toJson(model: SuccessEnvelope): AsJson;
+    function fromFormData(formData: FormDataResponseBody): SuccessEnvelope;
+    function toFormData(model: SuccessEnvelope): FormDataRequestBody;
+}

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

@@ -0,0 +1,19 @@
+export interface Success {
+    /**
+     * Detailed message
+     */
+    message?: string;
+    /**
+     * The HTTP status code
+     */
+    code?: number;
+}
+/** @ignore */
+export declare namespace _SuccessTransformation {
+    interface AsJson {
+        message?: string;
+        code?: number;
+    }
+    function fromJson(model: AsJson): Success;
+    function toJson(model: Success): AsJson;
+}

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

@@ -0,0 +1,22 @@
+/**
+ * A DTO for synthetic configuration.
+ */
+export interface SyntheticConfigDto {
+    /**
+     * bmMonitorTimeout - browser monitor execution timeout (ms)
+     */
+    bmMonitorTimeout: number;
+    /**
+     * bmStepTimeout - browser monitor single step execution timeout (ms)
+     */
+    bmStepTimeout: number;
+}
+/** @ignore */
+export declare namespace _SyntheticConfigDtoTransformation {
+    interface AsJson {
+        bmMonitorTimeout: number;
+        bmStepTimeout: number;
+    }
+    function fromJson(model: AsJson): SyntheticConfigDto;
+    function toJson(model: SyntheticConfigDto): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/synthetic-on-demand-batch-status-batch-status.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The status of the batch.
+ */
+export declare enum SyntheticOnDemandBatchStatusBatchStatus {
+    Failed = "FAILED",
+    FailedToExecute = "FAILED_TO_EXECUTE",
+    NotTriggered = "NOT_TRIGGERED",
+    Running = "RUNNING",
+    Success = "SUCCESS"
+}
+/** @ignore */
+export declare namespace _SyntheticOnDemandBatchStatusBatchStatusTransformation {
+    type AsJson = SyntheticOnDemandBatchStatusBatchStatus;
+    const toJson: (value: SyntheticOnDemandBatchStatusBatchStatus) => AsJson;
+    const fromJson: (value: AsJson) => SyntheticOnDemandBatchStatusBatchStatus;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/synthetic-on-demand-batch-status-metadata.d.ts

@@ -0,0 +1,14 @@
+/**
+ * String to string map of metadata properties for batch
+ */
+export interface SyntheticOnDemandBatchStatusMetadata {
+    [propName: string]: string | undefined;
+}
+/** @ignore */
+export declare namespace _SyntheticOnDemandBatchStatusMetadataTransformation {
+    interface AsJson {
+        [propName: string]: string | undefined;
+    }
+    function fromJson(model: AsJson): SyntheticOnDemandBatchStatusMetadata;
+    function toJson(model: SyntheticOnDemandBatchStatusMetadata): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/synthetic-on-demand-batch-status.d.ts

@@ -0,0 +1,61 @@
+import { SyntheticOnDemandBatchStatusBatchStatus, _SyntheticOnDemandBatchStatusBatchStatusTransformation } from './synthetic-on-demand-batch-status-batch-status';
+import { SyntheticOnDemandBatchStatusMetadata, _SyntheticOnDemandBatchStatusMetadataTransformation } from './synthetic-on-demand-batch-status-metadata';
+import { SyntheticOnDemandFailedExecutionStatus, _SyntheticOnDemandFailedExecutionStatusTransformation } from './synthetic-on-demand-failed-execution-status';
+import { SyntheticOnDemandTriggeringProblemDetails, _SyntheticOnDemandTriggeringProblemDetailsTransformation } from './synthetic-on-demand-triggering-problem-details';
+/**
+ * Contains information about on-demand executions triggered within the batch.
+ */
+export interface SyntheticOnDemandBatchStatus {
+    /**
+     * The identifier of the batch.
+     */
+    batchId: number;
+    /**
+     * The name of the user who triggered execution of the batch.
+     */
+    userId: string;
+    batchStatus: SyntheticOnDemandBatchStatusBatchStatus;
+    /**
+     * The number of triggered executions within the batch.
+     */
+    triggeredCount: number;
+    /**
+     * The number of triggered executions with the result SUCCESS or FAILED.
+     */
+    executedCount: number;
+    /**
+     * The number of triggered executions with the result FAILED.
+     */
+    failedCount: number;
+    failedExecutions?: SyntheticOnDemandFailedExecutionStatus[];
+    /**
+     * The number of executions that were triggered and timed out because of a problem with the Synthetic engine.
+     */
+    failedToExecuteCount: number;
+    failedToExecute?: SyntheticOnDemandFailedExecutionStatus[];
+    metadata?: SyntheticOnDemandBatchStatusMetadata;
+    /**
+     * The number of executions that were not triggered due to some problems.
+     */
+    triggeringProblemsCount?: number;
+    triggeringProblems?: SyntheticOnDemandTriggeringProblemDetails[];
+}
+/** @ignore */
+export declare namespace _SyntheticOnDemandBatchStatusTransformation {
+    interface AsJson {
+        batchId: number;
+        userId: string;
+        batchStatus: _SyntheticOnDemandBatchStatusBatchStatusTransformation.AsJson;
+        triggeredCount: number;
+        executedCount: number;
+        failedCount: number;
+        failedExecutions?: _SyntheticOnDemandFailedExecutionStatusTransformation.AsJson[];
+        failedToExecuteCount: number;
+        failedToExecute?: _SyntheticOnDemandFailedExecutionStatusTransformation.AsJson[];
+        metadata?: _SyntheticOnDemandBatchStatusMetadataTransformation.AsJson;
+        triggeringProblemsCount?: number;
+        triggeringProblems?: _SyntheticOnDemandTriggeringProblemDetailsTransformation.AsJson[];
+    }
+    function fromJson(model: AsJson): SyntheticOnDemandBatchStatus;
+    function toJson(model: SyntheticOnDemandBatchStatus): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/synthetic-on-demand-execution-execution-stage.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Execution stage.
+ */
+export declare enum SyntheticOnDemandExecutionExecutionStage {
+    DataRetrieved = "DATA_RETRIEVED",
+    Executed = "EXECUTED",
+    NotTriggered = "NOT_TRIGGERED",
+    TimedOut = "TIMED_OUT",
+    Triggered = "TRIGGERED"
+}
+/** @ignore */
+export declare namespace _SyntheticOnDemandExecutionExecutionStageTransformation {
+    type AsJson = SyntheticOnDemandExecutionExecutionStage;
+    const toJson: (value: SyntheticOnDemandExecutionExecutionStage) => AsJson;
+    const fromJson: (value: AsJson) => SyntheticOnDemandExecutionExecutionStage;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/synthetic-on-demand-execution-metadata.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Metadata map for the execution batch.
+ */
+export interface SyntheticOnDemandExecutionMetadata {
+    [propName: string]: string | undefined;
+}
+/** @ignore */
+export declare namespace _SyntheticOnDemandExecutionMetadataTransformation {
+    interface AsJson {
+        [propName: string]: string | undefined;
+    }
+    function fromJson(model: AsJson): SyntheticOnDemandExecutionMetadata;
+    function toJson(model: SyntheticOnDemandExecutionMetadata): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/synthetic-on-demand-execution-request-group.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Contains parameters for the on-demand execution of monitors identified by tags, applications, or services.
+ */
+export interface SyntheticOnDemandExecutionRequestGroup {
+    /**
+     * List of tags. Only monitors with all tags assigned will be executed.
+     */
+    tags?: string[];
+    /**
+     * List of application identifiers. Only monitors with all applications assigned will be executed.
+     */
+    applications?: string[];
+    /**
+     * List of service identifiers. Only monitors with all services assigned will be executed.
+     */
+    services?: string[];
+    /**
+     * The locations from where monitors are to be executed.
+     */
+    locations?: string[];
+}
+/** @ignore */
+export declare namespace _SyntheticOnDemandExecutionRequestGroupTransformation {
+    interface AsJson {
+        tags?: string[];
+        applications?: string[];
+        services?: string[];
+        locations?: string[];
+    }
+    function fromJson(model: AsJson): SyntheticOnDemandExecutionRequestGroup;
+    function toJson(model: SyntheticOnDemandExecutionRequestGroup): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/synthetic-on-demand-execution-request-metadata.d.ts

@@ -0,0 +1,14 @@
+/**
+ * String to string map of metadata properties for execution
+ */
+export interface SyntheticOnDemandExecutionRequestMetadata {
+    [propName: string]: string | undefined;
+}
+/** @ignore */
+export declare namespace _SyntheticOnDemandExecutionRequestMetadataTransformation {
+    interface AsJson {
+        [propName: string]: string | undefined;
+    }
+    function fromJson(model: AsJson): SyntheticOnDemandExecutionRequestMetadata;
+    function toJson(model: SyntheticOnDemandExecutionRequestMetadata): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/synthetic-on-demand-execution-request-monitor.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Contains monitors to be executed on demand from the locations specified.
+ */
+export interface SyntheticOnDemandExecutionRequestMonitor {
+    /**
+     * The monitor identifier
+     */
+    monitorId: string;
+    /**
+     * The locations from where the monitor is to be executed.
+     */
+    locations?: string[];
+}
+/** @ignore */
+export declare namespace _SyntheticOnDemandExecutionRequestMonitorTransformation {
+    interface AsJson {
+        monitorId: string;
+        locations?: string[];
+    }
+    function fromJson(model: AsJson): SyntheticOnDemandExecutionRequestMonitor;
+    function toJson(model: SyntheticOnDemandExecutionRequestMonitor): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/synthetic-on-demand-execution-request-processing-mode.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The execution's processing mode
+ */
+export declare enum SyntheticOnDemandExecutionRequestProcessingMode {
+    Standard = "STANDARD",
+    DisableProblemDetection = "DISABLE_PROBLEM_DETECTION",
+    ExecutionsDetailsOnly = "EXECUTIONS_DETAILS_ONLY"
+}
+/** @ignore */
+export declare namespace _SyntheticOnDemandExecutionRequestProcessingModeTransformation {
+    type AsJson = SyntheticOnDemandExecutionRequestProcessingMode;
+    const toJson: (value: SyntheticOnDemandExecutionRequestProcessingMode) => AsJson;
+    const fromJson: (value: AsJson) => SyntheticOnDemandExecutionRequestProcessingMode;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/synthetic-on-demand-execution-request.d.ts

@@ -0,0 +1,42 @@
+import { SyntheticOnDemandExecutionRequestGroup, _SyntheticOnDemandExecutionRequestGroupTransformation } from './synthetic-on-demand-execution-request-group';
+import { SyntheticOnDemandExecutionRequestMetadata, _SyntheticOnDemandExecutionRequestMetadataTransformation } from './synthetic-on-demand-execution-request-metadata';
+import { SyntheticOnDemandExecutionRequestMonitor, _SyntheticOnDemandExecutionRequestMonitorTransformation } from './synthetic-on-demand-execution-request-monitor';
+import { SyntheticOnDemandExecutionRequestProcessingMode, _SyntheticOnDemandExecutionRequestProcessingModeTransformation } from './synthetic-on-demand-execution-request-processing-mode';
+/**
+ * Contains parameters for the on-demand execution of monitors identified by tags, applications, or services.
+ */
+export interface SyntheticOnDemandExecutionRequest {
+    processingMode?: SyntheticOnDemandExecutionRequestProcessingMode;
+    /**
+     * If true, the status will be FAILED in case of performance issue.
+     */
+    failOnPerformanceIssue?: boolean;
+    /**
+     * If true, no executions will be scheduled if a problem occurs.
+     */
+    stopOnProblem?: boolean;
+    /**
+     * If true, the screenshots will be taken during the execution of a browser monitor.
+     */
+    takeScreenshotsOnSuccess?: boolean;
+    /**
+     * List of monitors to be triggered.
+     */
+    monitors?: SyntheticOnDemandExecutionRequestMonitor[];
+    group?: SyntheticOnDemandExecutionRequestGroup;
+    metadata?: SyntheticOnDemandExecutionRequestMetadata;
+}
+/** @ignore */
+export declare namespace _SyntheticOnDemandExecutionRequestTransformation {
+    interface AsJson {
+        processingMode?: _SyntheticOnDemandExecutionRequestProcessingModeTransformation.AsJson;
+        failOnPerformanceIssue?: boolean;
+        stopOnProblem?: boolean;
+        takeScreenshotsOnSuccess?: boolean;
+        monitors?: _SyntheticOnDemandExecutionRequestMonitorTransformation.AsJson[];
+        group?: _SyntheticOnDemandExecutionRequestGroupTransformation.AsJson;
+        metadata?: _SyntheticOnDemandExecutionRequestMetadataTransformation.AsJson;
+    }
+    function fromJson(model: AsJson): SyntheticOnDemandExecutionRequest;
+    function toJson(model: SyntheticOnDemandExecutionRequest): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/synthetic-on-demand-execution-result.d.ts

@@ -0,0 +1,39 @@
+import { SyntheticOnDemandTriggeredMonitor, _SyntheticOnDemandTriggeredMonitorTransformation } from './synthetic-on-demand-triggered-monitor';
+import { SyntheticOnDemandTriggeringProblemDetails, _SyntheticOnDemandTriggeringProblemDetailsTransformation } from './synthetic-on-demand-triggering-problem-details';
+/**
+ * The result of on-demand synthetic monitor execution.
+ */
+export interface SyntheticOnDemandExecutionResult {
+    /**
+     * The batch identifier of the triggered executions.
+     */
+    batchId: string;
+    /**
+     * The total number of problems within the batch.
+     */
+    triggeringProblemsCount: number;
+    /**
+     * List with the entities for which triggering problems occurred.
+     */
+    triggeringProblemsDetails?: SyntheticOnDemandTriggeringProblemDetails[];
+    /**
+     * The total number of the triggered executions within the batch.
+     */
+    triggeredCount: number;
+    /**
+     * Monitors for which on-demand executions were triggered.
+     */
+    triggered?: SyntheticOnDemandTriggeredMonitor[];
+}
+/** @ignore */
+export declare namespace _SyntheticOnDemandExecutionResultTransformation {
+    interface AsJson {
+        batchId: string;
+        triggeringProblemsCount: number;
+        triggeringProblemsDetails?: _SyntheticOnDemandTriggeringProblemDetailsTransformation.AsJson[];
+        triggeredCount: number;
+        triggered?: _SyntheticOnDemandTriggeredMonitorTransformation.AsJson[];
+    }
+    function fromJson(model: AsJson): SyntheticOnDemandExecutionResult;
+    function toJson(model: SyntheticOnDemandExecutionResult): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/synthetic-on-demand-execution-source.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The source of the triggering request.
+ */
+export declare enum SyntheticOnDemandExecutionSource {
+    Api = "API",
+    Ui = "UI"
+}
+/** @ignore */
+export declare namespace _SyntheticOnDemandExecutionSourceTransformation {
+    type AsJson = SyntheticOnDemandExecutionSource;
+    const toJson: (value: SyntheticOnDemandExecutionSource) => AsJson;
+    const fromJson: (value: AsJson) => SyntheticOnDemandExecutionSource;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/synthetic-on-demand-execution.d.ts

@@ -0,0 +1,67 @@
+import { ExecutionFullResults, _ExecutionFullResultsTransformation } from './execution-full-results';
+import { ExecutionSimpleResults, _ExecutionSimpleResultsTransformation } from './execution-simple-results';
+import { SyntheticOnDemandExecutionExecutionStage, _SyntheticOnDemandExecutionExecutionStageTransformation } from './synthetic-on-demand-execution-execution-stage';
+import { SyntheticOnDemandExecutionMetadata, _SyntheticOnDemandExecutionMetadataTransformation } from './synthetic-on-demand-execution-metadata';
+import { SyntheticOnDemandExecutionSource, _SyntheticOnDemandExecutionSourceTransformation } from './synthetic-on-demand-execution-source';
+/**
+ * Describes the status of an on-demand execution.
+ */
+export interface SyntheticOnDemandExecution {
+    /**
+     * The identifier of the batch.
+     */
+    batchId: string;
+    /**
+     * The identifier of the execution.
+     */
+    executionId: string;
+    executionStage: SyntheticOnDemandExecutionExecutionStage;
+    /**
+     * The scheduling timestamp, in UTC milliseconds.
+     */
+    schedulingTimestamp: number;
+    /**
+     * The timestamp when execution was finished, in UTC milliseconds.
+     */
+    executionTimestamp: number;
+    /**
+     * The timestamp when whole data set has been collected on server, in UTC milliseconds.
+     */
+    dataDeliveryTimestamp: number;
+    /**
+     * The identifier of the monitor.
+     */
+    monitorId: string;
+    /**
+     * The identifier of the location from where the monitor is to be executed.
+     */
+    locationId: string;
+    /**
+     * The name of the user who triggered the on-demand execution.
+     */
+    userId: string;
+    metadata?: SyntheticOnDemandExecutionMetadata;
+    source: SyntheticOnDemandExecutionSource;
+    simpleResults?: ExecutionSimpleResults;
+    fullResults?: ExecutionFullResults;
+}
+/** @ignore */
+export declare namespace _SyntheticOnDemandExecutionTransformation {
+    interface AsJson {
+        batchId: string;
+        executionId: string;
+        executionStage: _SyntheticOnDemandExecutionExecutionStageTransformation.AsJson;
+        schedulingTimestamp: number;
+        executionTimestamp: number;
+        dataDeliveryTimestamp: number;
+        monitorId: string;
+        locationId: string;
+        userId: string;
+        metadata?: _SyntheticOnDemandExecutionMetadataTransformation.AsJson;
+        source: _SyntheticOnDemandExecutionSourceTransformation.AsJson;
+        simpleResults?: _ExecutionSimpleResultsTransformation.AsJson;
+        fullResults?: _ExecutionFullResultsTransformation.AsJson;
+    }
+    function fromJson(model: AsJson): SyntheticOnDemandExecution;
+    function toJson(model: SyntheticOnDemandExecution): AsJson;
+}