@dynatrace-sdk/client-query 1.0.0

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

@@ -0,0 +1,24 @@
+export interface ParseRequest {
+    /**
+     * The full query string.
+     */
+    query: 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;
+}
+/** @ignore */
+export declare namespace _ParseRequestTransformation {
+    interface AsJson {
+        query: string;
+        timezone?: string;
+        locale?: string;
+    }
+    function fromJson(model: AsJson): ParseRequest;
+    function toJson(model: ParseRequest): AsJson;
+}

package/types/packages/client/query/src/lib/models/position-info.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The exact position in the query string.
+ */
+export interface PositionInfo {
+    /**
+     * Query position column zero based index.
+     */
+    column: number;
+    /**
+     * Query position index.
+     */
+    index: number;
+    /**
+     * Query position line zero based index.
+     */
+    line: number;
+}
+/** @ignore */
+export declare namespace _PositionInfoTransformation {
+    interface AsJson {
+        column: number;
+        index: number;
+        line: number;
+    }
+    function fromJson(model: AsJson): PositionInfo;
+    function toJson(model: PositionInfo): AsJson;
+}

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

@@ -0,0 +1,28 @@
+import { QueryResult, _QueryResultTransformation } from './query-result';
+import { QueryState, _QueryStateTransformation } from './query-state';
+/**
+ * The response of GET query:execute call.
+ */
+export interface QueryPollResponse {
+    result?: QueryResult;
+    /**
+     * Time to live in seconds.
+     */
+    ttlSeconds?: number;
+    /**
+     * The progress of the query from 0 to 100.
+     */
+    progress?: number;
+    state: QueryState;
+}
+/** @ignore */
+export declare namespace _QueryPollResponseTransformation {
+    interface AsJson {
+        result?: _QueryResultTransformation.AsJson;
+        ttlSeconds?: number;
+        progress?: number;
+        state: _QueryStateTransformation.AsJson;
+    }
+    function fromJson(model: AsJson): QueryPollResponse;
+    function toJson(model: QueryPollResponse): AsJson;
+}

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

@@ -0,0 +1,27 @@
+import { Metadata, _MetadataTransformation } from './metadata';
+import { RangedFieldTypes, _RangedFieldTypesTransformation } from './ranged-field-types';
+import { ResultRecord, _ResultRecordTransformation } from './result-record';
+/**
+ * The result of the DQL query.
+ */
+export interface QueryResult {
+    /**
+     * List of records containing the result fields data.
+     */
+    records: (ResultRecord | null)[];
+    metadata: Metadata;
+    /**
+     * The data types for the result records.
+     */
+    types: RangedFieldTypes[];
+}
+/** @ignore */
+export declare namespace _QueryResultTransformation {
+    interface AsJson {
+        records: (_ResultRecordTransformation.AsJson | null)[];
+        metadata: _MetadataTransformation.AsJson;
+        types: _RangedFieldTypesTransformation.AsJson[];
+    }
+    function fromJson(model: AsJson): QueryResult;
+    function toJson(model: QueryResult): AsJson;
+}

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

@@ -0,0 +1,33 @@
+import { QueryResult, _QueryResultTransformation } from './query-result';
+import { QueryState, _QueryStateTransformation } from './query-state';
+/**
+ * The response when starting a query.
+ */
+export interface QueryStartResponse {
+    result?: QueryResult;
+    /**
+     * Time to live in seconds.
+     */
+    ttlSeconds?: number;
+    /**
+     * The progress of the query from 0 to 100.
+     */
+    progress?: number;
+    /**
+     * The token returned by the POST query:execute call.
+     */
+    requestToken?: string;
+    state: QueryState;
+}
+/** @ignore */
+export declare namespace _QueryStartResponseTransformation {
+    interface AsJson {
+        result?: _QueryResultTransformation.AsJson;
+        ttlSeconds?: number;
+        progress?: number;
+        requestToken?: string;
+        state: _QueryStateTransformation.AsJson;
+    }
+    function fromJson(model: AsJson): QueryStartResponse;
+    function toJson(model: QueryStartResponse): AsJson;
+}

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

@@ -0,0 +1,17 @@
+/**
+ * Possible state of the query.
+ */
+export declare enum QueryState {
+    NotStarted = "NOT_STARTED",
+    Running = "RUNNING",
+    Succeeded = "SUCCEEDED",
+    ResultGone = "RESULT_GONE",
+    Cancelled = "CANCELLED",
+    Failed = "FAILED"
+}
+/** @ignore */
+export declare namespace _QueryStateTransformation {
+    type AsJson = QueryState;
+    const toJson: (value: QueryState) => AsJson;
+    const fromJson: (value: AsJson) => QueryState;
+}

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

@@ -0,0 +1,15 @@
+import { FieldType, _FieldTypeTransformation } from './field-type';
+/**
+ * The mapping between the field name and data type.
+ */
+export interface RangedFieldTypesMappings {
+    [propName: string]: FieldType | undefined;
+}
+/** @ignore */
+export declare namespace _RangedFieldTypesMappingsTransformation {
+    interface AsJson {
+        [propName: string]: _FieldTypeTransformation.AsJson | undefined;
+    }
+    function fromJson(model: AsJson): RangedFieldTypesMappings;
+    function toJson(model: RangedFieldTypesMappings): AsJson;
+}

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

@@ -0,0 +1,20 @@
+import { RangedFieldTypesMappings, _RangedFieldTypesMappingsTransformation } from './ranged-field-types-mappings';
+/**
+ * The field type in range.
+ */
+export interface RangedFieldTypes {
+    mappings: RangedFieldTypesMappings;
+    /**
+     * The range of elements at use this type in arrays (null for records).
+     */
+    indexRange?: number[];
+}
+/** @ignore */
+export declare namespace _RangedFieldTypesTransformation {
+    interface AsJson {
+        mappings: _RangedFieldTypesMappingsTransformation.AsJson;
+        indexRange?: number[];
+    }
+    function fromJson(model: AsJson): RangedFieldTypes;
+    function toJson(model: RangedFieldTypes): AsJson;
+}

package/types/packages/client/query/src/lib/models/result-record-value.d.ts

@@ -0,0 +1,13 @@
+import { GeoPoint, _GeoPointTransformation } from '../models/geo-point';
+import { ResultRecord, _ResultRecordTransformation } from '../models/result-record';
+import { Timeframe, _TimeframeTransformation } from '../models/timeframe';
+/**
+ * Single result field of a record.
+ * @typedef {boolean | number | string | Timeframe | GeoPoint | ResultRecord | null | (ResultRecordValue | null)[] | null} ResultRecordValue
+ */
+export declare type ResultRecordValue = boolean | number | string | Timeframe | GeoPoint | ResultRecord | null | (ResultRecordValue | null)[] | null;
+export declare namespace _ResultRecordValueTransformation {
+    type AsJson = boolean | number | string | _TimeframeTransformation.AsJson | _GeoPointTransformation.AsJson | _ResultRecordTransformation.AsJson | null | (_ResultRecordValueTransformation.AsJson | null)[] | null;
+    function fromJson(model: AsJson): any;
+    function toJson(model: ResultRecordValue): any;
+}

package/types/packages/client/query/src/lib/models/result-record.d.ts

@@ -0,0 +1,15 @@
+import { ResultRecordValue, _ResultRecordValueTransformation } from './result-record-value';
+/**
+ * Single record that contains the result fields.
+ */
+export interface ResultRecord {
+    [propName: string]: ResultRecordValue | null | undefined;
+}
+/** @ignore */
+export declare namespace _ResultRecordTransformation {
+    interface AsJson {
+        [propName: string]: _ResultRecordValueTransformation.AsJson | null | undefined;
+    }
+    function fromJson(model: AsJson | null): ResultRecord | null;
+    function toJson(model: ResultRecord | null): AsJson | null;
+}

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

@@ -0,0 +1,22 @@
+/**
+ * DQL data type timeframe.
+ */
+export interface Timeframe {
+    /**
+     * The start time of the timeframe.
+     */
+    start?: Date;
+    /**
+     * The end time of the timeframe.
+     */
+    end?: Date;
+}
+/** @ignore */
+export declare namespace _TimeframeTransformation {
+    interface AsJson {
+        start?: string;
+        end?: string;
+    }
+    function fromJson(model: AsJson): Timeframe;
+    function toJson(model: Timeframe): AsJson;
+}

package/types/packages/client/query/src/lib/models/token-position.d.ts

@@ -0,0 +1,20 @@
+import { FormDataRequestBody, FormDataResponseBody } from '@dynatrace-sdk/http-client';
+import { PositionInfo, _PositionInfoTransformation } from './position-info';
+/**
+ * The position of a token in a query string used for errors and notification to map the message to a specific part of the query.
+ */
+export interface TokenPosition {
+    start: PositionInfo;
+    end: PositionInfo;
+}
+/** @ignore */
+export declare namespace _TokenPositionTransformation {
+    interface AsJson {
+        start: _PositionInfoTransformation.AsJson;
+        end: _PositionInfoTransformation.AsJson;
+    }
+    function fromJson(model: AsJson): TokenPosition;
+    function toJson(model: TokenPosition): AsJson;
+    function fromFormData(formData: FormDataResponseBody): TokenPosition;
+    function toFormData(model: TokenPosition): FormDataRequestBody;
+}

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

@@ -0,0 +1,48 @@
+/**
+ * The type of the autocomplete token.
+ */
+export declare enum TokenType {
+    Space = "SPACE",
+    Linebreak = "LINEBREAK",
+    Indent = "INDENT",
+    Pipe = "PIPE",
+    Dot = "DOT",
+    Colon = "COLON",
+    Comma = "COMMA",
+    Assignment = "ASSIGNMENT",
+    BraceOpen = "BRACE_OPEN",
+    BraceClose = "BRACE_CLOSE",
+    BracketOpen = "BRACKET_OPEN",
+    BracketClose = "BRACKET_CLOSE",
+    ParenthesisOpen = "PARENTHESIS_OPEN",
+    ParenthesisClose = "PARENTHESIS_CLOSE",
+    Quote = "QUOTE",
+    SingleQuote = "SINGLE_QUOTE",
+    Slash = "SLASH",
+    BooleanTrue = "BOOLEAN_TRUE",
+    BooleanFalse = "BOOLEAN_FALSE",
+    Null = "NULL",
+    CommandName = "COMMAND_NAME",
+    ParameterKey = "PARAMETER_KEY",
+    ParameterValueScope = "PARAMETER_VALUE_SCOPE",
+    FunctionName = "FUNCTION_NAME",
+    TimeseriesAggregation = "TIMESERIES_AGGREGATION",
+    Operator = "OPERATOR",
+    TraversalOperator = "TRAVERSAL_OPERATOR",
+    TraversalRelationName = "TRAVERSAL_RELATION_NAME",
+    TraversalHopCount = "TRAVERSAL_HOP_COUNT",
+    SimpleIdentifier = "SIMPLE_IDENTIFIER",
+    Number = "NUMBER",
+    String = "STRING",
+    TimeUnit = "TIME_UNIT",
+    TimestampValue = "TIMESTAMP_VALUE",
+    MetricKey = "METRIC_KEY",
+    Variable = "VARIABLE",
+    EndComment = "END_COMMENT"
+}
+/** @ignore */
+export declare namespace _TokenTypeTransformation {
+    type AsJson = TokenType;
+    const toJson: (value: TokenType) => AsJson;
+    const fromJson: (value: AsJson) => TokenType;
+}

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

@@ -0,0 +1,24 @@
+export interface VerifyRequest {
+    /**
+     * The full query string.
+     */
+    query: 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;
+}
+/** @ignore */
+export declare namespace _VerifyRequestTransformation {
+    interface AsJson {
+        query: string;
+        timezone?: string;
+        locale?: string;
+    }
+    function fromJson(model: AsJson): VerifyRequest;
+    function toJson(model: VerifyRequest): AsJson;
+}

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

@@ -0,0 +1,23 @@
+import { MetadataNotification, _MetadataNotificationTransformation } from './metadata-notification';
+/**
+ * Verify response.
+ */
+export interface VerifyResponse {
+    /**
+     * True if the supplied DQL query string is valid.
+     */
+    valid: boolean;
+    /**
+     * The notifications related to the supplied DQL query string.
+     */
+    notifications?: MetadataNotification[];
+}
+/** @ignore */
+export declare namespace _VerifyResponseTransformation {
+    interface AsJson {
+        valid: boolean;
+        notifications?: _MetadataNotificationTransformation.AsJson[];
+    }
+    function fromJson(model: AsJson): VerifyResponse;
+    function toJson(model: VerifyResponse): AsJson;
+}

package/types/packages/client/query/src/lib/utils/url-helpers.d.ts

@@ -0,0 +1,3 @@
+declare type QueryParamsType = Record<string | number, any>;
+export declare const toQueryString: (rawQuery?: QueryParamsType) => string;
+export {};

package/types/packages/http-client/src/index.d.ts

@@ -0,0 +1,2 @@
+export { AbortController, AbortSignal, BaseError, Binary, BinaryFormDataRequestField, BinaryFormDataResponseField, DataTypeError, DataTypes, FormDataRequestBody, FormDataRequestField, FormDataResponseBody, FormDataResponseField, Headers, HttpClient, HttpClientAbortError, HttpClientNetworkError, HttpClientRequestError, HttpClientRequestOptions, HttpClientResponse, HttpClientResponseError, JsonFormDataRequestField, RequestBodyTypes, ResponseBodyTypes, StatusValidator, TextFormDataRequestField, TextFormDataResponseField, UnsupportedOperationError, } from './lib/types';
+export { AbortController as PlatformAbortController, AbortSignal as PlatformAbortSignal, BaseError as PlatformBaseError, Binary as PlatformBinary, DataTypeError as PlatformDataTypeError, HttpClient as PlatformHttpClient, HttpClientAbortError as PlatformHttpClientAbortError, HttpClientRequestError as PlatformHttpClientRequestError, HttpClientResponse as PlatformHttpClientResponse, HttpClientResponseError as PlatformHttpClientResponseError, UnsupportedOperationError as PlatformUnsupportedOperationError, httpClient, } from './lib/platform';

package/types/packages/http-client/src/lib/platform/abort-controller.d.ts

@@ -0,0 +1,6 @@
+import * as types from '../types';
+declare const AbortController: {
+    new (): types.AbortController;
+};
+declare type AbortController = InstanceType<typeof AbortController>;
+export { AbortController };

package/types/packages/http-client/src/lib/platform/abort-signal.d.ts

@@ -0,0 +1,6 @@
+import * as types from '../types';
+declare const AbortSignal: {
+    new (): types.AbortSignal;
+};
+declare type AbortSignal = InstanceType<typeof AbortSignal>;
+export { AbortSignal };

package/types/packages/http-client/src/lib/platform/apply-content-type-header.d.ts

@@ -0,0 +1,2 @@
+import { Headers, RequestBodyTypes } from '../types';
+export declare function applyContentTypeHeader<T extends keyof RequestBodyTypes>(headers: Headers | undefined, requestBodyType: T): Headers | undefined;

package/types/packages/http-client/src/lib/platform/base-error.d.ts

@@ -0,0 +1,5 @@
+import * as types from '../types';
+export declare abstract class BaseError extends Error implements types.BaseError {
+    readonly cause?: any;
+    protected constructor(message: string, cause?: any);
+}

package/types/packages/http-client/src/lib/platform/binary.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type * as stream from 'stream';
+import * as types from '../types';
+export declare class Binary implements types.Binary {
+    readonly data: Blob | ArrayBuffer | ReadableStream<Uint8Array>;
+    static fromText(text: string): Binary;
+    static fromJson(json: any): Binary;
+    static from(data: Blob | ArrayBuffer | ReadableStream<Uint8Array> | Buffer | stream.Readable): Binary;
+    private constructor();
+    get<T extends keyof types.DataTypes>(type: T): types.DataTypes[T];
+}
+export declare function isBinary(body: any): body is Binary;

package/types/packages/http-client/src/lib/platform/data-type-error.d.ts

@@ -0,0 +1,6 @@
+import * as types from '../types';
+import { BaseError } from './base-error';
+export declare class DataTypeError extends BaseError implements types.DataTypeError {
+    readonly name = "DataTypeError";
+    constructor(message: string, cause?: any);
+}

package/types/packages/http-client/src/lib/platform/decode-response-body.d.ts

@@ -0,0 +1,3 @@
+import * as types from '../types';
+import { ResponseBodyTypes } from '../types';
+export declare function decodeResponseBody<T extends keyof types.ResponseBodyTypes>(response: Response, responseBodyType: T): ResponseBodyTypes[T];

package/types/packages/http-client/src/lib/platform/default-status-validator.d.ts

@@ -0,0 +1,2 @@
+import { StatusValidator } from '../types';
+export declare const defaultStatusValidator: StatusValidator;

package/types/packages/http-client/src/lib/platform/encode-request-body.d.ts

@@ -0,0 +1,2 @@
+import { RequestBodyTypes } from '../types';
+export declare function encodeRequestBody<T extends keyof RequestBodyTypes>(body: RequestBodyTypes[T], requestBodyType: T): Promise<string | ArrayBuffer | Blob | ReadableStream<any> | FormData>;

package/types/packages/http-client/src/lib/platform/http-client-abort-error.d.ts

@@ -0,0 +1,7 @@
+import * as types from '../types';
+export declare class HttpClientAbortError extends Error implements types.HttpClientAbortError {
+    readonly cause: any;
+    readonly name = "AbortError";
+    constructor(cause: any);
+}
+export declare const throwIfAbortError: (e: unknown) => void;

package/types/packages/http-client/src/lib/platform/http-client-request-error.d.ts

@@ -0,0 +1,7 @@
+import * as types from '../types';
+import { BaseError } from './base-error';
+export declare class HttpClientRequestError extends BaseError implements types.HttpClientRequestError {
+    readonly cause: any;
+    readonly name = "RequestError";
+    constructor(cause: any);
+}

package/types/packages/http-client/src/lib/platform/http-client-response-error-serializer.d.ts

@@ -0,0 +1 @@
+export declare function addHttpClientResponseErrorSerializer(): void;

package/types/packages/http-client/src/lib/platform/http-client-response-error.d.ts

@@ -0,0 +1,8 @@
+import * as types from '../types';
+import { HttpClientResponse } from './http-client-response';
+import { BaseError } from './base-error';
+export declare class HttpClientResponseError extends BaseError implements types.HttpClientResponseError {
+    readonly name = "ResponseError";
+    readonly response: HttpClientResponse;
+    constructor(response: Response);
+}

package/types/packages/http-client/src/lib/platform/http-client-response.d.ts

@@ -0,0 +1,10 @@
+import * as types from '../types';
+export declare class HttpClientResponse implements types.HttpClientResponse {
+    private response;
+    constructor(response: Response);
+    get url(): string;
+    get status(): number;
+    get statusText(): string;
+    get headers(): types.Headers;
+    body<T extends keyof types.ResponseBodyTypes = 'json'>(responseBodyType?: T): types.ResponseBodyTypes[T];
+}

package/types/packages/http-client/src/lib/platform/http-client.d.ts

@@ -0,0 +1,5 @@
+import * as types from '../types';
+export declare class HttpClient implements types.HttpClient {
+    send<T extends keyof types.RequestBodyTypes = 'json'>(options: types.HttpClientRequestOptions<T>): Promise<types.HttpClientResponse>;
+}
+export declare const httpClient: HttpClient;

package/types/packages/http-client/src/lib/platform/index.d.ts

@@ -0,0 +1,11 @@
+export * from './abort-controller';
+export * from './abort-signal';
+export * from './base-error';
+export * from './binary';
+export * from './data-type-error';
+export * from './http-client';
+export * from './http-client-abort-error';
+export * from './http-client-request-error';
+export * from './http-client-response';
+export * from './http-client-response-error';
+export * from './unsupported-operation-error';

package/types/packages/http-client/src/lib/platform/unsupported-operation-error.d.ts

@@ -0,0 +1,6 @@
+import * as types from '../types';
+import { BaseError } from './base-error';
+export declare class UnsupportedOperationError extends BaseError implements types.UnsupportedOperationError {
+    readonly name = "UnsupportedOperationError";
+    constructor(message: string, cause?: any);
+}

package/types/packages/http-client/src/lib/types/abort-controller.d.ts

@@ -0,0 +1,14 @@
+import { AbortSignal } from './abort-signal';
+/**
+ * Represents a controller object that allows to abort one or more requests as and when desired.
+ */
+export interface AbortController {
+    /**
+     * Aborts a request before it has completed.
+     */
+    abort(): void;
+    /**
+     * Returns an AbortSignal object instance, which can be used to communicate with a request.
+     */
+    signal: AbortSignal;
+}

package/types/packages/http-client/src/lib/types/abort-signal.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Represents a signal object that allows to communicate with the request and abort it using the `AbortController`.
+ */
+export interface AbortSignal extends EventTarget {
+    readonly reason: any;
+    throwIfAborted(): void;
+    /**
+     * A flag indicating whether the requests the signal is communicating with are aborted.
+     */
+    readonly aborted: boolean;
+    /**
+     * Invoked when the requests the signal is communicating with are aborted.
+     */
+    onabort: ((this: AbortSignal, event: Event) => void) | null;
+}

package/types/packages/http-client/src/lib/types/base-error.d.ts

@@ -0,0 +1,4 @@
+export interface BaseError extends Error {
+    readonly name: string;
+    readonly cause?: any;
+}

package/types/packages/http-client/src/lib/types/binary.d.ts

@@ -0,0 +1,15 @@
+import { DataTypes } from './data-types';
+/**
+ * Represents an environment agnostic (browser vs node) abstraction layer for binary data.
+ */
+export interface Binary {
+    /**
+     * Returns the binary data in a form that conforms to the specified type.
+     *
+     * @param type  The type of the data.
+     * Can be `text`, `json`, `array-buffer`, `blob`, `readable-stream`, `buffer` or `stream`.
+     * @throws DataTypeError when the data does not conform to the specified type.
+     * @throws UnsupportedOperationError when the type is not supported by the platform.
+     */
+    get<T extends keyof DataTypes>(type: T): DataTypes[T];
+}

package/types/packages/http-client/src/lib/types/data-type-error.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Represents a situation when the response body does not conform to the specified response body type.
+ */
+import { BaseError } from './base-error';
+export interface DataTypeError extends BaseError {
+    /**
+     * The error name.
+     */
+    readonly name: 'DataTypeError';
+    /**
+     * The error root cause.
+     */
+    readonly cause?: any;
+}

package/types/packages/http-client/src/lib/types/data-types.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type * as stream from 'stream';
+/**
+ * Mapping between the data type names and types.
+ */
+export declare type DataTypes = {
+    /**
+     * A text type.
+     */
+    text: Promise<string>;
+    /**
+     * A JSON type.
+     */
+    json: Promise<any>;
+    /**
+     * An ArrayBuffer type.
+     */
+    'array-buffer': Promise<ArrayBuffer>;
+    /**
+     * A Blob type. Browser only.
+     */
+    blob: Promise<Blob>;
+    /**
+     * A ReadableStream type. Browser only.
+     */
+    'readable-stream': ReadableStream<Uint8Array>;
+    /**
+     * A Buffer type. Node only.
+     */
+    buffer: Promise<Buffer>;
+    /**
+     * A Stream type. Node only.
+     */
+    stream: stream.Readable;
+};