@dominusnode/sdk 1.0.0

package/dist/esm/client.js

@@ -0,0 +1,105 @@
+import { TokenManager } from "./token-manager.js";
+import { HttpClient } from "./http.js";
+import { AuthResource } from "./auth.js";
+import { KeysResource } from "./keys.js";
+import { WalletResource } from "./wallet.js";
+import { UsageResource } from "./usage.js";
+import { PlansResource } from "./plans.js";
+import { SessionsResource } from "./sessions.js";
+import { ProxyResource } from "./proxy.js";
+import { AdminResource } from "./admin.js";
+import { SlotsResource } from "./slots.js";
+import { AgenticWalletResource } from "./resources/agent-wallet.js";
+import { TeamsResource } from "./resources/teams.js";
+import { X402Resource } from "./resources/x402.js";
+import { WalletAuthResource } from "./resources/wallet-auth.js";
+import { DEFAULT_BASE_URL } from "./constants.js";
+export class DominusNodeClient {
+    auth;
+    keys;
+    wallet;
+    usage;
+    plans;
+    sessions;
+    proxy;
+    admin;
+    slots;
+    agenticWallets;
+    teams;
+    x402;
+    walletAuth;
+    tokenManager;
+    http;
+    apiKey = null;
+    constructor(config = {}) {
+        const baseUrl = config.baseUrl ?? DEFAULT_BASE_URL;
+        this.tokenManager = new TokenManager();
+        this.http = new HttpClient(baseUrl, this.tokenManager);
+        // Initialize all resource modules BEFORE setting refresh function
+        // this.auth must exist before refresh function can be invoked
+        this.auth = new AuthResource(this.http);
+        this.keys = new KeysResource(this.http);
+        this.wallet = new WalletResource(this.http);
+        this.usage = new UsageResource(this.http);
+        this.plans = new PlansResource(this.http);
+        this.sessions = new SessionsResource(this.http);
+        this.proxy = new ProxyResource(this.http, config);
+        this.admin = new AdminResource(this.http);
+        this.slots = new SlotsResource(this.http);
+        this.agenticWallets = new AgenticWalletResource(this.http);
+        this.teams = new TeamsResource(this.http);
+        this.x402 = new X402Resource(this.http);
+        this.walletAuth = new WalletAuthResource(this.http, this.tokenManager);
+        // Set refresh function AFTER auth is initialized
+        this.tokenManager.setRefreshFunction(async (rt) => {
+            const res = await this.auth.refresh(rt);
+            return { accessToken: res.token, refreshToken: res.refreshToken };
+        });
+        // Auto-authenticate if tokens were provided in config
+        if (config.accessToken) {
+            this.tokenManager.setTokens(config.accessToken, config.refreshToken);
+        }
+    }
+    /**
+     * Authenticate with an API key.
+     * Verifies the key against the server and stores the resulting JWT tokens
+     * for subsequent authenticated requests.
+     */
+    async connectWithKey(apiKey) {
+        const res = await this.auth.verifyKey(apiKey);
+        this.apiKey = apiKey;
+        this.tokenManager.setTokens(res.token, res.refreshToken);
+    }
+    /**
+     * Authenticate with email and password.
+     * If MFA is required, the returned result will have `mfaRequired: true`.
+     * Call `completeMfa()` to finish authentication in that case.
+     */
+    async connectWithCredentials(email, password) {
+        const res = await this.auth.login(email, password);
+        if (res.token) {
+            this.tokenManager.setTokens(res.token, res.refreshToken);
+        }
+        return { user: res.user, mfaRequired: res.mfaRequired };
+    }
+    /**
+     * Complete MFA verification after a login that returned `mfaRequired: true`.
+     */
+    async completeMfa(code, opts) {
+        const res = await this.auth.verifyMfa(code, opts);
+        this.tokenManager.setTokens(res.token, res.refreshToken);
+    }
+    /**
+     * Disconnect: revoke refresh tokens server-side (best-effort) and clear all stored tokens.
+     */
+    async disconnect() {
+        try {
+            await this.auth.logout();
+        }
+        catch {
+            // Best-effort — server may be unreachable
+        }
+        this.apiKey = null;
+        this.tokenManager.clear();
+    }
+}

package/dist/esm/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const SDK_VERSION = "1.0.0";
+export declare const USER_AGENT = "dominusnode-sdk-node/1.0.0";
+export declare const DEFAULT_BASE_URL = "https://api.dominusnode.com";
+export declare const DEFAULT_PROXY_HOST = "proxy.dominusnode.com";
+export declare const DEFAULT_HTTP_PROXY_PORT = 8080;
+export declare const DEFAULT_SOCKS5_PROXY_PORT = 1080;
+export declare const TOKEN_REFRESH_BUFFER_MS = 60000;
+export declare const MAX_RATE_LIMIT_RETRIES = 1;

package/dist/esm/constants.js

@@ -0,0 +1,8 @@
+export const SDK_VERSION = "1.0.0";
+export const USER_AGENT = `dominusnode-sdk-node/${SDK_VERSION}`;
+export const DEFAULT_BASE_URL = "https://api.dominusnode.com";
+export const DEFAULT_PROXY_HOST = "proxy.dominusnode.com";
+export const DEFAULT_HTTP_PROXY_PORT = 8080;
+export const DEFAULT_SOCKS5_PROXY_PORT = 1080;
+export const TOKEN_REFRESH_BUFFER_MS = 60_000; // Refresh 60s before expiry
+export const MAX_RATE_LIMIT_RETRIES = 1;

package/dist/esm/errors.d.ts

@@ -0,0 +1,36 @@
+export declare class DominusNodeError extends Error {
+    readonly statusCode?: number | undefined;
+    constructor(message: string, statusCode?: number | undefined);
+}
+export declare class AuthenticationError extends DominusNodeError {
+    constructor(message?: string);
+}
+export declare class AuthorizationError extends DominusNodeError {
+    constructor(message?: string);
+}
+export declare class RateLimitError extends DominusNodeError {
+    readonly retryAfterSeconds: number;
+    constructor(message?: string, retryAfter?: number);
+}
+export declare class InsufficientBalanceError extends DominusNodeError {
+    constructor(message?: string);
+}
+export declare class ValidationError extends DominusNodeError {
+    constructor(message?: string);
+}
+export declare class NotFoundError extends DominusNodeError {
+    constructor(message?: string);
+}
+export declare class ConflictError extends DominusNodeError {
+    constructor(message?: string);
+}
+export declare class ServerError extends DominusNodeError {
+    constructor(message?: string);
+}
+export declare class NetworkError extends DominusNodeError {
+    constructor(message?: string);
+}
+export declare class ProxyError extends DominusNodeError {
+    readonly proxyErrorCode?: string;
+    constructor(message: string, proxyErrorCode?: string);
+}

package/dist/esm/errors.js

@@ -0,0 +1,72 @@
+export class DominusNodeError extends Error {
+    statusCode;
+    constructor(message, statusCode) {
+        super(message);
+        this.statusCode = statusCode;
+        this.name = "DominusNodeError";
+    }
+}
+export class AuthenticationError extends DominusNodeError {
+    constructor(message = "Authentication failed") {
+        super(message, 401);
+        this.name = "AuthenticationError";
+    }
+}
+export class AuthorizationError extends DominusNodeError {
+    constructor(message = "Access denied") {
+        super(message, 403);
+        this.name = "AuthorizationError";
+    }
+}
+export class RateLimitError extends DominusNodeError {
+    retryAfterSeconds;
+    constructor(message = "Rate limit exceeded", retryAfter = 60) {
+        super(message, 429);
+        this.name = "RateLimitError";
+        this.retryAfterSeconds = retryAfter;
+    }
+}
+export class InsufficientBalanceError extends DominusNodeError {
+    constructor(message = "Insufficient balance") {
+        super(message, 402);
+        this.name = "InsufficientBalanceError";
+    }
+}
+export class ValidationError extends DominusNodeError {
+    constructor(message = "Validation failed") {
+        super(message, 400);
+        this.name = "ValidationError";
+    }
+}
+export class NotFoundError extends DominusNodeError {
+    constructor(message = "Resource not found") {
+        super(message, 404);
+        this.name = "NotFoundError";
+    }
+}
+export class ConflictError extends DominusNodeError {
+    constructor(message = "Resource conflict") {
+        super(message, 409);
+        this.name = "ConflictError";
+    }
+}
+export class ServerError extends DominusNodeError {
+    constructor(message = "Server error") {
+        super(message, 500);
+        this.name = "ServerError";
+    }
+}
+export class NetworkError extends DominusNodeError {
+    constructor(message = "Network error") {
+        super(message);
+        this.name = "NetworkError";
+    }
+}
+export class ProxyError extends DominusNodeError {
+    proxyErrorCode;
+    constructor(message, proxyErrorCode) {
+        super(message);
+        this.name = "ProxyError";
+        this.proxyErrorCode = proxyErrorCode;
+    }
+}

package/dist/esm/http.d.ts

@@ -0,0 +1,19 @@
+import type { TokenManager } from "./token-manager.js";
+export interface HttpOptions {
+    method: string;
+    path: string;
+    body?: unknown;
+    headers?: Record<string, string>;
+    requiresAuth?: boolean;
+}
+export declare class HttpClient {
+    private baseUrl;
+    private tokenManager;
+    constructor(baseUrl: string, tokenManager: TokenManager);
+    request<T>(opts: HttpOptions): Promise<T>;
+    get<T>(path: string, requiresAuth?: boolean): Promise<T>;
+    post<T>(path: string, body?: unknown, requiresAuth?: boolean): Promise<T>;
+    put<T>(path: string, body?: unknown): Promise<T>;
+    patch<T>(path: string, body?: unknown): Promise<T>;
+    delete<T>(path: string): Promise<T>;
+}

package/dist/esm/http.js

@@ -0,0 +1,191 @@
+import { USER_AGENT } from "./constants.js";
+import { DominusNodeError, AuthenticationError, AuthorizationError, RateLimitError, InsufficientBalanceError, ValidationError, NotFoundError, ConflictError, ServerError, NetworkError, } from "./errors.js";
+// Sanitize parsed JSON to prevent prototype pollution from untrusted API responses
+// Recursive prototype pollution stripping (covers nested objects too)
+const DANGEROUS_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+// Depth limit prevents stack overflow on deeply nested JSON
+function stripDangerousKeys(obj, depth = 0) {
+    if (depth > 50 || !obj || typeof obj !== "object")
+        return;
+    if (Array.isArray(obj)) {
+        for (const item of obj)
+            stripDangerousKeys(item, depth + 1);
+        return;
+    }
+    const record = obj;
+    for (const key of Object.keys(record)) {
+        if (DANGEROUS_KEYS.has(key)) {
+            delete record[key];
+        }
+        else if (record[key] && typeof record[key] === "object") {
+            stripDangerousKeys(record[key], depth + 1);
+        }
+    }
+}
+function safeJsonParse(text) {
+    const parsed = JSON.parse(text);
+    stripDangerousKeys(parsed);
+    return parsed;
+}
+// Add jitter to retry delays to prevent thundering-herd on rate-limited endpoints
+function addJitter(ms) {
+    const jitter = ms * 0.2 * (Math.random() - 0.5); // ±10% jitter
+    return Math.max(100, Math.round(ms + jitter));
+}
+function throwForStatus(status, body, headers) {
+    let message;
+    try {
+        const parsed = JSON.parse(body);
+        message = parsed.error ?? parsed.message ?? body;
+    }
+    catch {
+        message = body;
+    }
+    // Truncate error message to prevent unbounded body in exception strings
+    if (message.length > 500)
+        message = message.slice(0, 500) + "... [truncated]";
+    switch (status) {
+        case 400: throw new ValidationError(message);
+        case 401: throw new AuthenticationError(message);
+        case 402: throw new InsufficientBalanceError(message);
+        case 403: throw new AuthorizationError(message);
+        case 404: throw new NotFoundError(message);
+        case 409: throw new ConflictError(message);
+        case 429: {
+            const parsed = parseInt(headers.get("retry-after") ?? "60", 10);
+            const retryAfter = Number.isFinite(parsed) ? parsed : 60; // NaN guard
+            throw new RateLimitError(message, retryAfter);
+        }
+        default:
+            if (status >= 500)
+                throw new ServerError(message);
+            throw new DominusNodeError(message, status);
+    }
+}
+// Max response body size to prevent OOM from malicious/large API responses
+const MAX_RESPONSE_BYTES = 10 * 1024 * 1024; // 10 MB
+export class HttpClient {
+    baseUrl;
+    tokenManager;
+    constructor(baseUrl, tokenManager) {
+        this.baseUrl = baseUrl;
+        this.tokenManager = tokenManager;
+    }
+    async request(opts) {
+        const headers = {
+            "User-Agent": USER_AGENT,
+            "Content-Type": "application/json",
+            ...opts.headers,
+        };
+        if (opts.requiresAuth !== false) {
+            const token = await this.tokenManager.getValidToken();
+            // Guard against null/empty token to prevent "Bearer " header
+            if (!token) {
+                throw new Error("No valid token available. Call connectWithKey() or login() first.");
+            }
+            headers["Authorization"] = `Bearer ${token}`;
+        }
+        const url = `${this.baseUrl}${opts.path}`;
+        let response;
+        const timeoutMs = 30_000; // 30s request timeout
+        try {
+            response = await fetch(url, {
+                method: opts.method,
+                headers,
+                body: opts.body !== undefined ? JSON.stringify(opts.body) : undefined,
+                signal: AbortSignal.timeout(timeoutMs),
+                redirect: "error", // Reject redirects — prevents HTTPS→HTTP credential leakage
+            });
+        }
+        catch (err) {
+            throw new NetworkError(err instanceof Error ? err.message : "Network request failed");
+        }
+        if (response.status === 429) {
+            // Auto-retry once on rate limit (cap wait at 10s to avoid client-side DoS)
+            const parsed = parseInt(response.headers.get("retry-after") ?? "5", 10);
+            const retryAfter = Number.isFinite(parsed) ? parsed : 5; // NaN guard
+            // Cancel body stream instead of buffering — prevents OOM from large 429 responses
+            await response.body?.cancel();
+            await new Promise((resolve) => setTimeout(resolve, addJitter(Math.min(retryAfter * 1000, 10_000))));
+            // Refresh token before retry in case it expired during the wait
+            if (opts.requiresAuth !== false) {
+                const freshToken = await this.tokenManager.getValidToken();
+                headers["Authorization"] = `Bearer ${freshToken}`;
+            }
+            try {
+                response = await fetch(url, {
+                    method: opts.method,
+                    headers,
+                    body: opts.body !== undefined ? JSON.stringify(opts.body) : undefined,
+                    signal: AbortSignal.timeout(timeoutMs),
+                    redirect: "error",
+                });
+            }
+            catch (err) {
+                throw new NetworkError(err instanceof Error ? err.message : "Network request failed");
+            }
+        }
+        if (response.status === 401 && opts.requiresAuth !== false) {
+            // Cancel body stream before retry to prevent memory leak from unconsumed response
+            await response.body?.cancel();
+            // Force a token refresh (don't reuse the rejected token) and retry once
+            try {
+                const newToken = await this.tokenManager.forceRefresh();
+                headers["Authorization"] = `Bearer ${newToken}`;
+                const retry = await fetch(url, {
+                    method: opts.method,
+                    headers,
+                    body: opts.body !== undefined ? JSON.stringify(opts.body) : undefined,
+                    signal: AbortSignal.timeout(timeoutMs),
+                    redirect: "error",
+                });
+                // Apply response size limit to 401 retry path too
+                const retryContentLength = parseInt(retry.headers.get("content-length") ?? "0", 10);
+                if (retryContentLength > MAX_RESPONSE_BYTES) {
+                    throw new ServerError("Response body too large");
+                }
+                const retryText = await retry.text();
+                if (retryText.length > MAX_RESPONSE_BYTES) {
+                    throw new ServerError("Response body exceeds size limit");
+                }
+                if (retry.ok) {
+                    return retryText ? safeJsonParse(retryText) : {};
+                }
+                throwForStatus(retry.status, retryText, retry.headers);
+            }
+            catch (err) {
+                if (err instanceof DominusNodeError)
+                    throw err;
+                // Refresh failed — fall through to original 401 handling
+            }
+        }
+        // Enforce response body size limit to prevent OOM
+        const contentLength = parseInt(response.headers.get("content-length") ?? "0", 10);
+        if (contentLength > MAX_RESPONSE_BYTES) {
+            throw new ServerError("Response body too large");
+        }
+        const responseText = await response.text();
+        if (responseText.length > MAX_RESPONSE_BYTES) {
+            throw new ServerError("Response body exceeds size limit");
+        }
+        if (!response.ok) {
+            throwForStatus(response.status, responseText, response.headers);
+        }
+        return responseText ? safeJsonParse(responseText) : {};
+    }
+    async get(path, requiresAuth = true) {
+        return this.request({ method: "GET", path, requiresAuth });
+    }
+    async post(path, body, requiresAuth = true) {
+        return this.request({ method: "POST", path, body, requiresAuth });
+    }
+    async put(path, body) {
+        return this.request({ method: "PUT", path, body });
+    }
+    async patch(path, body) {
+        return this.request({ method: "PATCH", path, body });
+    }
+    async delete(path) {
+        return this.request({ method: "DELETE", path });
+    }
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,30 @@
+export { DominusNodeClient } from "./client.js";
+export { AuthResource } from "./auth.js";
+export { KeysResource } from "./keys.js";
+export type { CreateKeyResponse, ListKeysResponse } from "./keys.js";
+export { WalletResource } from "./wallet.js";
+export type { WalletBalanceResponse, TransactionsResponse, StripeCheckoutResponse, CryptoInvoiceResponse, ForecastResponse, } from "./wallet.js";
+export { UsageResource } from "./usage.js";
+export type { DateRangeOptions as UsageDateRangeOptions, UsageSummary, UsageResponse, DailyUsageDay, DailyUsageResponse, TopHostEntry, TopHostsResponse, } from "./usage.js";
+export { PlansResource } from "./plans.js";
+export type { PlanEntry, ListPlansResponse, UserPlanResponse, ChangePlanResponse, } from "./plans.js";
+export { SessionsResource } from "./sessions.js";
+export type { ActiveSessionEntry, ActiveSessionsResponse } from "./sessions.js";
+export { ProxyResource } from "./proxy.js";
+export type { ProxyHealthResponse, ProxyStatusResponse } from "./proxy.js";
+export { AdminResource } from "./admin.js";
+export { SlotsResource } from "./slots.js";
+export { AgenticWalletResource } from "./resources/agent-wallet.js";
+export type { AgenticWallet, AgenticWalletTransaction, AgenticWalletListResponse, AgenticWalletFundResponse, AgenticWalletTransactionsResponse, AgenticWalletDeleteResponse, } from "./resources/agent-wallet.js";
+export { TeamsResource } from "./resources/teams.js";
+export type { Team, TeamMember, TeamInvite, TeamListResponse, TeamMembersResponse, TeamInvitesResponse, TeamKeysResponse, TeamKeyCreateResponse, TeamDeleteResponse, TeamFundResponse, TeamTransactionsResponse, } from "./resources/teams.js";
+export { X402Resource } from "./resources/x402.js";
+export type { X402Info, X402Facilitator, X402Pricing, } from "./resources/x402.js";
+export { WalletAuthResource } from "./resources/wallet-auth.js";
+export type { WalletChallenge, WalletVerifyResult, WalletLinkResult, } from "./resources/wallet-auth.js";
+export type { DateRangeOptions as AdminDateRangeOptions, ListUsersResponse, GetUserResponse, RevenueResponse, DailyRevenueEntry, DailyRevenueResponse, } from "./admin.js";
+export { HttpClient } from "./http.js";
+export type { HttpOptions } from "./http.js";
+export { DominusNodeError, AuthenticationError, AuthorizationError, RateLimitError, InsufficientBalanceError, ValidationError, NotFoundError, ConflictError, ServerError, NetworkError, ProxyError, } from "./errors.js";
+export type { DominusNodeConfig, User, ApiKey, Wallet, WalletTransaction, UsageRecord, TopHost, Plan, ActiveSession, ProxyUrlOptions, ProxyHealth, ProxyConfig, StripeCheckout, CryptoInvoice, AdminUser, RevenueStats, DailyRevenue, SystemStats, MfaStatus, MfaSetup, LoginResult, TokenPair, SlotsInfo, WaitlistJoinResult, WaitlistCount, } from "./types.js";
+export { SDK_VERSION, USER_AGENT, DEFAULT_BASE_URL, DEFAULT_PROXY_HOST, DEFAULT_HTTP_PROXY_PORT, DEFAULT_SOCKS5_PROXY_PORT, } from "./constants.js";

package/dist/esm/index.js

@@ -0,0 +1,23 @@
+// Main client
+export { DominusNodeClient } from "./client.js";
+// Resource modules
+export { AuthResource } from "./auth.js";
+export { KeysResource } from "./keys.js";
+export { WalletResource } from "./wallet.js";
+export { UsageResource } from "./usage.js";
+export { PlansResource } from "./plans.js";
+export { SessionsResource } from "./sessions.js";
+export { ProxyResource } from "./proxy.js";
+export { AdminResource } from "./admin.js";
+export { SlotsResource } from "./slots.js";
+export { AgenticWalletResource } from "./resources/agent-wallet.js";
+export { TeamsResource } from "./resources/teams.js";
+export { X402Resource } from "./resources/x402.js";
+export { WalletAuthResource } from "./resources/wallet-auth.js";
+// Infrastructure (HttpClient for advanced custom integrations)
+export { HttpClient } from "./http.js";
+// TokenManager is internal — not exported to prevent misuse of token lifecycle
+// Errors
+export { DominusNodeError, AuthenticationError, AuthorizationError, RateLimitError, InsufficientBalanceError, ValidationError, NotFoundError, ConflictError, ServerError, NetworkError, ProxyError, } from "./errors.js";
+// Constants
+export { SDK_VERSION, USER_AGENT, DEFAULT_BASE_URL, DEFAULT_PROXY_HOST, DEFAULT_HTTP_PROXY_PORT, DEFAULT_SOCKS5_PROXY_PORT, } from "./constants.js";

package/dist/esm/keys.d.ts

@@ -0,0 +1,27 @@
+import type { HttpClient } from "./http.js";
+export interface CreateKeyResponse {
+    key: string;
+    id: string;
+    prefix: string;
+    label: string;
+    created_at: string;
+}
+export interface ListKeysResponse {
+    keys: Array<{
+        id: string;
+        prefix: string;
+        label: string;
+        created_at: string;
+        revoked_at: string | null;
+    }>;
+}
+export declare class KeysResource {
+    private http;
+    constructor(http: HttpClient);
+    /** Create a new API key. The raw key is returned only once. */
+    create(label?: string): Promise<CreateKeyResponse>;
+    /** List all API keys for the authenticated user. */
+    list(): Promise<ListKeysResponse>;
+    /** Revoke an API key by its ID. */
+    revoke(id: string): Promise<void>;
+}

package/dist/esm/keys.js

@@ -0,0 +1,18 @@
+export class KeysResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    /** Create a new API key. The raw key is returned only once. */
+    async create(label) {
+        return this.http.post("/api/keys", { label: label ?? "Default" });
+    }
+    /** List all API keys for the authenticated user. */
+    async list() {
+        return this.http.get("/api/keys");
+    }
+    /** Revoke an API key by its ID. */
+    async revoke(id) {
+        await this.http.delete(`/api/keys/${encodeURIComponent(id)}`);
+    }
+}

package/dist/esm/plans.d.ts

@@ -0,0 +1,37 @@
+import type { HttpClient } from "./http.js";
+export interface PlanEntry {
+    id: string;
+    name: string;
+    pricePerGbCents: number;
+    pricePerGbUsd: number;
+    monthlyBandwidthBytes: number;
+    monthlyBandwidthGB: number | null;
+    isDefault: boolean;
+}
+export interface ListPlansResponse {
+    plans: PlanEntry[];
+}
+export interface UserPlanResponse {
+    plan: PlanEntry;
+    usage: {
+        monthlyUsageBytes: number;
+        monthlyUsageGB: number;
+        limitBytes: number;
+        limitGB: number | null;
+        percentUsed: number | null;
+    };
+}
+export interface ChangePlanResponse {
+    message: string;
+    plan: PlanEntry;
+}
+export declare class PlansResource {
+    private http;
+    constructor(http: HttpClient);
+    /** List all available plans (does not require authentication). */
+    list(): Promise<ListPlansResponse>;
+    /** Get the current user's plan and monthly usage. */
+    getUserPlan(): Promise<UserPlanResponse>;
+    /** Change the current user's plan. */
+    changePlan(planId: string): Promise<ChangePlanResponse>;
+}

package/dist/esm/plans.js

@@ -0,0 +1,18 @@
+export class PlansResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    /** List all available plans (does not require authentication). */
+    async list() {
+        return this.http.get("/api/plans", false);
+    }
+    /** Get the current user's plan and monthly usage. */
+    async getUserPlan() {
+        return this.http.get("/api/plans/user/plan");
+    }
+    /** Change the current user's plan. */
+    async changePlan(planId) {
+        return this.http.put("/api/plans/user/plan", { planId });
+    }
+}

package/dist/esm/proxy.d.ts

@@ -0,0 +1,62 @@
+import type { HttpClient } from "./http.js";
+import type { ProxyUrlOptions, ProxyConfig, DominusNodeConfig } from "./types.js";
+export interface ProxyHealthResponse {
+    status: string;
+    activeSessions: number;
+    uptimeSeconds: number;
+}
+export interface ProxyStatusResponse {
+    status: string;
+    activeSessions: number;
+    userActiveSessions: number;
+    avgLatencyMs: number;
+    providers: Array<{
+        name: string;
+        state: string;
+        consecutiveFailures: number;
+        totalRequests: number;
+        totalErrors: number;
+        avgLatencyMs: number;
+        fallbackOnly: boolean;
+    }>;
+    endpoints: {
+        http: string;
+        socks5: string;
+    };
+    supportedCountries: string[];
+    uptimeSeconds: number;
+}
+export declare class ProxyResource {
+    private http;
+    private proxyHost;
+    private httpPort;
+    private socks5Port;
+    constructor(http: HttpClient, config: DominusNodeConfig);
+    /**
+     * Build a proxy URL string for use with HTTP clients.
+     *
+     * The returned URL includes authentication via the username field.
+     * Geo-targeting and sticky sessions are encoded in the username portion
+     * following Dominus Node proxy conventions.
+     *
+     * @param apiKey - The API key to authenticate proxy requests.
+     * @param opts   - Optional targeting parameters (protocol, country, etc.).
+     * @returns A fully-formed proxy URL string.
+     *
+     * @example
+     * ```ts
+     * const url = client.proxy.buildUrl("dn_live_abc123");
+     * // => "http://user:dn_live_abc123@proxy.dominusnode.com:8080"
+     *
+     * const socksUrl = client.proxy.buildUrl("dn_live_abc123", { protocol: "socks5", country: "US" });
+     * // => "socks5://user-country-US:dn_live_abc123@proxy.dominusnode.com:1080"
+     * ```
+     */
+    buildUrl(apiKey: string, opts?: ProxyUrlOptions): string;
+    /** Get public proxy health status (does not require authentication). */
+    getHealth(): Promise<ProxyHealthResponse>;
+    /** Get detailed proxy status including provider info (requires authentication). */
+    getStatus(): Promise<ProxyStatusResponse>;
+    /** Get proxy server configuration (requires authentication). */
+    getConfig(): Promise<ProxyConfig>;
+}