@dynatrace-sdk/client-query 1.0.0

package/types/packages/client/query/src/lib/error-envelopes/invalid-response-error.d.ts

@@ -0,0 +1,8 @@
+import { ApiClientError } from './api-client-error';
+export declare class InvalidResponseError extends ApiClientError {
+    responseBody: any;
+    expectedType?: string;
+    nestedError?: Error;
+    constructor(name: string, nestedError: Error | any | undefined, body: any, expectedType?: string, message?: string);
+}
+export declare function isInvalidResponseError(e: any): e is InvalidResponseError;

package/types/packages/client/query/src/lib/index.d.ts

@@ -0,0 +1,3 @@
+export * from './apis';
+export * from './error-envelopes';
+export * from './models';

package/types/packages/client/query/src/lib/models/autocomplete-request.d.ts

@@ -0,0 +1,26 @@
+export interface AutocompleteRequest {
+    /**
+     * The full query string.
+     */
+    query: string;
+    cursorPosition?: number;
+    /**
+     * The query timezone. If none is specified, UTC is used as fallback. The list of valid input values matches that of the IANA Time Zone Database (TZDB). It accepts values in their canonical names like 'Europe/Paris', the abbreviated version like CET or the UTC offset format like '+01:00'
+     */
+    timezone?: string;
+    /**
+     * The query locale. If none specified, then a language/country neutral locale is chosen. The input values take the ISO-639 Language code with an optional ISO-3166 country code appended to it with an underscore. For instance, both values are valid 'en' or 'en_US'.
+     */
+    locale?: string;
+}
+/** @ignore */
+export declare namespace _AutocompleteRequestTransformation {
+    interface AsJson {
+        query: string;
+        cursorPosition?: number;
+        timezone?: string;
+        locale?: string;
+    }
+    function fromJson(model: AsJson): AutocompleteRequest;
+    function toJson(model: AutocompleteRequest): AsJson;
+}

package/types/packages/client/query/src/lib/models/autocomplete-response.d.ts

@@ -0,0 +1,28 @@
+import { AutocompleteSuggestion, _AutocompleteSuggestionTransformation } from './autocomplete-suggestion';
+/**
+ * The response of the autocomplete call.
+ */
+export interface AutocompleteResponse {
+    /**
+     * True if the suggestions are optional.
+     */
+    optional: boolean;
+    /**
+     * The list of suggestions.
+     */
+    suggestions: AutocompleteSuggestion[];
+    /**
+     * Suggested duration in seconds, for how long the response may be cached and reused by the client. It is derived from the volatility of the suggestions on the server (if the suggestions are static, how long the server will cache the volatile suggestions, ...). If not provided, then the result may be cached for long time. Value below 1 means that the result should not be cached.
+     */
+    suggestedTtlSeconds?: number;
+}
+/** @ignore */
+export declare namespace _AutocompleteResponseTransformation {
+    interface AsJson {
+        optional: boolean;
+        suggestions: _AutocompleteSuggestionTransformation.AsJson[];
+        suggestedTtlSeconds?: number;
+    }
+    function fromJson(model: AsJson): AutocompleteResponse;
+    function toJson(model: AutocompleteResponse): AsJson;
+}

package/types/packages/client/query/src/lib/models/autocomplete-suggestion-part.d.ts

@@ -0,0 +1,30 @@
+import { TokenType, _TokenTypeTransformation } from './token-type';
+/**
+ * Part of the suggestion.
+ */
+export interface AutocompleteSuggestionPart {
+    type: TokenType;
+    /**
+     * The type of the suggestion.
+     */
+    info?: string;
+    /**
+     * The synopsis of the suggestion.
+     */
+    synopsis?: string;
+    /**
+     * The suggested continuation of the query.
+     */
+    suggestion: string;
+}
+/** @ignore */
+export declare namespace _AutocompleteSuggestionPartTransformation {
+    interface AsJson {
+        type: _TokenTypeTransformation.AsJson;
+        info?: string;
+        synopsis?: string;
+        suggestion: string;
+    }
+    function fromJson(model: AsJson): AutocompleteSuggestionPart;
+    function toJson(model: AutocompleteSuggestionPart): AsJson;
+}

package/types/packages/client/query/src/lib/models/autocomplete-suggestion.d.ts

@@ -0,0 +1,28 @@
+import { AutocompleteSuggestionPart, _AutocompleteSuggestionPartTransformation } from './autocomplete-suggestion-part';
+/**
+ * Single suggestion for completion of the query.
+ */
+export interface AutocompleteSuggestion {
+    /**
+     * List of suggestion parts.
+     */
+    parts: AutocompleteSuggestionPart[];
+    /**
+     * Number of characters that the user user already typed for this suggestion.
+     */
+    alreadyTypedCharacters: number;
+    /**
+     * The suggested continuation of the query.
+     */
+    suggestion: string;
+}
+/** @ignore */
+export declare namespace _AutocompleteSuggestionTransformation {
+    interface AsJson {
+        parts: _AutocompleteSuggestionPartTransformation.AsJson[];
+        alreadyTypedCharacters: number;
+        suggestion: string;
+    }
+    function fromJson(model: AsJson): AutocompleteSuggestion;
+    function toJson(model: AutocompleteSuggestion): AsJson;
+}

package/types/packages/client/query/src/lib/models/dql-alternative-node.d.ts

@@ -0,0 +1,18 @@
+import { DQLNode, _DQLNodeTransformation } from './dql-node';
+/**
+ * The DQL node that has alternatives.
+ */
+export interface DQLAlternativeNode extends DQLNode {
+    /**
+     * The different alternatives.
+     */
+    alternatives?: object;
+}
+/** @ignore */
+export declare namespace _DQLAlternativeNodeTransformation {
+    interface AsJson extends _DQLNodeTransformation.AsJson {
+        alternatives?: object;
+    }
+    function fromJson(model: AsJson): DQLAlternativeNode;
+    function toJson(model: DQLAlternativeNode): AsJson;
+}

package/types/packages/client/query/src/lib/models/dql-container-node.d.ts

@@ -0,0 +1,23 @@
+import { DQLNode, _DQLNodeTransformation } from './dql-node';
+/**
+ * The DQL node that contains other nodes.
+ */
+export interface DQLContainerNode extends DQLNode {
+    /**
+     * The type of the node.
+     */
+    type?: string;
+    /**
+     * The list of children nodes.
+     */
+    children?: DQLNode[];
+}
+/** @ignore */
+export declare namespace _DQLContainerNodeTransformation {
+    interface AsJson extends _DQLNodeTransformation.AsJson {
+        type?: string;
+        children?: _DQLNodeTransformation.AsJson[];
+    }
+    function fromJson(model: AsJson): DQLContainerNode;
+    function toJson(model: DQLContainerNode): AsJson;
+}

package/types/packages/client/query/src/lib/models/dql-node-node-type.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The type of the node.
+ */
+export declare enum DQLNodeNodeType {
+    Terminal = "TERMINAL",
+    Container = "CONTAINER",
+    Alternative = "ALTERNATIVE"
+}
+/** @ignore */
+export declare namespace _DQLNodeNodeTypeTransformation {
+    type AsJson = DQLNodeNodeType;
+    const toJson: (value: DQLNodeNodeType) => AsJson;
+    const fromJson: (value: AsJson) => DQLNodeNodeType;
+}

package/types/packages/client/query/src/lib/models/dql-node.d.ts

@@ -0,0 +1,29 @@
+import { DQLAlternativeNode } from './dql-alternative-node';
+import { DQLContainerNode } from './dql-container-node';
+import { DQLNodeNodeType, _DQLNodeNodeTypeTransformation } from './dql-node-node-type';
+import { DQLTerminalNode } from './dql-terminal-node';
+import { TokenPosition, _TokenPositionTransformation } from './token-position';
+/**
+ * General Node in the DQL query.
+ */
+export interface DQLNode {
+    nodeType: DQLNodeNodeType;
+    tokenPosition?: TokenPosition;
+    /**
+     * True if the node is optional.
+     */
+    isOptional: boolean;
+}
+/** @ignore */
+export declare namespace _DQLNodeTransformation {
+    function isDqlTerminalNode(model: DQLNode): model is DQLTerminalNode;
+    function isDqlContainerNode(model: DQLNode): model is DQLContainerNode;
+    function isDqlAlternativeNode(model: DQLNode): model is DQLAlternativeNode;
+    interface AsJson {
+        nodeType: _DQLNodeNodeTypeTransformation.AsJson;
+        tokenPosition?: _TokenPositionTransformation.AsJson;
+        isOptional: boolean;
+    }
+    function fromJson(model: AsJson, includeChildProps?: boolean): DQLNode;
+    function toJson(model: DQLNode, includeChildProps?: boolean): AsJson;
+}

package/types/packages/client/query/src/lib/models/dql-terminal-node.d.ts

@@ -0,0 +1,26 @@
+import { DQLNode, _DQLNodeTransformation } from './dql-node';
+import { TokenType, _TokenTypeTransformation } from './token-type';
+/**
+ * Node that represents single token.
+ */
+export interface DQLTerminalNode extends DQLNode {
+    type?: TokenType;
+    /**
+     * For optional items only: whether this node becomes mandatory when user order is used. True only for some optional 'ghost braces'
+     */
+    isMandatoryOnUserOrder?: boolean;
+    /**
+     * Canonical form.
+     */
+    canonicalString?: string;
+}
+/** @ignore */
+export declare namespace _DQLTerminalNodeTransformation {
+    interface AsJson extends _DQLNodeTransformation.AsJson {
+        type?: _TokenTypeTransformation.AsJson;
+        isMandatoryOnUserOrder?: boolean;
+        canonicalString?: string;
+    }
+    function fromJson(model: AsJson): DQLTerminalNode;
+    function toJson(model: DQLTerminalNode): AsJson;
+}

package/types/packages/client/query/src/lib/models/error-envelope.d.ts

@@ -0,0 +1,18 @@
+import { FormDataRequestBody, FormDataResponseBody } from '@dynatrace-sdk/http-client';
+import { ErrorResponse, _ErrorResponseTransformation } from './error-response';
+/**
+ * An 'envelope' error object that has the mandatory error object.
+ */
+export interface ErrorEnvelope {
+    error: ErrorResponse;
+}
+/** @ignore */
+export declare namespace _ErrorEnvelopeTransformation {
+    interface AsJson {
+        error: _ErrorResponseTransformation.AsJson;
+    }
+    function fromJson(model: AsJson): ErrorEnvelope;
+    function toJson(model: ErrorEnvelope): AsJson;
+    function fromFormData(formData: FormDataResponseBody): ErrorEnvelope;
+    function toFormData(model: ErrorEnvelope): FormDataRequestBody;
+}

package/types/packages/client/query/src/lib/models/error-response-details.d.ts

@@ -0,0 +1,50 @@
+import { TokenPosition, _TokenPositionTransformation } from './token-position';
+/**
+ * Detailed information about the error.
+ */
+export interface ErrorResponseDetails {
+    /**
+     * The exception type.
+     */
+    exceptionType: string;
+    syntaxErrorPosition?: TokenPosition;
+    /**
+     * The error type, e.g. COMMAND_NAME_MISSING
+     */
+    errorType: string;
+    /**
+     * Complete error message.
+     */
+    errorMessage: string;
+    /**
+     * The arguments for the message format.
+     */
+    arguments: string[];
+    /**
+     * Submitted query string.
+     */
+    queryString: string;
+    /**
+     * The corresponding DQL format specifier types for each format specifier used in the error message format.
+     */
+    errorMessageFormatSpecifierTypes: string[];
+    /**
+     * The message format of the error message, string.format based.
+     */
+    errorMessageFormat: string;
+}
+/** @ignore */
+export declare namespace _ErrorResponseDetailsTransformation {
+    interface AsJson {
+        exceptionType: string;
+        syntaxErrorPosition?: _TokenPositionTransformation.AsJson;
+        errorType: string;
+        errorMessage: string;
+        arguments: string[];
+        queryString: string;
+        errorMessageFormatSpecifierTypes: string[];
+        errorMessageFormat: string;
+    }
+    function fromJson(model: AsJson): ErrorResponseDetails;
+    function toJson(model: ErrorResponseDetails): AsJson;
+}

package/types/packages/client/query/src/lib/models/error-response.d.ts

@@ -0,0 +1,25 @@
+import { ErrorResponseDetails, _ErrorResponseDetailsTransformation } from './error-response-details';
+/**
+ * The response for error state
+ */
+export interface ErrorResponse {
+    /**
+     * A short, clear error message without details
+     */
+    message: string;
+    details: ErrorResponseDetails;
+    /**
+     * Error code, which normally matches the HTTP error code.
+     */
+    code: number;
+}
+/** @ignore */
+export declare namespace _ErrorResponseTransformation {
+    interface AsJson {
+        message: string;
+        details: _ErrorResponseDetailsTransformation.AsJson;
+        code: number;
+    }
+    function fromJson(model: AsJson): ErrorResponse;
+    function toJson(model: ErrorResponse): AsJson;
+}

package/types/packages/client/query/src/lib/models/execute-request.d.ts

@@ -0,0 +1,64 @@
+export interface ExecuteRequest {
+    /**
+     * The full query string.
+     */
+    query: string;
+    /**
+     * The query timeframe 'start' timestamp in ISO-8601 or RFC399 format. If the timeframe 'end' parameter is missing, the whole timeframe is ignored. <em>Note that if a timeframe is specified within the query string (query) then it has precedence over this query request parameter.</em>
+     */
+    defaultTimeframeStart?: string;
+    /**
+     * The query timeframe 'end' timestamp in ISO-8601 or RFC399 format. If the timeframe 'start' parameter is missing, the whole timeframe is ignored. <em>Note that if a timeframe is specified within the query string (query) then it has precedence over this query request parameter.</em>
+     */
+    defaultTimeframeEnd?: string;
+    /**
+     * The query timezone. If none is specified, UTC is used as fallback. The list of valid input values matches that of the IANA Time Zone Database (TZDB). It accepts values in their canonical names like 'Europe/Paris', the abbreviated version like CET or the UTC offset format like '+01:00'
+     */
+    timezone?: string;
+    /**
+     * The query locale. If none specified, then a language/country neutral locale is chosen. The input values take the ISO-639 Language code with an optional ISO-3166 country code appended to it with an underscore. For instance, both values are valid 'en' or 'en_US'.
+     */
+    locale?: string;
+    /**
+     * The maximum number of result records that this query will return.
+     */
+    maxResultRecords?: number;
+    /**
+     * The query will stop after reaching the fetch-timeout.
+     */
+    fetchTimeoutSeconds?: number;
+    /**
+     * The time a client is willing to wait for the query result. In case the query finishes within the specified timeout, the query result is returned. Otherwise, the requestToken is returned, allowing polling for the result.
+     */
+    requestTimeoutMilliseconds?: number;
+    /**
+     * Request preview results. If a preview is available within the request-timeout-milliseconds, then it will be returned as part of the response.
+     */
+    enablePreview?: boolean;
+    /**
+     * In case not specified in the DQL string, the sampling ratio defined here is applied. Note that this is only applicable to log queries.
+     */
+    defaultSamplingRatio?: number;
+    /**
+     * Limit in gigabytes for the amount data that will be scanned during read.
+     */
+    defaultScanLimitGbytes?: number;
+}
+/** @ignore */
+export declare namespace _ExecuteRequestTransformation {
+    interface AsJson {
+        query: string;
+        defaultTimeframeStart?: string;
+        defaultTimeframeEnd?: string;
+        timezone?: string;
+        locale?: string;
+        maxResultRecords?: number;
+        fetchTimeoutSeconds?: number;
+        requestTimeoutMilliseconds?: number;
+        enablePreview?: boolean;
+        defaultSamplingRatio?: number;
+        defaultScanLimitGbytes?: number;
+    }
+    function fromJson(model: AsJson): ExecuteRequest;
+    function toJson(model: ExecuteRequest): AsJson;
+}

package/types/packages/client/query/src/lib/models/field-type-type.d.ts

@@ -0,0 +1,21 @@
+export declare enum FieldTypeType {
+    Boolean = "boolean",
+    String = "string",
+    Double = "double",
+    Long = "long",
+    Timestamp = "timestamp",
+    Timeframe = "timeframe",
+    Duration = "duration",
+    Binary = "binary",
+    IpAddress = "ip_address",
+    GeoPoint = "geo_point",
+    Array = "array",
+    Record = "record",
+    Undefined = "undefined"
+}
+/** @ignore */
+export declare namespace _FieldTypeTypeTransformation {
+    type AsJson = FieldTypeType;
+    const toJson: (value: FieldTypeType) => AsJson;
+    const fromJson: (value: AsJson) => FieldTypeType;
+}

package/types/packages/client/query/src/lib/models/field-type.d.ts

@@ -0,0 +1,18 @@
+import { FieldTypeType, _FieldTypeTypeTransformation } from './field-type-type';
+import { RangedFieldTypes, _RangedFieldTypesTransformation } from './ranged-field-types';
+/**
+ * The possible type of a field in DQL.
+ */
+export interface FieldType {
+    type: FieldTypeType;
+    types?: RangedFieldTypes[];
+}
+/** @ignore */
+export declare namespace _FieldTypeTransformation {
+    interface AsJson {
+        type: _FieldTypeTypeTransformation.AsJson;
+        types?: _RangedFieldTypesTransformation.AsJson[];
+    }
+    function fromJson(model: AsJson): FieldType;
+    function toJson(model: FieldType): AsJson;
+}

package/types/packages/client/query/src/lib/models/geo-point.d.ts

@@ -0,0 +1,22 @@
+/**
+ * DQL data type representing a geolocation point.
+ */
+export interface GeoPoint {
+    /**
+     * The coordinate that specifies the north–south position of a point on the surface of the earth.
+     */
+    latitude: number;
+    /**
+     * The coordinate that specifies the  east–west position of a point on the surface of the earth.
+     */
+    longitude: number;
+}
+/** @ignore */
+export declare namespace _GeoPointTransformation {
+    interface AsJson {
+        latitude: number;
+        longitude: number;
+    }
+    function fromJson(model: AsJson): GeoPoint;
+    function toJson(model: GeoPoint): AsJson;
+}

package/types/packages/client/query/src/lib/models/grail-metadata.d.ts

@@ -0,0 +1,66 @@
+import { MetadataNotification, _MetadataNotificationTransformation } from './metadata-notification';
+import { Timeframe, _TimeframeTransformation } from './timeframe';
+/**
+ * Collects various bits of metadata information.
+ */
+export interface GrailMetadata {
+    /**
+     * The canonical form of the query. It has normalized spaces and canonical constructs.
+     */
+    canonicalQuery?: string;
+    /**
+     * Effective timezone for the query.
+     */
+    timezone?: string;
+    /**
+     * The submitted query.
+     */
+    query?: string;
+    /**
+     * Number of scanned records during the query execution.
+     */
+    scannedRecords?: number;
+    /**
+     * The version of DQL that was used to process the query request.
+     */
+    dqlVersion?: string;
+    /**
+     * Number of scanned bytes during the query execution.
+     */
+    scannedBytes?: number;
+    analysisTimeframe?: Timeframe;
+    /**
+     * Effective locale for the query.
+     */
+    locale?: string;
+    /**
+     * The time it took to execute the query.
+     */
+    executionTimeMilliseconds?: number;
+    /**
+     * Collected messages during the execution of the query.
+     */
+    notifications?: MetadataNotification[];
+    /**
+     * The id of the query
+     */
+    queryId?: string;
+}
+/** @ignore */
+export declare namespace _GrailMetadataTransformation {
+    interface AsJson {
+        canonicalQuery?: string;
+        timezone?: string;
+        query?: string;
+        scannedRecords?: number;
+        dqlVersion?: string;
+        scannedBytes?: number;
+        analysisTimeframe?: _TimeframeTransformation.AsJson;
+        locale?: string;
+        executionTimeMilliseconds?: number;
+        notifications?: _MetadataNotificationTransformation.AsJson[];
+        queryId?: string;
+    }
+    function fromJson(model: AsJson): GrailMetadata;
+    function toJson(model: GrailMetadata): AsJson;
+}

package/types/packages/client/query/src/lib/models/index.d.ts

@@ -0,0 +1,35 @@
+export * from './autocomplete-request';
+export * from './autocomplete-response';
+export * from './autocomplete-suggestion';
+export * from './autocomplete-suggestion-part';
+export * from './dql-alternative-node';
+export * from './dql-container-node';
+export * from './dql-node';
+export * from './dql-node-node-type';
+export * from './dql-terminal-node';
+export * from './error-envelope';
+export * from './error-response';
+export * from './error-response-details';
+export * from './execute-request';
+export * from './field-type';
+export * from './field-type-type';
+export * from './geo-point';
+export * from './grail-metadata';
+export * from './metadata';
+export * from './metadata-notification';
+export * from './metric-metadata';
+export * from './parse-request';
+export * from './position-info';
+export * from './query-poll-response';
+export * from './query-result';
+export * from './query-start-response';
+export * from './query-state';
+export * from './ranged-field-types';
+export * from './ranged-field-types-mappings';
+export * from './result-record';
+export * from './result-record-value';
+export * from './timeframe';
+export * from './token-position';
+export * from './token-type';
+export * from './verify-request';
+export * from './verify-response';

package/types/packages/client/query/src/lib/models/metadata-notification.d.ts

@@ -0,0 +1,45 @@
+import { TokenPosition, _TokenPositionTransformation } from './token-position';
+/**
+ * The message that provides additional information about the execution of the query.
+ */
+export interface MetadataNotification {
+    /**
+     * The severity of the notification, currently: INFO, WARN, ERROR.
+     */
+    severity?: string;
+    /**
+     * The message format of the notification, string.format based
+     */
+    messageFormat?: string;
+    syntaxPosition?: TokenPosition;
+    /**
+     * The corresponding DQL format specifier types for each format specifier used in the error message format.
+     */
+    messageFormatSpecifierTypes?: string[];
+    /**
+     * The arguments for the message format.
+     */
+    arguments?: string[];
+    /**
+     * The notification type, e.g. LIMIT_ADDED.
+     */
+    notificationType?: string;
+    /**
+     * The complete message of the notification.
+     */
+    message?: string;
+}
+/** @ignore */
+export declare namespace _MetadataNotificationTransformation {
+    interface AsJson {
+        severity?: string;
+        messageFormat?: string;
+        syntaxPosition?: _TokenPositionTransformation.AsJson;
+        messageFormatSpecifierTypes?: string[];
+        arguments?: string[];
+        notificationType?: string;
+        message?: string;
+    }
+    function fromJson(model: AsJson): MetadataNotification;
+    function toJson(model: MetadataNotification): AsJson;
+}

package/types/packages/client/query/src/lib/models/metadata.d.ts

@@ -0,0 +1,18 @@
+import { GrailMetadata, _GrailMetadataTransformation } from './grail-metadata';
+import { MetricMetadata, _MetricMetadataTransformation } from './metric-metadata';
+/**
+ * Collects various bits of metadata information.
+ */
+export interface Metadata {
+    grail?: GrailMetadata;
+    metrics?: MetricMetadata[];
+}
+/** @ignore */
+export declare namespace _MetadataTransformation {
+    interface AsJson {
+        grail?: _GrailMetadataTransformation.AsJson;
+        metrics?: _MetricMetadataTransformation.AsJson[];
+    }
+    function fromJson(model: AsJson): Metadata;
+    function toJson(model: Metadata): AsJson;
+}

package/types/packages/client/query/src/lib/models/metric-metadata.d.ts

@@ -0,0 +1,32 @@
+/**
+ * An object that defines additional metric metadata.
+ */
+export interface MetricMetadata {
+    /**
+     * The metric key.
+     */
+    'metric.key'?: string;
+    /**
+     * The display name of the metadata.
+     */
+    displayName?: string;
+    /**
+     * The description of the metadata.
+     */
+    description?: string;
+    /**
+     * The unit used.
+     */
+    unit?: string;
+}
+/** @ignore */
+export declare namespace _MetricMetadataTransformation {
+    interface AsJson {
+        'metric.key'?: string;
+        displayName?: string;
+        description?: string;
+        unit?: string;
+    }
+    function fromJson(model: AsJson): MetricMetadata;
+    function toJson(model: MetricMetadata): AsJson;
+}