@iteradian-rpc/sdk 1.0.1

package/dist/index.d.mts

@@ -0,0 +1,893 @@
+interface RegisterRequest {
+    email: string;
+    password: string;
+    organizationName?: string;
+}
+interface LoginRequest {
+    email: string;
+    password: string;
+    twoFactorCode?: string;
+    backupCode?: string;
+}
+interface AuthTokens {
+    accessToken: string;
+    refreshToken: string;
+    user: User;
+}
+interface TwoFASetup {
+    secret: string;
+    qrCode: string;
+}
+interface User {
+    id: string;
+    email: string;
+    emailVerified: boolean;
+    systemRole: "user" | "admin" | "super_admin";
+    twoFactorEnabled: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+interface Membership {
+    id: string;
+    userId: string;
+    organizationId: string;
+    role: OrgRole;
+    joinedAt: string;
+}
+type OrgRole = "owner" | "admin" | "developer" | "viewer";
+interface Organization {
+    id: string;
+    name: string;
+    slug: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface OrgMember {
+    id: string;
+    userId: string;
+    email: string;
+    role: OrgRole;
+    joinedAt: string;
+}
+interface UserPermissions {
+    role: OrgRole;
+    roleLabel: string;
+    roleDescription: string;
+    permissions: string[];
+}
+interface ApiKey {
+    id: string;
+    name: string;
+    prefix: string;
+    environment: "live" | "test";
+    status: "active" | "revoked";
+    ipAllowlist: string[];
+    allowedNetworks: string[];
+    rateLimit: number | null;
+    dailyLimit: number | null;
+    expiresAt: string | null;
+    lastUsedAt: string | null;
+    createdAt: string;
+    revokedAt?: string | null;
+}
+interface CreateApiKeyRequest {
+    name: string;
+    environment: "live" | "test";
+    ipAllowlist?: string[];
+    allowedNetworks?: string[];
+    rateLimit?: number;
+    dailyLimit?: number;
+    expiresAt?: string;
+}
+interface UpdateApiKeyRequest {
+    name?: string;
+    ipAllowlist?: string[];
+    allowedNetworks?: string[];
+    rateLimit?: number | null;
+    dailyLimit?: number | null;
+    expiresAt?: string | null;
+}
+interface ApiKeyWithSecret extends ApiKey {
+    key: string;
+}
+interface ApiKeyAnalytics {
+    keyId: string;
+    keyName: string;
+    keyPrefix: string;
+    period: {
+        from: string;
+        to: string;
+        days: number;
+    };
+    totals: {
+        requests: number;
+        errors: number;
+        throttled: number;
+        avgLatencyMs: number;
+        errorRate: number;
+        successRate: number;
+    };
+    dailyData: {
+        date: string;
+        requests: number;
+        errors: number;
+        throttled: number;
+        avgLatencyMs: number;
+    }[];
+}
+type EndpointRegion = "us_east" | "us_west" | "eu_west" | "eu_central" | "asia_east" | "asia_south";
+type EndpointStatus = "active" | "degraded" | "down" | "maintenance";
+type NetworkType = "mainnet" | "testnet";
+interface Network {
+    id: string;
+    slug: string;
+    name: string;
+    chainId: number;
+    type: NetworkType;
+    environment: string;
+    rpcUrl?: string;
+    wsUrl?: string;
+    explorerUrl?: string;
+    iconUrl?: string;
+    isActive: boolean;
+}
+interface Endpoint {
+    id: string;
+    organizationId: string;
+    networkId: string;
+    network?: Network;
+    region: EndpointRegion;
+    name: string;
+    priority: number;
+    status: EndpointStatus;
+    isEnabled: boolean;
+    rateLimitOverride?: number;
+    timeoutMs: number;
+    retryCount: number;
+    lastHealthCheck?: string;
+    healthCheckStatus?: EndpointStatus;
+    avgLatencyMs?: number;
+    successRate?: number;
+    totalRequests?: number;
+    totalErrors?: number;
+    uptime?: number;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateEndpointRequest {
+    networkId: string;
+    region: EndpointRegion;
+    name: string;
+    priority?: number;
+    timeoutMs?: number;
+    retryCount?: number;
+    rateLimitOverride?: number;
+}
+interface UpdateEndpointRequest {
+    name?: string;
+    region?: EndpointRegion;
+    priority?: number;
+    timeoutMs?: number;
+    retryCount?: number;
+    rateLimitOverride?: number;
+}
+interface EndpointMetric {
+    id: string;
+    endpointId: string;
+    timestamp: string;
+    requests: number;
+    errors: number;
+    avgLatencyMs: number;
+    p50LatencyMs?: number;
+    p95LatencyMs?: number;
+    p99LatencyMs?: number;
+    throttled: number;
+}
+interface UsageSummary {
+    totalRequests: number;
+    totalErrors: number;
+    avgLatencyMs: number;
+    byNetwork: UsageByNetwork[];
+    byRegion: UsageByRegion[];
+    byMethod: UsageByMethod[];
+    daily: DailyUsage[];
+}
+interface UsageByNetwork {
+    networkId: string;
+    networkName: string;
+    networkType: string;
+    requests: number;
+    errors: number;
+    avgLatencyMs: number;
+}
+interface UsageByRegion {
+    region: string;
+    requests: number;
+    errors: number;
+    avgLatencyMs: number;
+}
+interface UsageByMethod {
+    method: string;
+    requests: number;
+    errors: number;
+    avgLatencyMs: number;
+}
+interface DailyUsage {
+    date: string;
+    requests: number;
+    errors: number;
+    avgLatencyMs: number;
+}
+interface DashboardData {
+    quickStats: QuickStats;
+    requestRate: DataPoint[];
+    errorRate: DataPoint[];
+}
+interface QuickStats {
+    totalRequests: number;
+    totalErrors: number;
+    avgLatencyMs: number;
+    successRate: number;
+    activeEndpoints: number;
+}
+interface DataPoint {
+    timestamp: string;
+    value: number;
+}
+interface HealthStatus {
+    status: "healthy" | "degraded" | "down";
+    endpoints: {
+        id: string;
+        name: string;
+        status: string;
+    }[];
+}
+type AlertSeverity = "info" | "warning" | "critical";
+type AlertStatus = "active" | "acknowledged" | "resolved";
+type AlertMetric = "error_rate" | "latency" | "request_count" | "uptime";
+type AlertCondition = "greater_than" | "less_than" | "equals";
+interface Alert {
+    id: string;
+    organizationId: string;
+    ruleId: string;
+    severity: AlertSeverity;
+    status: AlertStatus;
+    title: string;
+    message: string;
+    metadata?: Record<string, unknown>;
+    acknowledgedAt?: string;
+    resolvedAt?: string;
+    createdAt: string;
+}
+interface AlertRule {
+    id: string;
+    organizationId: string;
+    name: string;
+    description?: string;
+    metric: AlertMetric;
+    condition: AlertCondition;
+    threshold: number;
+    severity: AlertSeverity;
+    isEnabled: boolean;
+    cooldownMinutes: number;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateAlertRuleRequest {
+    name: string;
+    description?: string;
+    metric: AlertMetric;
+    condition: AlertCondition;
+    threshold: number;
+    severity: AlertSeverity;
+    cooldownMinutes?: number;
+}
+interface AlertChannel {
+    id: string;
+    organizationId: string;
+    type: "email" | "webhook" | "slack";
+    name: string;
+    config: Record<string, unknown>;
+    isEnabled: boolean;
+    createdAt: string;
+}
+interface CreateAlertChannelRequest {
+    type: "email" | "webhook" | "slack";
+    name: string;
+    config: Record<string, unknown>;
+}
+type LogStatus = "success" | "error" | "timeout" | "throttled";
+interface RequestLog {
+    id: string;
+    organizationId: string;
+    apiKeyId?: string;
+    apiKeyPrefix?: string;
+    method: string;
+    path?: string;
+    network?: string;
+    region?: string;
+    status: LogStatus;
+    statusCode?: number;
+    latencyMs?: number;
+    requestBody?: string;
+    responseBody?: string;
+    errorMessage?: string;
+    ipAddress?: string;
+    userAgent?: string;
+    timestamp: string;
+}
+interface LogsResponse {
+    logs: RequestLog[];
+    total: number;
+    page: number;
+    pageSize: number;
+    totalPages: number;
+}
+interface LogFilterOptions {
+    methods: string[];
+    networks: string[];
+    regions: string[];
+    apiKeys: {
+        id: string;
+        name: string;
+        prefix: string;
+    }[];
+}
+interface LogQueryParams {
+    page?: number;
+    pageSize?: number;
+    status?: LogStatus;
+    method?: string;
+    network?: string;
+    region?: string;
+    apiKeyId?: string;
+    search?: string;
+    from?: string;
+    to?: string;
+    minLatency?: number;
+    maxLatency?: number;
+    sortBy?: "timestamp" | "latencyMs" | "statusCode";
+    sortOrder?: "asc" | "desc";
+}
+interface Subscription {
+    id: string;
+    organizationId: string;
+    planId: string;
+    status: "active" | "cancelled" | "past_due" | "trialing";
+    currentPeriodStart: string;
+    currentPeriodEnd: string;
+    cancelAtPeriodEnd: boolean;
+    plan: Plan;
+}
+interface Plan {
+    id: string;
+    name: string;
+    slug: string;
+    price: number;
+    currency: string;
+    interval: "month" | "year";
+    features: Record<string, unknown>;
+    limits: PlanLimits;
+    isActive: boolean;
+}
+interface PlanLimits {
+    requestsPerMonth: number;
+    requestsPerSecond: number;
+    apiKeys: number;
+    endpoints: number;
+    teamMembers: number;
+    logRetentionDays: number;
+}
+interface Invoice {
+    id: string;
+    amount: number;
+    currency: string;
+    status: string;
+    periodStart: string;
+    periodEnd: string;
+    paidAt?: string;
+    createdAt: string;
+}
+type TicketPriority = "low" | "medium" | "high" | "urgent";
+type TicketStatus = "open" | "in_progress" | "waiting" | "resolved" | "closed";
+type TicketCategory = "billing" | "technical" | "account" | "feature_request" | "other";
+interface SupportTicket {
+    id: string;
+    organizationId: string;
+    subject: string;
+    category: TicketCategory;
+    priority: TicketPriority;
+    status: TicketStatus;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateTicketRequest {
+    subject: string;
+    message: string;
+    category: TicketCategory;
+    priority: TicketPriority;
+}
+interface TicketMessage {
+    id: string;
+    ticketId: string;
+    content: string;
+    isStaff: boolean;
+    createdAt: string;
+}
+interface IteradianConfig {
+    /** Base URL of the Iteradian control-plane API (default: https://api.iteradian.com/api/v1) */
+    baseUrl?: string;
+    /**
+     * Base URL of the RPC gateway (default: https://rpc.iteradian.com).
+     *
+     * The gateway is deliberately NOT under the control plane's /api/v1 prefix —
+     * it serves `POST /rpc/v1/{network}` at the host root. Sending RPC through
+     * `baseUrl` produces `/api/v1/rpc/v1/{network}`, which 404s.
+     */
+    gatewayUrl?: string;
+    /** Bearer access token for authentication */
+    accessToken?: string;
+    /** API key for authentication (alternative to accessToken) */
+    apiKey?: string;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Custom headers to include with every request */
+    headers?: Record<string, string>;
+    /** Retry failed requests (default: true) */
+    retry?: boolean;
+    /** Maximum number of retries (default: 3) */
+    maxRetries?: number;
+}
+interface ApiResponse<T> {
+    data: T;
+    status: number;
+    headers: Record<string, string>;
+}
+interface ApiError {
+    message: string;
+    statusCode: number;
+    error?: string;
+}
+interface PaginatedResponse<T> {
+    data: T[];
+    total: number;
+    page: number;
+    pageSize: number;
+    totalPages: number;
+}
+interface JsonRpcRequest {
+    jsonrpc: "2.0";
+    method: string;
+    params?: unknown[];
+    id: string | number;
+}
+interface JsonRpcResponse {
+    jsonrpc: "2.0";
+    id: string | number | null;
+    result?: unknown;
+    error?: JsonRpcError;
+}
+interface JsonRpcError {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+
+declare class IteradianError extends Error {
+    readonly statusCode: number;
+    readonly error?: string;
+    /**
+     * JSON-RPC error code from the gateway, when the failure came from there.
+     *
+     *   -32005  rate limit or concurrency limit exceeded (retry shortly)
+     *   -32006  monthly quota exhausted (retrying will not help until `resetsAt`)
+     *   -32007  overage spend limit reached (same — needs a plan change)
+     */
+    readonly rpcCode?: number;
+    /** Seconds to wait before retrying, when the gateway supplied one. */
+    readonly retryAfter?: number;
+    /** The gateway's `error.data` payload, e.g. `{quota, used, resetsAt}`. */
+    readonly data?: Record<string, unknown>;
+    constructor(message: string, statusCode: number, error?: string, rpc?: {
+        code?: number;
+        retryAfter?: number;
+        data?: Record<string, unknown>;
+    });
+    /** True when the request failed because the subscription is out of allowance. */
+    get isQuotaExhausted(): boolean;
+    /** True when the request was throttled and is worth retrying. */
+    get isRateLimited(): boolean;
+}
+declare class HttpClient {
+    private baseUrl;
+    private gatewayUrl;
+    private accessToken?;
+    private apiKey?;
+    private timeout;
+    private customHeaders;
+    private retry;
+    private maxRetries;
+    constructor(config: IteradianConfig);
+    setAccessToken(token: string): void;
+    clearAccessToken(): void;
+    private buildHeaders;
+    private request;
+    get<T>(path: string): Promise<T>;
+    post<T>(path: string, body?: unknown): Promise<T>;
+    put<T>(path: string, body?: unknown): Promise<T>;
+    patch<T>(path: string, body?: unknown): Promise<T>;
+    /**
+     * Call the RPC gateway rather than the control plane.
+     *
+     * Separate base URL because the gateway is not under `/api/v1`: it serves
+     * `POST /rpc/v1/{network}` at the host root.
+     */
+    gateway<T>(path: string, body?: unknown, signal?: AbortSignal): Promise<T>;
+    gatewayGet<T>(path: string, signal?: AbortSignal): Promise<T>;
+    delete<T>(path: string, body?: unknown): Promise<T>;
+}
+
+declare class AuthResource {
+    private http;
+    constructor(http: HttpClient);
+    /** Register a new user account */
+    register(data: RegisterRequest): Promise<AuthTokens>;
+    /** Login with email/password (optionally with 2FA code) */
+    login(data: LoginRequest): Promise<AuthTokens>;
+    /** Logout current session */
+    logout(): Promise<void>;
+    /** Refresh the access token */
+    refresh(refreshToken: string): Promise<AuthTokens>;
+    /** Verify email with token */
+    verifyEmail(token: string): Promise<void>;
+    /** Resend email verification */
+    resendVerification(email: string): Promise<void>;
+    /** Request password reset email */
+    forgotPassword(email: string): Promise<void>;
+    /** Reset password with token */
+    resetPassword(token: string, newPassword: string): Promise<void>;
+    /** Request a magic login link */
+    requestMagicLink(email: string): Promise<void>;
+    /** Login via magic link token */
+    loginWithMagicLink(token: string): Promise<AuthTokens>;
+    /** Enable 2FA – returns QR code image and secret */
+    enable2FA(password: string): Promise<TwoFASetup>;
+    /** Verify 2FA setup with code from authenticator app */
+    verify2FA(code: string): Promise<{
+        backupCodes: string[];
+    }>;
+    /** Disable 2FA */
+    disable2FA(password: string, code: string): Promise<void>;
+    /** Regenerate backup codes */
+    regenerateBackupCodes(password: string): Promise<{
+        backupCodes: string[];
+    }>;
+}
+
+declare class OrganizationsResource {
+    private http;
+    constructor(http: HttpClient);
+    /** List organizations the current user belongs to */
+    list(): Promise<Organization[]>;
+    /** Create a new organization */
+    create(data: {
+        name: string;
+        slug?: string;
+    }): Promise<Organization>;
+    /** Get organization details */
+    get(orgId: string): Promise<Organization>;
+    /** Update an organization */
+    update(orgId: string, data: {
+        name?: string;
+        slug?: string;
+    }): Promise<Organization>;
+    /** Delete an organization */
+    delete(orgId: string): Promise<void>;
+    /** Leave an organization */
+    leave(orgId: string): Promise<void>;
+    /** List organization members */
+    listMembers(orgId: string): Promise<OrgMember[]>;
+    /** Invite a member to the organization */
+    inviteMember(orgId: string, data: {
+        email: string;
+        role: string;
+    }): Promise<OrgMember>;
+    /** Update a member's role */
+    updateMemberRole(orgId: string, memberId: string, role: string): Promise<OrgMember>;
+    /** Remove a member from the organization */
+    removeMember(orgId: string, memberId: string): Promise<void>;
+    /** Get current user's permissions in the organization */
+    getMyPermissions(orgId: string): Promise<UserPermissions>;
+}
+
+declare class ApiKeysResource {
+    private http;
+    constructor(http: HttpClient);
+    /** List all API keys for an organization */
+    list(orgId: string): Promise<ApiKey[]>;
+    /** Get a specific API key */
+    get(orgId: string, keyId: string): Promise<ApiKey>;
+    /** Create a new API key (returns the full key only once) */
+    create(orgId: string, data: CreateApiKeyRequest): Promise<ApiKeyWithSecret>;
+    /** Update an API key */
+    update(orgId: string, keyId: string, data: UpdateApiKeyRequest): Promise<ApiKey>;
+    /** Revoke (delete) an API key */
+    revoke(orgId: string, keyId: string): Promise<void>;
+    /** Rotate an API key (revoke old, create new) */
+    rotate(orgId: string, keyId: string): Promise<ApiKeyWithSecret>;
+    /** Get analytics for an API key */
+    getAnalytics(orgId: string, keyId: string, timeRange?: "1d" | "7d" | "30d" | "90d"): Promise<ApiKeyAnalytics>;
+}
+
+declare class EndpointsResource {
+    private http;
+    constructor(http: HttpClient);
+    /** List all available networks */
+    getNetworks(): Promise<Network[]>;
+    /** Get a specific network */
+    getNetwork(networkId: string): Promise<Network>;
+    /** List all endpoints for an organization */
+    list(orgId: string): Promise<Endpoint[]>;
+    /** Get a specific endpoint */
+    get(orgId: string, endpointId: string): Promise<Endpoint>;
+    /** Create a new endpoint */
+    create(orgId: string, data: CreateEndpointRequest): Promise<Endpoint>;
+    /** Update an endpoint */
+    update(orgId: string, endpointId: string, data: UpdateEndpointRequest): Promise<Endpoint>;
+    /** Delete an endpoint */
+    delete(orgId: string, endpointId: string): Promise<void>;
+    /** Pause an endpoint */
+    pause(orgId: string, endpointId: string): Promise<Endpoint>;
+    /** Resume an endpoint */
+    resume(orgId: string, endpointId: string): Promise<Endpoint>;
+    /** Trigger a health check */
+    checkHealth(orgId: string, endpointId: string): Promise<{
+        status: EndpointStatus;
+        latencyMs?: number;
+    }>;
+    /** Get endpoint health summary */
+    getHealthOverview(orgId: string): Promise<unknown>;
+    /** Get endpoint metrics */
+    getMetrics(orgId: string, endpointId: string, from?: string, to?: string): Promise<EndpointMetric[]>;
+    /** Update endpoint priorities */
+    updatePriorities(orgId: string, priorities: {
+        id: string;
+        priority: number;
+    }[]): Promise<void>;
+}
+
+declare class UsageResource {
+    private http;
+    constructor(http: HttpClient);
+    /** Get usage analytics for a date range */
+    get(orgId: string, from: string, to: string): Promise<UsageSummary>;
+    /** Get usage summary */
+    getSummary(orgId: string): Promise<UsageSummary>;
+}
+
+declare class DashboardResource {
+    private http;
+    constructor(http: HttpClient);
+    /** Get full dashboard data */
+    get(orgId: string, period?: string): Promise<DashboardData>;
+    /** Get system health overview */
+    getHealth(orgId: string): Promise<HealthStatus>;
+    /** Get quick stats */
+    getQuickStats(orgId: string, period?: string): Promise<QuickStats>;
+    /** Get request rate time series */
+    getRequestRate(orgId: string, period?: string): Promise<DataPoint[]>;
+    /** Get error rate time series */
+    getErrorRate(orgId: string, period?: string): Promise<DataPoint[]>;
+    /** Get latency metrics */
+    getLatency(orgId: string, period?: string): Promise<DataPoint[]>;
+    /** Get performance metrics */
+    getPerformance(orgId: string): Promise<unknown>;
+}
+
+declare class AlertsResource {
+    private http;
+    constructor(http: HttpClient);
+    /** List alerts for an organization */
+    list(orgId: string): Promise<Alert[]>;
+    /** Acknowledge an alert */
+    acknowledge(orgId: string, alertId: string): Promise<Alert>;
+    /** Resolve an alert */
+    resolve(orgId: string, alertId: string): Promise<Alert>;
+    /** Evaluate all alert rules now */
+    evaluate(orgId: string): Promise<void>;
+    /** List alert rules */
+    listRules(orgId: string): Promise<AlertRule[]>;
+    /** Create a new alert rule */
+    createRule(orgId: string, data: CreateAlertRuleRequest): Promise<AlertRule>;
+    /** Get a specific alert rule */
+    getRule(orgId: string, ruleId: string): Promise<AlertRule>;
+    /** Update an alert rule */
+    updateRule(orgId: string, ruleId: string, data: Partial<CreateAlertRuleRequest>): Promise<AlertRule>;
+    /** Delete an alert rule */
+    deleteRule(orgId: string, ruleId: string): Promise<void>;
+    /** Toggle an alert rule on/off */
+    toggleRule(orgId: string, ruleId: string): Promise<AlertRule>;
+    /** Seed default alert rules */
+    seedDefaults(orgId: string): Promise<AlertRule[]>;
+    /** List notification channels */
+    listChannels(orgId: string): Promise<AlertChannel[]>;
+    /** Create a notification channel */
+    createChannel(orgId: string, data: CreateAlertChannelRequest): Promise<AlertChannel>;
+    /** Get a specific channel */
+    getChannel(orgId: string, channelId: string): Promise<AlertChannel>;
+    /** Update a notification channel */
+    updateChannel(orgId: string, channelId: string, data: Partial<CreateAlertChannelRequest>): Promise<AlertChannel>;
+    /** Delete a notification channel */
+    deleteChannel(orgId: string, channelId: string): Promise<void>;
+    /** Test a notification channel */
+    testChannel(orgId: string, channelId: string): Promise<void>;
+}
+
+declare class LogsResource {
+    private http;
+    constructor(http: HttpClient);
+    /** Query request logs with filters and pagination */
+    query(orgId: string, params?: LogQueryParams): Promise<LogsResponse>;
+    /** Get a single log entry */
+    get(orgId: string, logId: string): Promise<RequestLog>;
+    /** Get log statistics */
+    getStats(orgId: string): Promise<unknown>;
+    /** Get available filter options */
+    getFilterOptions(orgId: string): Promise<LogFilterOptions>;
+}
+
+declare class SubscriptionsResource {
+    private http;
+    constructor(http: HttpClient);
+    /** Get current subscription */
+    get(orgId: string): Promise<Subscription>;
+    /** Change subscription plan */
+    changePlan(orgId: string, planId: string): Promise<Subscription>;
+    /** Cancel subscription */
+    cancel(orgId: string): Promise<Subscription>;
+    /** Reactivate a cancelled subscription */
+    reactivate(orgId: string): Promise<Subscription>;
+    /** Get invoices */
+    getInvoices(orgId: string, limit?: number): Promise<Invoice[]>;
+}
+
+declare class PlansResource {
+    private http;
+    constructor(http: HttpClient);
+    /** List all available plans */
+    list(): Promise<Plan[]>;
+    /** Get a specific plan */
+    get(planId: string): Promise<Plan>;
+}
+
+declare class SupportResource {
+    private http;
+    constructor(http: HttpClient);
+    /** Create a support ticket */
+    createTicket(orgId: string, data: CreateTicketRequest): Promise<SupportTicket>;
+    /** List support tickets */
+    listTickets(orgId: string): Promise<SupportTicket[]>;
+    /** Get ticket statistics */
+    getStats(orgId: string): Promise<unknown>;
+    /** Get a specific ticket */
+    getTicket(orgId: string, ticketId: string): Promise<SupportTicket>;
+    /** Add a message to a ticket */
+    addMessage(orgId: string, ticketId: string, content: string): Promise<TicketMessage>;
+    /** Update ticket status */
+    updateStatus(orgId: string, ticketId: string, status: string): Promise<SupportTicket>;
+}
+
+declare class RpcResource {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * Send a JSON-RPC 2.0 request to the specified network via the Iteradian gateway.
+     *
+     * @example
+     * ```ts
+     * const result = await client.rpc.call('eth-mainnet', {
+     *   jsonrpc: '2.0',
+     *   method: 'eth_blockNumber',
+     *   params: [],
+     *   id: 1,
+     * });
+     * ```
+     */
+    call(network: string, request: JsonRpcRequest, options?: {
+        signal?: AbortSignal;
+    }): Promise<JsonRpcResponse>;
+    /**
+     * Send a batch of JSON-RPC 2.0 requests to the specified network.
+     *
+     * A batch of N calls costs N against both your per-second rate limit and
+     * your monthly request quota — it is a transport optimisation, not a
+     * billing one.
+     *
+     * @example
+     * ```ts
+     * const results = await client.rpc.batch('eth-mainnet', [
+     *   { jsonrpc: '2.0', method: 'eth_blockNumber', params: [], id: 1 },
+     *   { jsonrpc: '2.0', method: 'net_peerCount', params: [], id: 2 },
+     * ]);
+     * ```
+     */
+    batch(network: string, requests: JsonRpcRequest[], options?: {
+        signal?: AbortSignal;
+    }): Promise<JsonRpcResponse[]>;
+    /**
+     * List the networks the gateway can currently route to.
+     *
+     * Only networks with at least one healthy node are advertised.
+     */
+    networks(): Promise<{
+        networks: Array<{
+            slug: string;
+            aliases: string[];
+            name: string;
+            type: string;
+            environment: string;
+        }>;
+        usage?: string;
+        example?: unknown;
+    }>;
+}
+
+/**
+ * Iteradian Control Plane SDK Client
+ *
+ * @example
+ * ```typescript
+ * import { IteradianClient } from '@iteradian/sdk';
+ *
+ * const client = new IteradianClient({
+ *   baseUrl: 'https://api.iteradian.com/api/v1',
+ *   accessToken: 'your-access-token',
+ * });
+ *
+ * // Login
+ * const tokens = await client.auth.login({ email: 'user@example.com', password: 'pass' });
+ *
+ * // List organizations
+ * const orgs = await client.organizations.list();
+ *
+ * // Create an API key
+ * const key = await client.apiKeys.create(orgId, { name: 'My Key', environment: 'live' });
+ *
+ * // Query logs
+ * const logs = await client.logs.query(orgId, { status: 'error', pageSize: 50 });
+ * ```
+ */
+declare class IteradianClient {
+    private readonly http;
+    /** Authentication (register, login, 2FA, password reset) */
+    readonly auth: AuthResource;
+    /** Organization management */
+    readonly organizations: OrganizationsResource;
+    /** API key management */
+    readonly apiKeys: ApiKeysResource;
+    /** Endpoint & network management */
+    readonly endpoints: EndpointsResource;
+    /** Usage analytics */
+    readonly usage: UsageResource;
+    /** Dashboard stats & time series */
+    readonly dashboard: DashboardResource;
+    /** Alerts, rules, and notification channels */
+    readonly alerts: AlertsResource;
+    /** Request log querying */
+    readonly logs: LogsResource;
+    /** Subscription & billing */
+    readonly subscriptions: SubscriptionsResource;
+    /** Plan catalog */
+    readonly plans: PlansResource;
+    /** Support tickets */
+    readonly support: SupportResource;
+    /** JSON-RPC gateway (blockchain calls) */
+    readonly rpc: RpcResource;
+    constructor(config?: IteradianConfig);
+    /** Set the access token for all subsequent requests */
+    setAccessToken(token: string): void;
+    /** Clear the access token */
+    clearAccessToken(): void;
+}
+
+export { type Alert, type AlertChannel, type AlertCondition, type AlertMetric, type AlertRule, type AlertSeverity, type AlertStatus, AlertsResource, type ApiError, type ApiKey, type ApiKeyAnalytics, type ApiKeyWithSecret, ApiKeysResource, type ApiResponse, AuthResource, type AuthTokens, type CreateAlertChannelRequest, type CreateAlertRuleRequest, type CreateApiKeyRequest, type CreateEndpointRequest, type CreateTicketRequest, type DailyUsage, type DashboardData, DashboardResource, type DataPoint, type Endpoint, type EndpointMetric, type EndpointRegion, type EndpointStatus, EndpointsResource, type HealthStatus, type Invoice, IteradianClient, type IteradianConfig, IteradianError, type JsonRpcError, type JsonRpcRequest, type JsonRpcResponse, type LogFilterOptions, type LogQueryParams, type LogStatus, type LoginRequest, LogsResource, type LogsResponse, type Membership, type Network, type NetworkType, type OrgMember, type OrgRole, type Organization, OrganizationsResource, type PaginatedResponse, type Plan, type PlanLimits, PlansResource, type QuickStats, type RegisterRequest, type RequestLog, RpcResource, type Subscription, SubscriptionsResource, SupportResource, type SupportTicket, type TicketCategory, type TicketMessage, type TicketPriority, type TicketStatus, type TwoFASetup, type UpdateApiKeyRequest, type UpdateEndpointRequest, type UsageByMethod, type UsageByNetwork, type UsageByRegion, UsageResource, type UsageSummary, type User, type UserPermissions };