@fusebase/fusebase-gate-sdk 1.0.2-sdk.0

package/dist/apis/TokensApi.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * Tokens API
+ *
+ * Generated from contract introspection
+ * Domain: tokens
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokensApi = void 0;
+class TokensApi {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Create a new API token
+     * Create a new API token with specified scopes and permissions.
+     * The token value is only returned once on creation - store it securely.
+     * At least one org scope is required in the scopes array.
+     *
+     */
+    async createToken(params) {
+        return this.client.request({
+            method: "POST",
+            path: "/tokens",
+            headers: params.headers,
+            body: params.body,
+            opId: "createToken",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Get token by ID
+     * Retrieve details of a specific API token by its global ID
+     */
+    async getToken(params) {
+        return this.client.request({
+            method: "GET",
+            path: "/tokens/:tokenId",
+            pathParams: params.path,
+            headers: params.headers,
+            opId: "getToken",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * List user's API tokens
+     * Retrieve a list of all API tokens for the authenticated user.
+     * Optionally filter by scope type and scope ID (both must be provided together).
+     *
+     */
+    async listTokens(params) {
+        return this.client.request({
+            method: "GET",
+            path: "/tokens",
+            query: params.query,
+            headers: params.headers,
+            opId: "listTokens",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Revoke token
+     * Permanently revoke (soft delete) an API token.
+     * Once revoked, the token can no longer be used for authentication.
+     *
+     */
+    async revokeToken(params) {
+        return this.client.request({
+            method: "DELETE",
+            path: "/tokens/:tokenId",
+            pathParams: params.path,
+            headers: params.headers,
+            opId: "revokeToken",
+            expectedContentType: "application/json",
+        });
+    }
+    /**
+     * Update token
+     * Update token properties (name, permissions, expiration).
+     * Note: The token value itself cannot be changed.
+     *
+     */
+    async updateToken(params) {
+        return this.client.request({
+            method: "PUT",
+            path: "/tokens/:tokenId",
+            pathParams: params.path,
+            headers: params.headers,
+            body: params.body,
+            opId: "updateToken",
+            expectedContentType: "application/json",
+        });
+    }
+}
+exports.TokensApi = TokensApi;

package/dist/extras/fetchWithRetry.d.ts

@@ -0,0 +1,30 @@
+export type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+type BackoffValue = number | ((attempt: number, response?: Response | undefined, error?: unknown) => number);
+export interface RetryOptions {
+    /**
+     * Number of retry attempts after the initial request.
+     * A value of 0 disables retries.
+     * @default 3
+     */
+    retries?: number;
+    /**
+     * Static or dynamic backoff duration (ms) between retries.
+     * When a function is provided, it receives the current attempt index (starting at 1),
+     * the last failing response (if any), and the last thrown error (if any).
+     * @default attempt => Math.min(1000 * 2 ** attempt, 30000)
+     */
+    backoffMs?: BackoffValue;
+    /**
+     * Predicate that determines whether a response should be retried.
+     * Throwing inside this function will abort the retry loop.
+     * @default status >= 500 && status < 600
+     */
+    shouldRetry?: (response: Response) => boolean;
+    /**
+     * Optional guard to abort retrying on specific errors (network, abort, etc.).
+     * Return true to continue retrying, false to rethrow immediately.
+     */
+    shouldRetryError?: (error: unknown) => boolean;
+}
+export declare function createFetchWithRetry(baseFetch: FetchLike, { retries, backoffMs, shouldRetry, shouldRetryError, }?: RetryOptions): FetchLike;
+export {};

package/dist/extras/fetchWithRetry.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFetchWithRetry = createFetchWithRetry;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const defaultShouldRetry = (response) => response.status >= 500 && response.status < 600;
+const defaultBackoff = (attempt) => Math.min(1000 * 2 ** attempt, 30000);
+const shouldRetryNetworkError = (error) => {
+    if (error == null) {
+        return true;
+    }
+    if (typeof error !== "object") {
+        return true;
+    }
+    if (error.name === "AbortError") {
+        return false;
+    }
+    return true;
+};
+function createFetchWithRetry(baseFetch, { retries = 3, backoffMs = defaultBackoff, shouldRetry = defaultShouldRetry, shouldRetryError = shouldRetryNetworkError, } = {}) {
+    return async (input, init) => {
+        const originalRequest = input instanceof Request ? input : new Request(input, init);
+        let lastError;
+        let lastResponse;
+        for (let attempt = 0; attempt <= retries; attempt++) {
+            if (attempt > 0) {
+                const wait = typeof backoffMs === "function"
+                    ? backoffMs(attempt, lastResponse, lastError)
+                    : backoffMs;
+                if (wait > 0) {
+                    console.log(`Waiting ${wait}ms before next attempt #${attempt}, ${lastError instanceof Error ? lastError.message : "unknown error"}`);
+                    await sleep(wait);
+                }
+            }
+            try {
+                const response = await baseFetch(originalRequest.clone());
+                if (!shouldRetry(response) || attempt === retries) {
+                    return response;
+                }
+                lastResponse = response;
+            }
+            catch (error) {
+                lastError = error;
+                if (!shouldRetryError(error) || attempt === retries) {
+                    throw error;
+                }
+            }
+        }
+        // Should never reach here, but TypeScript needs a final throw.
+        throw lastError instanceof Error
+            ? lastError
+            : new Error("createFetchWithRetry exhausted all retries without a terminal condition");
+    };
+}

package/dist/extras/messaging.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Base event interface
+ * All events must extend this interface
+ */
+export interface EventBase<T extends string = string, P = unknown> {
+    type: T;
+    payload: P;
+}
+/**
+ * Dashboard event types
+ */
+export declare const EVENTS: {
+    readonly DATABASE_CREATED: "database:created";
+    readonly DASHBOARD_CREATED: "dashboard:created";
+    readonly DASHBOARD_DELETED: "dashboard:deleted";
+    readonly DASHBOARD_ROW_CREATED: "dashboard:row_created";
+    readonly DASHBOARD_ROW_COLUMN_UPDATED: "dashboard:row_column_updated";
+    readonly DASHBOARD_RELATION_UPDATED: "dashboard:relation_updated";
+    readonly DASHBOARD_RELATION_DELETED: "dashboard:relation_deleted";
+};
+export type DashboardEventType = (typeof EVENTS)[keyof typeof EVENTS];
+/**
+ * Event payload interfaces
+ */
+export interface DatabaseCreatedPayload {
+    orgId: string;
+    databaseId: string;
+}
+export interface DashboardCreatedPayload {
+    orgId: string;
+    dashboardId: string;
+    databaseId?: string;
+}
+export interface DashboardRowCreatedPayload {
+    orgId: string;
+    dashboardId: string;
+    rowUuids: string[];
+}
+export interface DashboardRowColumnUpdatedPayload {
+    orgId: string;
+    dashboardId: string;
+    viewId: string;
+    rootIndexValue: string;
+    itemKey: string;
+    valueBefore: null | string | number | boolean | object | Date;
+    alias: null | string;
+    render: {
+        type: string;
+    };
+}
+export interface DashboardRelationPayload {
+    globalId: string;
+    sourceDashboardId: string;
+    targetDashboardId: string;
+    beforeRows: object[];
+    afterRows: object[];
+}
+export interface DashboardDeletedPayload {
+    dashboardId: string;
+}
+/**
+ * Event interfaces
+ */
+export type DatabaseCreatedEvent = EventBase<typeof EVENTS.DATABASE_CREATED, DatabaseCreatedPayload>;
+export type DashboardCreatedEvent = EventBase<typeof EVENTS.DASHBOARD_CREATED, DashboardCreatedPayload>;
+export type DashboardRowCreatedEvent = EventBase<typeof EVENTS.DASHBOARD_ROW_CREATED, DashboardRowCreatedPayload>;
+export type DashboardRowColumnUpdatedEvent = EventBase<typeof EVENTS.DASHBOARD_RELATION_UPDATED, DashboardRowColumnUpdatedPayload>;
+export type DashboardRelationUpdatedEvent = EventBase<typeof EVENTS.DASHBOARD_RELATION_DELETED, DashboardRelationPayload>;
+export type DashboardRelationDeletedEvent = EventBase<typeof EVENTS.DASHBOARD_ROW_COLUMN_UPDATED, DashboardRelationPayload>;
+export type DashboardDeletedEvent = EventBase<typeof EVENTS.DASHBOARD_DELETED, DashboardDeletedPayload>;
+/**
+ * Union type of all dashboard events
+ * Will be extended when more events are added
+ */
+export type DashboardEvent = DatabaseCreatedEvent | DashboardCreatedEvent | DashboardRowCreatedEvent | DashboardRowColumnUpdatedEvent | DashboardDeletedEvent | DashboardRelationUpdatedEvent | DashboardRelationDeletedEvent;
+/**
+ * Helper: Extract payload type by event type string
+ */
+export type DashboardEventPayload<T extends DashboardEvent["type"]> = Extract<DashboardEvent, {
+    type: T;
+}>["payload"];

package/dist/extras/messaging.js

@@ -0,0 +1,16 @@
+"use strict";
+// Do not import anything in this file, messaging.ts copy in sdk-client
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVENTS = void 0;
+/**
+ * Dashboard event types
+ */
+exports.EVENTS = {
+    DATABASE_CREATED: "database:created",
+    DASHBOARD_CREATED: "dashboard:created",
+    DASHBOARD_DELETED: "dashboard:deleted",
+    DASHBOARD_ROW_CREATED: "dashboard:row_created",
+    DASHBOARD_ROW_COLUMN_UPDATED: "dashboard:row_column_updated",
+    DASHBOARD_RELATION_UPDATED: "dashboard:relation_updated",
+    DASHBOARD_RELATION_DELETED: "dashboard:relation_deleted",
+};

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * SDK Client
+ *
+ * Generated from contract introspection
+ */
+export * from "./runtime";
+export * from "./types";
+export { HealthApi } from "./apis/HealthApi";
+export { OrgUsersApi } from "./apis/OrgUsersApi";
+export { TokensApi } from "./apis/TokensApi";
+export * from "./extras/fetchWithRetry";

package/dist/index.js

@@ -0,0 +1,31 @@
+"use strict";
+/**
+ * SDK Client
+ *
+ * Generated from contract introspection
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokensApi = exports.OrgUsersApi = exports.HealthApi = void 0;
+__exportStar(require("./runtime"), exports);
+__exportStar(require("./types"), exports);
+var HealthApi_1 = require("./apis/HealthApi");
+Object.defineProperty(exports, "HealthApi", { enumerable: true, get: function () { return HealthApi_1.HealthApi; } });
+var OrgUsersApi_1 = require("./apis/OrgUsersApi");
+Object.defineProperty(exports, "OrgUsersApi", { enumerable: true, get: function () { return OrgUsersApi_1.OrgUsersApi; } });
+var TokensApi_1 = require("./apis/TokensApi");
+Object.defineProperty(exports, "TokensApi", { enumerable: true, get: function () { return TokensApi_1.TokensApi; } });
+__exportStar(require("./extras/fetchWithRetry"), exports);

package/dist/runtime/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Runtime exports
+ */
+export * from "./types";
+export * from "./transport";

package/dist/runtime/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Runtime exports
+ */
+__exportStar(require("./types"), exports);
+__exportStar(require("./transport"), exports);

package/dist/runtime/transport.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Runtime transport for SDK
+ * Generated by SDK codegen
+ */
+import { type ClientConfig } from "./types";
+/**
+ * Request options for transport layer
+ */
+export interface RequestOptions {
+    method: string;
+    path: string;
+    pathParams?: Record<string, string | number>;
+    query?: Record<string, unknown>;
+    headers?: Record<string, string>;
+    body?: unknown;
+    opId?: string;
+    expectedContentType?: string;
+}
+/**
+ * Client instance returned by createClient
+ */
+export interface Client {
+    request<T = unknown>(options: RequestOptions): Promise<T>;
+}
+/**
+ * Create SDK client
+ */
+export declare function createClient(config: ClientConfig): Client;

package/dist/runtime/transport.js

@@ -0,0 +1,237 @@
+"use strict";
+/**
+ * Runtime transport for SDK
+ * Generated by SDK codegen
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClient = createClient;
+// @ts-ignore - Import path valid in generated SDK (src/runtime -> src/extras), not in generator source
+const fetchWithRetry_1 = require("../extras/fetchWithRetry");
+const types_1 = require("./types");
+function isPrimitive(v) {
+    return (typeof v === "string" || typeof v === "number" || typeof v === "boolean");
+}
+/** True if value is a plain object with only numeric keys 0,1,2,... (array-like). */
+function isArrayLikeObject(v) {
+    if (v === null || typeof v !== "object" || Array.isArray(v))
+        return false;
+    const keys = Object.keys(v);
+    if (keys.length === 0)
+        return false;
+    return keys.every((k, i) => k === String(i));
+}
+/** Get values from array-like object in index order. */
+function getArrayLikeValues(obj) {
+    const keys = Object.keys(obj).sort((a, b) => Number(a) - Number(b));
+    return keys.map((k) => obj[k]);
+}
+/**
+ * Serialize query object. Uses form-style for top-level arrays of primitives
+ * (key=val1&key=val2) so servers get a normal repeated key. Array-like objects
+ * (plain objects with keys "0","1",...) are serialized the same way. Uses deepObject
+ * for nested structures (e.g. mapping[columns][0][index]=0).
+ */
+function buildQueryString(query) {
+    const parts = [];
+    function encodeKey(prefix, key) {
+        return prefix ? `${prefix}[${key}]` : key;
+    }
+    function append(keyPrefix, value) {
+        if (value === undefined || value === null)
+            return;
+        if (isPrimitive(value)) {
+            parts.push(`${encodeURIComponent(keyPrefix)}=${encodeURIComponent(String(value))}`);
+            return;
+        }
+        if (Array.isArray(value)) {
+            const allPrimitive = value.every(isPrimitive);
+            if (allPrimitive) {
+                for (const item of value) {
+                    parts.push(`${encodeURIComponent(keyPrefix)}=${encodeURIComponent(String(item))}`);
+                }
+                return;
+            }
+            value.forEach((item, i) => append(`${keyPrefix}[${i}]`, item));
+            return;
+        }
+        if (typeof value === "object" && value !== null) {
+            // Array-like object (e.g. { 0: "a", 1: "b" }) → form-style repeated key, not root_entities[0]=a
+            if (isArrayLikeObject(value)) {
+                const arr = getArrayLikeValues(value);
+                const allPrimitive = arr.every(isPrimitive);
+                if (allPrimitive) {
+                    for (const item of arr) {
+                        parts.push(`${encodeURIComponent(keyPrefix)}=${encodeURIComponent(String(item))}`);
+                    }
+                    return;
+                }
+                arr.forEach((item, i) => append(`${keyPrefix}[${i}]`, item));
+                return;
+            }
+            for (const [k, v] of Object.entries(value)) {
+                append(encodeKey(keyPrefix, k), v);
+            }
+        }
+    }
+    for (const [key, value] of Object.entries(query)) {
+        if (value !== undefined && value !== null) {
+            append(key, value);
+        }
+    }
+    return parts.join("&");
+}
+/**
+ * Create SDK client
+ */
+function createClient(config) {
+    const { baseUrl, auth, defaultHeaders = {}, timeout = 30000 } = config;
+    // Build authorization header
+    const authHeader = {};
+    if (auth === null || auth === void 0 ? void 0 : auth.authorization) {
+        authHeader["Authorization"] = auth.authorization;
+    }
+    else if (auth === null || auth === void 0 ? void 0 : auth.token) {
+        authHeader["Authorization"] = `Bearer ${auth.token}`;
+    }
+    // Merge default headers with auth
+    const clientHeaders = {
+        ...defaultHeaders,
+        ...authHeader,
+    };
+    // Create fetch with retry logic for network errors and 5xx responses
+    // Retries up to 3 times with exponential backoff for transient failures
+    const fetchWithRetry = (0, fetchWithRetry_1.createFetchWithRetry)(fetch, {
+        retries: 3,
+        backoffMs: (attempt) => Math.min(1000 * 2 ** attempt, 5000), // Max 5s backoff
+        shouldRetry: (response) => {
+            // Retry on 5xx server errors
+            return response.status >= 500 && response.status < 600;
+        },
+        shouldRetryError: (error) => {
+            // Retry on network errors (status 0, connection refused, etc.)
+            // Don't retry on abort errors (timeouts)
+            if (error instanceof Error && error.name === "AbortError") {
+                return false;
+            }
+            return true;
+        },
+    });
+    return {
+        async request(options) {
+            const { method, path, pathParams = {}, query, headers = {}, body, opId = "unknown", expectedContentType, } = options;
+            // Replace path parameters (e.g., "/tokens/:id" with { id: "123" } -> "/tokens/123")
+            // Extract required path params from path template
+            const pathParamNames = new Set();
+            const pathParamRegex = /:(\w+)/g;
+            let match;
+            while ((match = pathParamRegex.exec(path)) !== null) {
+                pathParamNames.add(match[1]);
+            }
+            // Validate required path params are provided
+            for (const paramName of pathParamNames) {
+                if (!(paramName in pathParams)) {
+                    throw new types_1.ApiError(400, opId, path, { message: `Missing required path parameter: ${paramName}` }, undefined);
+                }
+            }
+            // Replace path parameters with URL-encoded values
+            let resolvedPath = path;
+            for (const [key, value] of Object.entries(pathParams)) {
+                const encodedValue = encodeURIComponent(String(value));
+                resolvedPath = resolvedPath.replace(new RegExp(`:${key}(?=/|$)`), encodedValue);
+            }
+            // Build query string (form-style for arrays of primitives; deepObject for nested)
+            const queryString = query && Object.keys(query).length > 0 ? buildQueryString(query) : "";
+            const url = `${baseUrl}${resolvedPath}${queryString ? `?${queryString}` : ""}`;
+            // Merge headers: client defaults + per-call headers (per-call overrides)
+            const requestHeaders = {
+                ...clientHeaders,
+                ...headers,
+            };
+            // Body and Content-Type: FormData/Blob must be sent as-is (multipart/binary); do not set Content-Type so browser sets boundary
+            const isFormData = typeof FormData !== "undefined" && body instanceof FormData;
+            const isBlob = typeof Blob !== "undefined" && body instanceof Blob;
+            if (isFormData || isBlob) {
+                delete requestHeaders["Content-Type"];
+            }
+            else if (body !== undefined && body !== null) {
+                if (!requestHeaders["Content-Type"]) {
+                    requestHeaders["Content-Type"] = "application/json";
+                }
+            }
+            // Create AbortController for timeout
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), timeout);
+            let requestBody;
+            if (body !== undefined && body !== null) {
+                requestBody =
+                    isFormData || isBlob
+                        ? body
+                        : JSON.stringify(body);
+            }
+            else {
+                requestBody = undefined;
+            }
+            try {
+                const response = await fetchWithRetry(url, {
+                    method,
+                    headers: requestHeaders,
+                    body: requestBody,
+                    signal: controller.signal,
+                });
+                clearTimeout(timeoutId);
+                // Handle 204 No Content
+                if (response.status === 204) {
+                    return undefined;
+                }
+                // Determine content type: use actual response header first, fallback to expectedContentType
+                let contentType = response.headers.get("content-type") || "";
+                // Strip charset and other parameters (e.g., "text/csv; charset=utf-8" -> "text/csv")
+                if (contentType) {
+                    contentType = contentType.split(";")[0].trim();
+                }
+                if (!contentType && expectedContentType) {
+                    contentType = expectedContentType;
+                }
+                let data;
+                // Parse response based on actual content type
+                if (contentType.includes("application/json")) {
+                    data = (await response.json());
+                }
+                else if (contentType.includes("text/csv")) {
+                    data = (await response.text());
+                }
+                else if (contentType.includes("application/pdf")) {
+                    data = (await response.arrayBuffer());
+                }
+                else {
+                    // Fallback: try to parse as text, then attempt JSON
+                    const text = await response.text();
+                    try {
+                        data = JSON.parse(text);
+                    }
+                    catch {
+                        data = text;
+                    }
+                }
+                // Check for error status (after parsing to get error body)
+                if (!response.ok) {
+                    const requestId = response.headers.get("x-request-id") || undefined;
+                    throw new types_1.ApiError(response.status, opId, url, data, requestId);
+                }
+                return data;
+            }
+            catch (error) {
+                clearTimeout(timeoutId);
+                if (error instanceof types_1.ApiError) {
+                    throw error;
+                }
+                // Handle fetch errors (network, timeout, etc.)
+                if (error instanceof Error && error.name === "AbortError") {
+                    throw new types_1.ApiError(408, opId, url, undefined, undefined);
+                }
+                // Re-throw as ApiError with minimal info
+                throw new types_1.ApiError(0, opId, url, error, undefined);
+            }
+        },
+    };
+}

package/dist/runtime/types.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Runtime types for SDK
+ * Generated by SDK codegen
+ */
+/**
+ * Client configuration
+ */
+export interface ClientConfig {
+    /**
+     * Base URL for API requests (e.g., "https://api.example.com")
+     */
+    baseUrl: string;
+    /**
+     * Authentication configuration
+     */
+    auth?: AuthConfig;
+    /**
+     * Default headers to include in all requests
+     */
+    defaultHeaders?: Record<string, string>;
+    /**
+     * Request timeout in milliseconds (default: 30000)
+     */
+    timeout?: number;
+}
+/**
+ * Authentication configuration
+ */
+export interface AuthConfig {
+    /**
+     * API token for authentication
+     * Will be sent as "Authorization: Bearer <token>"
+     */
+    token?: string;
+    /**
+     * Custom authorization header value
+     * If provided, will be used instead of "Bearer <token>"
+     */
+    authorization?: string;
+}
+/**
+ * API Error
+ * Thrown when a request fails (non-2xx response)
+ */
+export declare class ApiError extends Error {
+    readonly status: number;
+    readonly opId: string;
+    readonly url: string;
+    readonly body?: unknown | undefined;
+    readonly requestId?: string | undefined;
+    constructor(status: number, opId: string, url: string, body?: unknown | undefined, requestId?: string | undefined);
+}