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

package/types/packages/client/classic-environment-v2/src/lib/models/update-job-job-state.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The status of the update job.
+ */
+export declare enum UpdateJobJobState {
+    Failed = "FAILED",
+    InProgress = "IN_PROGRESS",
+    Pending = "PENDING",
+    Rollback = "ROLLBACK",
+    Scheduled = "SCHEDULED",
+    Skipped = "SKIPPED",
+    Succeed = "SUCCEED"
+}
+/** @ignore */
+export declare namespace _UpdateJobJobStateTransformation {
+    type AsJson = UpdateJobJobState;
+    const toJson: (value: UpdateJobJobState) => AsJson;
+    const fromJson: (value: AsJson) => UpdateJobJobState;
+}

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

@@ -0,0 +1,23 @@
+import { UpdateJob, _UpdateJobTransformation } from './update-job';
+/**
+ * A list of update jobs of the ActiveGate.
+ */
+export interface UpdateJobList {
+    /**
+     * A list of update jobs of the ActiveGate.
+     */
+    updateJobs?: UpdateJob[];
+    /**
+     * The ID of the ActiveGate.
+     */
+    agId?: string;
+}
+/** @ignore */
+export declare namespace _UpdateJobListTransformation {
+    interface AsJson {
+        updateJobs?: _UpdateJobTransformation.AsJson[];
+        agId?: string;
+    }
+    function fromJson(model: AsJson): UpdateJobList;
+    function toJson(model: UpdateJobList): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/update-job-update-method.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The method of updating the ActiveGate or its component.
+ */
+export declare enum UpdateJobUpdateMethod {
+    Automatic = "AUTOMATIC",
+    ManualInstallation = "MANUAL_INSTALLATION",
+    OnDemand = "ON_DEMAND"
+}
+/** @ignore */
+export declare namespace _UpdateJobUpdateMethodTransformation {
+    type AsJson = UpdateJobUpdateMethod;
+    const toJson: (value: UpdateJobUpdateMethod) => AsJson;
+    const fromJson: (value: AsJson) => UpdateJobUpdateMethod;
+}

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

@@ -0,0 +1,15 @@
+/**
+ * The component to be updated.
+ */
+export declare enum UpdateJobUpdateType {
+    ActiveGate = "ACTIVE_GATE",
+    RemotePluginAgent = "REMOTE_PLUGIN_AGENT",
+    Synthetic = "SYNTHETIC",
+    ZRemote = "Z_REMOTE"
+}
+/** @ignore */
+export declare namespace _UpdateJobUpdateTypeTransformation {
+    type AsJson = UpdateJobUpdateType;
+    const toJson: (value: UpdateJobUpdateType) => AsJson;
+    const fromJson: (value: AsJson) => UpdateJobUpdateType;
+}

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

@@ -0,0 +1,70 @@
+import { UpdateJobAgType, _UpdateJobAgTypeTransformation } from './update-job-ag-type';
+import { UpdateJobJobState, _UpdateJobJobStateTransformation } from './update-job-job-state';
+import { UpdateJobUpdateMethod, _UpdateJobUpdateMethodTransformation } from './update-job-update-method';
+import { UpdateJobUpdateType, _UpdateJobUpdateTypeTransformation } from './update-job-update-type';
+/**
+ * Configuration of the ActiveGate update job.
+ */
+export interface UpdateJob {
+    /**
+     * A list of environments (specified by IDs) the ActiveGate can connect to.
+     */
+    environments?: string[];
+    /**
+     * The ID of the update job.
+     */
+    jobId?: string;
+    jobState?: UpdateJobJobState;
+    updateMethod?: UpdateJobUpdateMethod;
+    updateType?: UpdateJobUpdateType;
+    agType?: UpdateJobAgType;
+    /**
+     * The initial version of the ActiveGate.
+     */
+    startVersion?: string;
+    /**
+     * The duration of the update, in milliseconds.
+     */
+    duration?: number;
+    /**
+     * The timestamp of the update job completion.
+     *
+     *  The `null` value means the job is still running.
+     */
+    timestamp?: number;
+    /**
+     * The target version of the update.
+     *
+     * Specify the version in the `<major>.<minor>.<revision>.<timestamp>` format.
+     *
+     * To update to the latest available version, use the `latest` value.
+     */
+    targetVersion: string;
+    /**
+     * The information about update error.
+     */
+    error?: string;
+    /**
+     * The job can (`true`) or can't (`false`) be cancelled at the moment.
+     */
+    cancelable?: boolean;
+}
+/** @ignore */
+export declare namespace _UpdateJobTransformation {
+    interface AsJson {
+        environments?: string[];
+        jobId?: string;
+        jobState?: _UpdateJobJobStateTransformation.AsJson;
+        updateMethod?: _UpdateJobUpdateMethodTransformation.AsJson;
+        updateType?: _UpdateJobUpdateTypeTransformation.AsJson;
+        agType?: _UpdateJobAgTypeTransformation.AsJson;
+        startVersion?: string;
+        duration?: number;
+        timestamp?: number;
+        targetVersion: string;
+        error?: string;
+        cancelable?: boolean;
+    }
+    function fromJson(model: AsJson): UpdateJob;
+    function toJson(model: UpdateJob): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/update-jobs-all.d.ts

@@ -0,0 +1,18 @@
+import { UpdateJobList, _UpdateJobListTransformation } from './update-job-list';
+/**
+ * A list of ActiveGates with update jobs.
+ */
+export interface UpdateJobsAll {
+    /**
+     * A list of ActiveGates with update jobs.
+     */
+    allUpdateJobs?: UpdateJobList[];
+}
+/** @ignore */
+export declare namespace _UpdateJobsAllTransformation {
+    interface AsJson {
+        allUpdateJobs?: _UpdateJobListTransformation.AsJson[];
+    }
+    function fromJson(model: AsJson): UpdateJobsAll;
+    function toJson(model: UpdateJobsAll): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/upload-extension-body.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+import { Binary, FormDataRequestBody, FormDataResponseBody } from '@dynatrace-sdk/http-client';
+export interface UploadExtensionBody {
+    /**
+     * Extension 2.0 zip file to upload.
+     */
+    file: Binary | Buffer | Blob | File;
+}
+/** @ignore */
+export declare namespace _UploadExtensionBodyTransformation {
+    interface AsJson {
+        file: Binary | Buffer | Blob | File;
+    }
+    function fromJson(model: AsJson): UploadExtensionBody;
+    function toJson(model: UploadExtensionBody): AsJson;
+    function fromFormData(formData: FormDataResponseBody): UploadExtensionBody;
+    function toFormData(model: UploadExtensionBody): FormDataRequestBody;
+}

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

@@ -0,0 +1,26 @@
+import { Credentials, _CredentialsTransformation } from './credentials';
+import { ExternalVault, _ExternalVaultTransformation } from './external-vault';
+/**
+ * A credentials set of the `USERNAME_PASSWORD` type.
+ */
+export interface UserPasswordCredentials extends Credentials {
+    /**
+     * The username of the credentials set.
+     */
+    user?: string;
+    /**
+     * The password of the credential.
+     */
+    password?: string;
+    externalVault?: ExternalVault;
+}
+/** @ignore */
+export declare namespace _UserPasswordCredentialsTransformation {
+    interface AsJson extends _CredentialsTransformation.AsJson {
+        user?: string;
+        password?: string;
+        externalVault?: _ExternalVaultTransformation.AsJson;
+    }
+    function fromJson(model: AsJson): UserPasswordCredentials;
+    function toJson(model: UserPasswordCredentials): AsJson;
+}

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

@@ -0,0 +1,19 @@
+import { MetricIngestError, _MetricIngestErrorTransformation } from './metric-ingest-error';
+import { Warnings, _WarningsTransformation } from './warnings';
+export interface ValidationResponse {
+    linesOk?: number;
+    linesInvalid?: number;
+    warnings?: Warnings;
+    error?: MetricIngestError;
+}
+/** @ignore */
+export declare namespace _ValidationResponseTransformation {
+    interface AsJson {
+        linesOk?: number;
+        linesInvalid?: number;
+        warnings?: _WarningsTransformation.AsJson;
+        error?: _MetricIngestErrorTransformation.AsJson;
+    }
+    function fromJson(model: AsJson): ValidationResponse;
+    function toJson(model: ValidationResponse): AsJson;
+}

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

@@ -0,0 +1,37 @@
+/**
+ * Vulnerable component of a security problem.
+ */
+export interface VulnerableComponent {
+    /**
+     * The Dynatrace entity ID of the vulnerable component.
+     */
+    id?: string;
+    /**
+     * The display name of the vulnerable component.
+     */
+    displayName?: string;
+    /**
+     * The file name of the vulnerable component.
+     */
+    fileName?: string;
+    /**
+     * The number of affected entities.
+     */
+    numberOfAffectedEntities?: number;
+    /**
+     * A list of affected entities.
+     */
+    affectedEntities?: string[];
+}
+/** @ignore */
+export declare namespace _VulnerableComponentTransformation {
+    interface AsJson {
+        id?: string;
+        displayName?: string;
+        fileName?: string;
+        numberOfAffectedEntities?: number;
+        affectedEntities?: string[];
+    }
+    function fromJson(model: AsJson): VulnerableComponent;
+    function toJson(model: VulnerableComponent): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/models/vulnerable-function-process-groups-usage.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The vulnerable function usage based on the given process groups:
+ * * IN_USE if at least one process group calls this vulnerable function.
+ * * NOT_IN_USE if all process groups do not call this vulnerable function.
+ * * NOT_AVAILABLE if vulnerable function usage could not be calculated for at least one process group and no process group calls this vulnerable function.
+ */
+export declare enum VulnerableFunctionProcessGroupsUsage {
+    InUse = "IN_USE",
+    NotAvailable = "NOT_AVAILABLE",
+    NotInUse = "NOT_IN_USE"
+}
+/** @ignore */
+export declare namespace _VulnerableFunctionProcessGroupsUsageTransformation {
+    type AsJson = VulnerableFunctionProcessGroupsUsage;
+    const toJson: (value: VulnerableFunctionProcessGroupsUsage) => AsJson;
+    const fromJson: (value: AsJson) => VulnerableFunctionProcessGroupsUsage;
+}

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

@@ -0,0 +1,33 @@
+import { VulnerableFunction, _VulnerableFunctionTransformation } from './vulnerable-function';
+import { VulnerableFunctionProcessGroupsUsage, _VulnerableFunctionProcessGroupsUsageTransformation } from './vulnerable-function-process-groups-usage';
+/**
+ * A vulnerable function including its usage by specific process groups in context of the security problem.
+ */
+export interface VulnerableFunctionProcessGroups {
+    function?: VulnerableFunction;
+    usage?: VulnerableFunctionProcessGroupsUsage;
+    /**
+     * The process group identifiers, where this vulnerable function is in use.
+     */
+    processGroupsInUse?: string[];
+    /**
+     * The process group identifiers, where this vulnerable function is not in use.
+     */
+    processGroupsNotInUse?: string[];
+    /**
+     * The process group identifiers, where information about the usage of this function not available.
+     */
+    processGroupsNotAvailable?: string[];
+}
+/** @ignore */
+export declare namespace _VulnerableFunctionProcessGroupsTransformation {
+    interface AsJson {
+        function?: _VulnerableFunctionTransformation.AsJson;
+        usage?: _VulnerableFunctionProcessGroupsUsageTransformation.AsJson;
+        processGroupsInUse?: string[];
+        processGroupsNotInUse?: string[];
+        processGroupsNotAvailable?: string[];
+    }
+    function fromJson(model: AsJson): VulnerableFunctionProcessGroups;
+    function toJson(model: VulnerableFunctionProcessGroups): AsJson;
+}

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

@@ -0,0 +1,27 @@
+/**
+ * Defines an vulnerable function.
+ */
+export interface VulnerableFunction {
+    /**
+     * The class name of the vulnerable function.
+     */
+    className?: string;
+    /**
+     * The file path of the vulnerable function.
+     */
+    filePath?: string;
+    /**
+     * The function name of the vulnerable function.
+     */
+    functionName?: string;
+}
+/** @ignore */
+export declare namespace _VulnerableFunctionTransformation {
+    interface AsJson {
+        className?: string;
+        filePath?: string;
+        functionName?: string;
+    }
+    function fromJson(model: AsJson): VulnerableFunction;
+    function toJson(model: VulnerableFunction): AsJson;
+}

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

@@ -0,0 +1,30 @@
+import { ProcessGroupVulnerableFunctions, _ProcessGroupVulnerableFunctionsTransformation } from './process-group-vulnerable-functions';
+import { VulnerableFunctionProcessGroups, _VulnerableFunctionProcessGroupsTransformation } from './vulnerable-function-process-groups';
+/**
+ * A list of vulnerable functions, their security problem wide usages and their usages per process group.
+ * Optional: A list of vulnerable function usages per process group for a security problem.
+ */
+export interface VulnerableFunctionsContainer {
+    /**
+     * A list of vulnerable functions, their security problem wide usages and their usages per process group.
+     */
+    vulnerableFunctions?: VulnerableFunctionProcessGroups[];
+    /**
+     * A list of vulnerable function usages per process group for a security problem.
+     * The result is sorted based on the following criteria:
+     * * the number of vulnerable functions in use (descending).
+     * * the number of vulnerable functions not in use (descending).
+     * * the number of vulnerable functions not available (descending).
+     * * the process group identifier (ascending)
+     */
+    vulnerableFunctionsByProcessGroup?: ProcessGroupVulnerableFunctions[];
+}
+/** @ignore */
+export declare namespace _VulnerableFunctionsContainerTransformation {
+    interface AsJson {
+        vulnerableFunctions?: _VulnerableFunctionProcessGroupsTransformation.AsJson[];
+        vulnerableFunctionsByProcessGroup?: _ProcessGroupVulnerableFunctionsTransformation.AsJson[];
+    }
+    function fromJson(model: AsJson): VulnerableFunctionsContainer;
+    function toJson(model: VulnerableFunctionsContainer): AsJson;
+}

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

@@ -0,0 +1,13 @@
+export interface WarningLine {
+    line?: number;
+    warning?: string;
+}
+/** @ignore */
+export declare namespace _WarningLineTransformation {
+    interface AsJson {
+        line?: number;
+        warning?: string;
+    }
+    function fromJson(model: AsJson): WarningLine;
+    function toJson(model: WarningLine): AsJson;
+}

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

@@ -0,0 +1,14 @@
+import { WarningLine, _WarningLineTransformation } from './warning-line';
+export interface Warnings {
+    changedMetricKeys?: WarningLine[];
+    message?: string;
+}
+/** @ignore */
+export declare namespace _WarningsTransformation {
+    interface AsJson {
+        changedMetricKeys?: _WarningLineTransformation.AsJson[];
+        message?: string;
+    }
+    function fromJson(model: AsJson): Warnings;
+    function toJson(model: Warnings): AsJson;
+}

package/types/packages/client/classic-environment-v2/src/lib/utils/encoding.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Available formats to transform models to and from
+ */
+export declare enum Encoding {
+    Json = "json",
+    Text = "text",
+    Binary = "binary",
+    FormData = "form-data"
+}
+export declare function mimeTypeToEncoding(mimeType: string): Encoding;

package/types/packages/client/classic-environment-v2/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;
+}