doover-js 0.1.0

package/dist/apis/processors-api.d.ts

@@ -0,0 +1,21 @@
+import type { RestClient } from "../http/rest-client";
+import type { CreateIngestionRequest, PutScheduleRequest, PutSubscriptionRequest, ScheduleInfo, SubscriptionInfo } from "../types/openapi";
+export declare class ProcessorsApi {
+    private readonly rest;
+    constructor(rest: RestClient);
+    createProcessorSchedule(agentId: string, scheduleId: string, body: PutScheduleRequest): Promise<unknown>;
+    deleteProcessorSchedule(agentId: string, scheduleId: string): Promise<unknown>;
+    regenerateScheduleToken(agentId: string, scheduleId: string): Promise<unknown>;
+    getScheduleInfo(scheduleId: string): Promise<ScheduleInfo>;
+    getScheduleInfoAlias(scheduleId: string): Promise<ScheduleInfo>;
+    createProcessorSubscription(agentId: string, subscriptionId: string, body: PutSubscriptionRequest): Promise<unknown>;
+    deleteProcessorSubscription(agentId: string, subscriptionId: string): Promise<unknown>;
+    getProcessorSubscriptionInfo(subscriptionName: string): Promise<SubscriptionInfo>;
+    getProcessorSubscriptionInfoAlias(subscriptionArn: string): Promise<SubscriptionInfo>;
+    createIngestionEndpoint(agentId: string, ingestionId: string, body: CreateIngestionRequest): Promise<unknown>;
+    deleteIngestionEndpoint(agentId: string, ingestionId: string): Promise<unknown>;
+    invokeIngestionEndpoint(agentId: string, ingestionId: string, body: unknown, params?: {
+        wait?: boolean;
+        json_response?: boolean;
+    }): Promise<unknown>;
+}

package/dist/apis/processors-api.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessorsApi = void 0;
+class ProcessorsApi {
+    constructor(rest) {
+        this.rest = rest;
+    }
+    createProcessorSchedule(agentId, scheduleId, body) {
+        return this.rest.put(`/agents/${agentId}/processors/schedules/${scheduleId}`, body);
+    }
+    deleteProcessorSchedule(agentId, scheduleId) {
+        return this.rest.delete(`/agents/${agentId}/processors/schedules/${scheduleId}`);
+    }
+    regenerateScheduleToken(agentId, scheduleId) {
+        return this.rest.post(`/agents/${agentId}/processors/schedules/${scheduleId}/token`, {});
+    }
+    getScheduleInfo(scheduleId) {
+        return this.rest.get(`/processors/schedules/${scheduleId}`);
+    }
+    getScheduleInfoAlias(scheduleId) {
+        return this.rest.get(`/processors/schedules/${scheduleId}/info`);
+    }
+    createProcessorSubscription(agentId, subscriptionId, body) {
+        return this.rest.put(`/agents/${agentId}/processors/subscriptions/${subscriptionId}`, body);
+    }
+    deleteProcessorSubscription(agentId, subscriptionId) {
+        return this.rest.delete(`/agents/${agentId}/processors/subscriptions/${subscriptionId}`);
+    }
+    getProcessorSubscriptionInfo(subscriptionName) {
+        return this.rest.get(`/processors/subscriptions/${subscriptionName}`);
+    }
+    getProcessorSubscriptionInfoAlias(subscriptionArn) {
+        return this.rest.get(`/processors/subscriptions/${subscriptionArn}/info`);
+    }
+    createIngestionEndpoint(agentId, ingestionId, body) {
+        return this.rest.put(`/agents/${agentId}/processors/ingestions/${ingestionId}`, body);
+    }
+    deleteIngestionEndpoint(agentId, ingestionId) {
+        return this.rest.delete(`/agents/${agentId}/processors/ingestions/${ingestionId}`);
+    }
+    invokeIngestionEndpoint(agentId, ingestionId, body, params) {
+        return this.rest.post(`/agents/${agentId}/processors/ingestions/${ingestionId}/invoke`, body, params);
+    }
+}
+exports.ProcessorsApi = ProcessorsApi;

package/dist/apis/turn-api.d.ts

@@ -0,0 +1,7 @@
+import type { RestClient } from "../http/rest-client";
+import type { TurnCredential, TurnTokenRequest } from "../types/openapi";
+export declare class TurnApi {
+    private readonly rest;
+    constructor(rest: RestClient);
+    createTurnToken(body: TurnTokenRequest): Promise<TurnCredential>;
+}

package/dist/apis/turn-api.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TurnApi = void 0;
+class TurnApi {
+    constructor(rest) {
+        this.rest = rest;
+    }
+    createTurnToken(body) {
+        return this.rest.post("/turn/token", body);
+    }
+}
+exports.TurnApi = TurnApi;

package/dist/client/doover-client.d.ts

@@ -0,0 +1,29 @@
+import { AgentsApi } from "../apis/agents-api";
+import { AggregatesApi } from "../apis/aggregates-api";
+import { AlarmsApi } from "../apis/alarms-api";
+import { ChannelsApi } from "../apis/channels-api";
+import { ConnectionsApi } from "../apis/connections-api";
+import { MessagesApi } from "../apis/messages-api";
+import { NotificationsApi } from "../apis/notifications-api";
+import { PermissionsApi } from "../apis/permissions-api";
+import { ProcessorsApi } from "../apis/processors-api";
+import { TurnApi } from "../apis/turn-api";
+import { GatewayClient } from "../gateway/gateway-client";
+import { RestClient, type DooverClientConfig } from "../http/rest-client";
+import { DooverDataProvider } from "../viewer/doover-data-provider";
+export declare class DooverClient {
+    readonly rest: RestClient;
+    readonly viewer: DooverDataProvider;
+    readonly channels: ChannelsApi;
+    readonly messages: MessagesApi;
+    readonly aggregates: AggregatesApi;
+    readonly alarms: AlarmsApi;
+    readonly connections: ConnectionsApi;
+    readonly notifications: NotificationsApi;
+    readonly permissions: PermissionsApi;
+    readonly processors: ProcessorsApi;
+    readonly turn: TurnApi;
+    readonly agents: AgentsApi;
+    readonly gateway: GatewayClient;
+    constructor(config: DooverClientConfig);
+}

package/dist/client/doover-client.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DooverClient = void 0;
+const agents_api_1 = require("../apis/agents-api");
+const aggregates_api_1 = require("../apis/aggregates-api");
+const alarms_api_1 = require("../apis/alarms-api");
+const channels_api_1 = require("../apis/channels-api");
+const connections_api_1 = require("../apis/connections-api");
+const messages_api_1 = require("../apis/messages-api");
+const notifications_api_1 = require("../apis/notifications-api");
+const permissions_api_1 = require("../apis/permissions-api");
+const processors_api_1 = require("../apis/processors-api");
+const turn_api_1 = require("../apis/turn-api");
+const gateway_client_1 = require("../gateway/gateway-client");
+const rest_client_1 = require("../http/rest-client");
+const doover_data_provider_1 = require("../viewer/doover-data-provider");
+class DooverClient {
+    constructor(config) {
+        this.rest = new rest_client_1.RestClient(config);
+        this.viewer = new doover_data_provider_1.DooverDataProvider(config);
+        this.channels = new channels_api_1.ChannelsApi(this.rest);
+        this.messages = new messages_api_1.MessagesApi(this.rest);
+        this.aggregates = new aggregates_api_1.AggregatesApi(this.rest);
+        this.alarms = new alarms_api_1.AlarmsApi(this.rest);
+        this.connections = new connections_api_1.ConnectionsApi(this.rest);
+        this.notifications = new notifications_api_1.NotificationsApi(this.rest);
+        this.permissions = new permissions_api_1.PermissionsApi(this.rest);
+        this.processors = new processors_api_1.ProcessorsApi(this.rest);
+        this.turn = new turn_api_1.TurnApi(this.rest);
+        this.agents = new agents_api_1.AgentsApi(this.rest);
+        this.gateway = new gateway_client_1.GatewayClient(config);
+    }
+}
+exports.DooverClient = DooverClient;

package/dist/gateway/gateway-client.d.ts

@@ -0,0 +1,37 @@
+import type { DooverClientConfig } from "../http/rest-client";
+import type { GatewayListenerMap, WebSocketSession } from "./types";
+import type { ChannelRef, JSONValue } from "../types/common";
+export declare class GatewayClient {
+    private readonly config;
+    private socket;
+    private session;
+    private heartbeatTimer;
+    private lastHeartbeatAt;
+    private missedHeartbeats;
+    private reconnectTimer;
+    private listeners;
+    private subscriptions;
+    constructor(config: DooverClientConfig);
+    connect(): void;
+    disconnect(code?: number, reason?: string): void;
+    on<K extends keyof GatewayListenerMap>(eventName: K, listener: GatewayListenerMap[K]): void;
+    off<K extends keyof GatewayListenerMap>(eventName: K, listener: GatewayListenerMap[K]): void;
+    subscribe(channel: ChannelRef, options?: {
+        diff_only?: boolean;
+    }): void;
+    unsubscribe(channel: ChannelRef): void;
+    syncChannel(channel: ChannelRef): void;
+    sendOneShotMessage(channel: ChannelRef, data: JSONValue): void;
+    getSession(): WebSocketSession | null;
+    getLatency(): number | null;
+    isConnected(): boolean;
+    private handleMessage;
+    private identifyOrResume;
+    private resubscribeAll;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private send;
+    private emit;
+    private scheduleReconnect;
+    private channelKey;
+}

package/dist/gateway/gateway-client.js

@@ -0,0 +1,258 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GatewayClient = void 0;
+const errors_1 = require("../http/errors");
+const snowflake_1 = require("../utils/snowflake");
+class GatewayClient {
+    constructor(config) {
+        this.config = config;
+        this.socket = null;
+        this.session = null;
+        this.heartbeatTimer = null;
+        this.lastHeartbeatAt = null;
+        this.missedHeartbeats = 0;
+        this.reconnectTimer = null;
+        this.listeners = {
+            ready: new Set(),
+            channelSync: new Set(),
+            messageCreate: new Set(),
+            messageUpdate: new Set(),
+            aggregateUpdate: new Set(),
+            alarmTrigger: new Set(),
+            oneShotMessage: new Set(),
+            channelSubscription: new Set(),
+            channelUnsubscription: new Set(),
+            wssError: new Set(),
+            sessionCancelled: new Set(),
+            open: new Set(),
+            close: new Set(),
+            heartbeatAck: new Set(),
+        };
+        this.subscriptions = new Map();
+    }
+    connect() {
+        if (this.socket && this.socket.readyState <= WebSocket.OPEN) {
+            return;
+        }
+        const WebSocketImpl = this.config.webSocketImpl ?? WebSocket;
+        this.socket = new WebSocketImpl(this.config.dataWssUrl);
+        this.socket.onopen = () => this.emit("open");
+        this.socket.onclose = (event) => {
+            this.stopHeartbeat();
+            this.emit("close", event);
+            this.scheduleReconnect();
+        };
+        this.socket.onerror = () => undefined;
+        this.socket.onmessage = (event) => this.handleMessage(event.data);
+    }
+    disconnect(code, reason) {
+        this.stopHeartbeat();
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        this.socket?.close(code, reason);
+        this.socket = null;
+    }
+    on(eventName, listener) {
+        this.listeners[eventName].add(listener);
+    }
+    off(eventName, listener) {
+        this.listeners[eventName].delete(listener);
+    }
+    subscribe(channel, options) {
+        this.subscriptions.set(this.channelKey(channel), {
+            channel,
+            diff_only: options?.diff_only ?? false,
+        });
+        if (!this.isConnected()) {
+            this.connect();
+            return;
+        }
+        this.send({
+            op: 12,
+            d: {
+                channel,
+                organisation_id: this.config.organisationId ?? null,
+                diff_only: options?.diff_only ?? false,
+            },
+        });
+    }
+    unsubscribe(channel) {
+        this.subscriptions.delete(this.channelKey(channel));
+        if (!this.isConnected()) {
+            return;
+        }
+        this.send({
+            op: 13,
+            d: {
+                channel,
+                organisation_id: this.config.organisationId ?? null,
+            },
+        });
+    }
+    syncChannel(channel) {
+        if (!this.isConnected()) {
+            this.connect();
+            return;
+        }
+        this.send({
+            op: 14,
+            d: {
+                channel,
+                organisation_id: this.config.organisationId ?? null,
+            },
+        });
+    }
+    sendOneShotMessage(channel, data) {
+        if (!this.isConnected()) {
+            this.connect();
+            return;
+        }
+        this.send({
+            op: 15,
+            d: {
+                channel,
+                data,
+            },
+        });
+    }
+    getSession() {
+        return this.session;
+    }
+    getLatency() {
+        return this.lastHeartbeatAt === null ? null : Date.now() - this.lastHeartbeatAt;
+    }
+    isConnected() {
+        return this.socket?.readyState === WebSocket.OPEN;
+    }
+    handleMessage(raw) {
+        const message = JSON.parse(raw);
+        if (message.op === 2) {
+            this.missedHeartbeats = 0;
+            const latency = this.lastHeartbeatAt === null ? null : Date.now() - this.lastHeartbeatAt;
+            this.emit("heartbeatAck", latency);
+            return;
+        }
+        if (message.op === 3) {
+            this.session = null;
+            this.emit("sessionCancelled");
+            return;
+        }
+        if (message.op !== 0 || !message.t) {
+            return;
+        }
+        switch (message.t) {
+            case "Hello":
+                this.identifyOrResume();
+                this.startHeartbeat();
+                break;
+            case "Ready":
+                this.session = message.d;
+                this.emit("ready", message.d);
+                this.resubscribeAll();
+                break;
+            case "ChannelSync":
+                this.emit("channelSync", message.d);
+                break;
+            case "MessageCreate":
+                this.emit("messageCreate", (0, snowflake_1.addTimestampToMessage)(message.d));
+                break;
+            case "MessageUpdate":
+                this.emit("messageUpdate", (0, snowflake_1.addTimestampToMessage)(message.d));
+                break;
+            case "AggregateUpdate":
+                this.emit("aggregateUpdate", message.d);
+                break;
+            case "AlarmTrigger":
+                this.emit("alarmTrigger", message.d);
+                break;
+            case "OneShotMessage":
+                this.emit("oneShotMessage", message.d);
+                break;
+            case "ChannelSubscription":
+                this.emit("channelSubscription", message.d);
+                break;
+            case "ChannelUnsubscription":
+                this.emit("channelUnsubscription", message.d);
+                break;
+            case "WSSErrorEvent":
+                this.emit("wssError", message.d);
+                break;
+            default:
+                break;
+        }
+    }
+    identifyOrResume() {
+        if (this.session) {
+            this.send({
+                op: 11,
+                d: {
+                    session_id: this.session.session_id,
+                    session_token: this.session.session_token,
+                    default_connection: false,
+                },
+            });
+            return;
+        }
+        this.send({
+            op: 10,
+            d: {
+                default_connection: false,
+                organisation_id: this.config.organisationId ?? null,
+                sharing_mode: this.config.sharing ?? "internal",
+            },
+        });
+    }
+    resubscribeAll() {
+        for (const entry of this.subscriptions.values()) {
+            this.subscribe(entry.channel, { diff_only: entry.diff_only });
+        }
+    }
+    startHeartbeat() {
+        this.stopHeartbeat();
+        this.heartbeatTimer = setInterval(() => {
+            if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+                return;
+            }
+            this.lastHeartbeatAt = Date.now();
+            this.missedHeartbeats += 1;
+            if (this.missedHeartbeats > 3) {
+                this.socket.close(4000, "Missed heartbeats");
+                return;
+            }
+            this.send({ op: 1, d: {} });
+        }, 20000);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+        this.missedHeartbeats = 0;
+    }
+    send(payload) {
+        if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+            throw new errors_1.DooverGatewayError("WebSocket is not connected");
+        }
+        this.socket.send(JSON.stringify(payload));
+    }
+    emit(eventName, ...args) {
+        this.listeners[eventName].forEach((listener) => {
+            listener(...args);
+        });
+    }
+    scheduleReconnect() {
+        if (this.reconnectTimer) {
+            return;
+        }
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            this.connect();
+        }, 1000);
+    }
+    channelKey(channel) {
+        return `${channel.agent_id}/${channel.name}`;
+    }
+}
+exports.GatewayClient = GatewayClient;

package/dist/gateway/types.d.ts

@@ -0,0 +1,135 @@
+import type { Aggregate, Alarm, ChannelRef, JSONValue, MessageStructure } from "../types/common";
+export interface WebSocketSubscription {
+    channel: ChannelRef;
+    organisation_id?: string | null;
+    diff_only: boolean;
+}
+export interface WebSocketSession {
+    session_id: string;
+    session_token: string;
+    subscriptions: WebSocketSubscription[];
+}
+export interface GatewayMessageBase {
+    op: number;
+    d: unknown;
+    s?: number | null;
+    t?: string;
+}
+export interface GatewayHello extends GatewayMessageBase {
+    op: 0;
+    t: "Hello";
+    d: Record<string, never>;
+}
+export interface GatewayReady extends GatewayMessageBase {
+    op: 0;
+    t: "Ready";
+    d: WebSocketSession;
+}
+export interface GatewayChannelSync extends GatewayMessageBase {
+    op: 0;
+    t: "ChannelSync";
+    d: {
+        channel: ChannelRef;
+        aggregate: Aggregate;
+    };
+}
+export interface GatewayMessageCreate extends GatewayMessageBase {
+    op: 0;
+    t: "MessageCreate";
+    d: Omit<MessageStructure, "timestamp">;
+}
+export interface GatewayMessageUpdate extends GatewayMessageBase {
+    op: 0;
+    t: "MessageUpdate";
+    d: Omit<MessageStructure, "timestamp"> & {
+        request_data: JSONValue;
+    };
+}
+export interface GatewayAggregateUpdate extends GatewayMessageBase {
+    op: 0;
+    t: "AggregateUpdate";
+    d: {
+        author_id: string;
+        channel: ChannelRef;
+        aggregate: Aggregate;
+        request_data: Aggregate;
+        organisation_id: string;
+    };
+}
+export interface GatewayAlarmTrigger extends GatewayMessageBase {
+    op: 0;
+    t: "AlarmTrigger";
+    d: {
+        channel: ChannelRef;
+        alarm: Alarm;
+        old_state: Alarm["state"];
+        new_state: Alarm["state"];
+        aggregate: Aggregate;
+        request_data: Aggregate;
+        organisation_id: string;
+    };
+}
+export interface GatewayOneShotMessage extends GatewayMessageBase {
+    op: 0;
+    t: "OneShotMessage";
+    d: {
+        id: string | null;
+        author_id: string;
+        channel: ChannelRef;
+        data: JSONValue;
+    };
+}
+export interface GatewayChannelSubscription extends GatewayMessageBase {
+    op: 0;
+    t: "ChannelSubscription";
+    d: {
+        agent_id: string;
+        channel: ChannelRef;
+        session_id: string;
+        default_session: boolean;
+    };
+}
+export interface GatewayChannelUnsubscription extends GatewayMessageBase {
+    op: 0;
+    t: "ChannelUnsubscription";
+    d: {
+        agent_id: string;
+        channel: ChannelRef;
+        session_id: string;
+        default_session: boolean;
+    };
+}
+export interface GatewayWSSErrorEvent extends GatewayMessageBase {
+    op: 0;
+    t: "WSSErrorEvent";
+    d: {
+        message: string;
+    };
+}
+export interface GatewayHeartbeatAck extends GatewayMessageBase {
+    op: 2;
+    d: Record<string, never>;
+}
+export interface GatewaySessionCancelled extends GatewayMessageBase {
+    op: 3;
+    d: Record<string, never>;
+}
+export type GatewayInboundMessage = GatewayHello | GatewayReady | GatewayChannelSync | GatewayMessageCreate | GatewayMessageUpdate | GatewayAggregateUpdate | GatewayAlarmTrigger | GatewayOneShotMessage | GatewayChannelSubscription | GatewayChannelUnsubscription | GatewayWSSErrorEvent | GatewayHeartbeatAck | GatewaySessionCancelled;
+export interface GatewayListenerMap {
+    ready: (event: GatewayReady["d"]) => void;
+    channelSync: (event: GatewayChannelSync["d"]) => void;
+    messageCreate: (event: MessageStructure) => void;
+    messageUpdate: (event: GatewayMessageUpdate["d"] & {
+        timestamp: number;
+    }) => void;
+    aggregateUpdate: (event: GatewayAggregateUpdate["d"]) => void;
+    alarmTrigger: (event: GatewayAlarmTrigger["d"]) => void;
+    oneShotMessage: (event: GatewayOneShotMessage["d"]) => void;
+    channelSubscription: (event: GatewayChannelSubscription["d"]) => void;
+    channelUnsubscription: (event: GatewayChannelUnsubscription["d"]) => void;
+    wssError: (event: GatewayWSSErrorEvent["d"]) => void;
+    sessionCancelled: () => void;
+    open: () => void;
+    close: (event: CloseEvent) => void;
+    heartbeatAck: (latencyMs: number | null) => void;
+}

package/dist/gateway/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/http/errors.d.ts

@@ -0,0 +1,19 @@
+export declare class DooverApiError extends Error {
+    status: number;
+    body: unknown;
+    url: string;
+    method: string;
+    constructor(params: {
+        status: number;
+        body: unknown;
+        url: string;
+        method: string;
+        message?: string;
+    });
+}
+export declare class DooverValidationError extends Error {
+    constructor(message: string);
+}
+export declare class DooverGatewayError extends Error {
+    constructor(message: string);
+}

package/dist/http/errors.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DooverGatewayError = exports.DooverValidationError = exports.DooverApiError = void 0;
+class DooverApiError extends Error {
+    constructor(params) {
+        super(params.message ?? `Request failed with status ${params.status}`);
+        this.name = "DooverApiError";
+        this.status = params.status;
+        this.body = params.body;
+        this.url = params.url;
+        this.method = params.method;
+    }
+}
+exports.DooverApiError = DooverApiError;
+class DooverValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "DooverValidationError";
+    }
+}
+exports.DooverValidationError = DooverValidationError;
+class DooverGatewayError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "DooverGatewayError";
+    }
+}
+exports.DooverGatewayError = DooverGatewayError;

package/dist/http/rest-client.d.ts

@@ -0,0 +1,35 @@
+export interface DooverClientConfig {
+    dataRestUrl: string;
+    controlApiUrl: string;
+    dataWssUrl: string;
+    organisationId?: string | null;
+    sharing?: "internal" | "external" | "none";
+    impersonateUserStorageKey?: string;
+    fetchImpl?: typeof fetch;
+    webSocketImpl?: typeof WebSocket;
+}
+export interface RequestOptions {
+    baseUrl?: string;
+    path: string;
+    method?: string;
+    query?: QueryParams;
+    body?: BodyInit | object | null;
+    headers?: HeadersInit;
+}
+type QueryValue = string | number | boolean | null | undefined | Array<string | number | boolean>;
+type QueryParams = Record<string, QueryValue> | object;
+export declare class RestClient {
+    readonly config: Required<Pick<DooverClientConfig, "dataRestUrl" | "controlApiUrl" | "dataWssUrl" | "sharing" | "impersonateUserStorageKey">> & Pick<DooverClientConfig, "organisationId" | "fetchImpl" | "webSocketImpl">;
+    constructor(config: DooverClientConfig);
+    request<T>(options: RequestOptions): Promise<T>;
+    get<T>(path: string, query?: RequestOptions["query"], baseUrl?: string): Promise<T>;
+    post<T>(path: string, body?: RequestOptions["body"], query?: RequestOptions["query"], baseUrl?: string): Promise<T>;
+    put<T>(path: string, body?: RequestOptions["body"], query?: RequestOptions["query"], baseUrl?: string): Promise<T>;
+    patch<T>(path: string, body?: RequestOptions["body"], query?: RequestOptions["query"], baseUrl?: string): Promise<T>;
+    delete<T>(path: string, query?: RequestOptions["query"], baseUrl?: string): Promise<T>;
+    private buildUrl;
+    private normalizeBody;
+    private parseResponse;
+    private getImpersonatedUserId;
+}
+export {};