@iteradian-rpc/sdk 1.1.1 → 1.2.0

package/dist/index.d.mts

@@ -1,3 +1,11 @@
+/** A number the API may send as a JSON number or as a numeric string. */
+type Numeric = number | string;
+/** An open string union: known values autocomplete, unknown ones still type-check. */
+type OpenString<T extends string> = T | (string & {});
+/** Plain `{ message }` acknowledgement. */
+interface MessageResponse {
+    message: string;
+}
 interface RegisterRequest {
     email: string;
     password: string;
@@ -13,7 +21,9 @@ interface RegisterRequest {
 interface LoginRequest {
     email: string;
     password: string;
+    /** Current 6-digit authenticator code, when two-factor auth is on. */
     twoFactorCode?: string;
+    /** One-time backup code, used instead of `twoFactorCode`. */
     backupCode?: string;
 }
 /**
@@ -25,78 +35,155 @@ interface RegisterResponse {
     message: string;
     email: string;
 }
+/** The signed-in user as returned with tokens. */
+interface AuthUser {
+    id: string;
+    email?: string;
+    personalOrgId?: string | null;
+    emailVerified?: boolean;
+    twoFactorEnabled?: boolean;
+    systemRole?: OpenString<"user" | "admin" | "super_admin">;
+    isIteradianMember?: boolean;
+}
+/**
+ * What login answers. With two-factor auth on and no code sent, the API
+ * answers `{ requires2FA: true }` and no tokens: check `requires2FA`, then
+ * log in again with `twoFactorCode` or `backupCode`.
+ */
+interface LoginResult {
+    accessToken?: string;
+    refreshToken?: string;
+    user?: AuthUser;
+    requires2FA?: boolean;
+}
+/** What refresh answers: both tokens are always present. */
 interface AuthTokens {
     accessToken: string;
     refreshToken: string;
-    user: User;
+    user?: AuthUser;
 }
 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 BackupCodes {
+    backupCodes: string[];
 }
+type User = AuthUser;
 interface Membership {
     id: string;
-    userId: string;
-    organizationId: string;
-    role: OrgRole;
-    joinedAt: string;
+    userId?: string;
+    organizationId?: string;
+    role?: OrgRole;
+    joinedAt?: string;
 }
 type OrgRole = "owner" | "admin" | "developer" | "viewer";
+type BillingInterval = "month" | "year";
+/** Request body of `organizations.create`. */
+interface CreateOrganizationRequest {
+    name: string;
+    /** Plan to start on, e.g. `"plan_free"`. */
+    planId: string;
+    /**
+     * The caller confirms the user ticked "I agree to the Terms of Service,
+     * Privacy Policy and DPA". The server requires the field.
+     */
+    acceptedTerms: boolean;
+    /** Lowercase letters, digits and hyphens, 2-50 characters. */
+    slug?: string;
+    billingInterval?: BillingInterval;
+}
+interface UpdateOrganizationRequest {
+    name?: string;
+    slug?: string;
+}
+interface OrgPlanSummary {
+    id: string;
+    name?: string;
+    tier?: string;
+    displayName?: string;
+    description?: string;
+    priceMonthly?: Numeric;
+    priceAnnual?: Numeric | null;
+    limits?: PlanLimits;
+    features?: string[];
+    isActive?: boolean;
+}
+interface OrgSubscriptionSummary {
+    id?: string;
+    organizationId?: string;
+    planId?: string;
+    plan?: OrgPlanSummary;
+    billingInterval?: string;
+    status?: string;
+    currentPeriodStart?: string;
+    currentPeriodEnd?: string;
+    cancelAtPeriodEnd?: boolean;
+    trialStart?: string | null;
+    trialEnd?: string | null;
+}
+/**
+ * An organization. Which fields are filled depends on the call: `list` adds
+ * `subscription` (summary), `get` adds `subscription` (full) and `members`,
+ * `create` adds `onboardingComplete`, `billingProvider`, `checkoutUrl` and
+ * `paddleCheckout`.
+ */
 interface Organization {
     id: string;
-    name: string;
-    slug: string;
-    createdAt: string;
-    updatedAt: string;
+    name?: string;
+    slug?: string;
+    avatarUrl?: string | null;
+    avatarUrlDark?: string | null;
+    role?: OrgRole;
+    onboardingCompletedAt?: string | null;
+    onboardingComplete?: boolean;
+    billingProvider?: string | null;
+    checkoutUrl?: string | null;
+    paddleCheckout?: unknown;
+    subscription?: OrgSubscriptionSummary;
+    members?: OrgMember[];
 }
 interface OrgMember {
     id: string;
-    userId: string;
-    email: string;
-    role: OrgRole;
-    joinedAt: string;
+    userId?: string;
+    email?: string;
+    avatarUrl?: string | null;
+    avatarUrlDark?: string | null;
+    role?: OrgRole;
+    joinedAt?: string;
+    userCreatedAt?: string;
 }
 /** An invitation to join an organization, as its owners/admins see it. */
 interface OrgInvite {
     id: string;
-    email: string;
-    role: OrgRole;
+    email?: string;
+    role?: OrgRole;
     /** "expired" invitations stay listed until revoked or re-sent. */
-    status: "pending" | "expired";
-    expiresAt: string;
-    createdAt: string;
+    status?: OpenString<"pending" | "expired">;
+    expiresAt?: string;
+    createdAt?: string;
     /** Email of the member who sent it. */
     invitedBy?: string | null;
 }
 /** An invitation addressed to the signed-in user. */
 interface MyInvite {
     id: string;
-    role: OrgRole;
-    expiresAt: string;
-    createdAt: string;
-    invitedBy: string | null;
-    organization: {
+    role?: OrgRole;
+    expiresAt?: string;
+    createdAt?: string;
+    invitedBy?: string | null;
+    organization?: {
         id: string;
-        name: string;
+        name?: string;
         avatarUrl?: string | null;
         avatarUrlDark?: string | null;
     };
 }
 interface MyInvites {
     /** Invitations can only be accepted once the user's email is verified. */
-    emailVerified: boolean;
+    emailVerified?: boolean;
     invites: MyInvite[];
 }
-/** The membership created by accepting an invitation. */
 /** Options for `organizations.acceptInvite`. */
 interface AcceptInviteOptions {
     /**
@@ -107,30 +194,32 @@ interface AcceptInviteOptions {
      */
     acceptedTerms?: boolean;
 }
+/** The membership created by accepting an invitation. */
 interface InviteAcceptance {
-    organizationId: string;
-    membershipId: string;
-    role: OrgRole;
+    organizationId?: string;
+    membershipId?: string;
+    role?: OrgRole;
 }
 interface UserPermissions {
-    role: OrgRole;
-    roleLabel: string;
-    roleDescription: string;
-    permissions: string[];
+    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;
+    name?: string;
+    prefix?: string;
+    environment?: OpenString<"live" | "test">;
+    status?: OpenString<"active" | "revoked">;
+    ipAllowlist?: string[];
+    allowedNetworks?: string[];
+    rateLimit?: number | null;
+    dailyLimit?: number | null;
+    expiresAt?: string | null;
+    walletUrlAuth?: boolean;
+    lastUsedAt?: string | null;
+    createdAt?: string;
     revokedAt?: string | null;
 }
 interface CreateApiKeyRequest {
@@ -141,6 +230,8 @@ interface CreateApiKeyRequest {
     rateLimit?: number;
     dailyLimit?: number;
     expiresAt?: string;
+    /** Allow the key as `?key=` in the RPC URL (wallets). Needs exactly one EVM network. */
+    walletUrlAuth?: boolean;
 }
 interface UpdateApiKeyRequest {
     name?: string;
@@ -150,72 +241,90 @@ interface UpdateApiKeyRequest {
     dailyLimit?: number | null;
     expiresAt?: string | null;
 }
+/** An API key as returned by create and rotate: the only time the secret is shown. */
 interface ApiKeyWithSecret extends ApiKey {
+    /** The full API key. Shown only once. */
+    secret: string;
+    /** @deprecated Same value as `secret`. Use `secret`. */
     key: string;
 }
 interface ApiKeyAnalytics {
-    keyId: string;
-    keyName: string;
-    keyPrefix: string;
-    period: {
-        from: string;
-        to: string;
-        days: number;
+    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;
+    totals?: {
+        requests?: Numeric;
+        errors?: Numeric;
+        throttled?: Numeric;
+        avgLatencyMs?: Numeric;
+        errorRate?: Numeric;
+        successRate?: Numeric;
     };
-    dailyData: {
-        date: string;
-        requests: number;
-        errors: number;
-        throttled: number;
-        avgLatencyMs: number;
+    dailyData?: {
+        date?: string;
+        requests?: Numeric;
+        errors?: Numeric;
+        throttled?: Numeric;
+        avgLatencyMs?: Numeric;
     }[];
+    peakDay?: {
+        date?: string;
+        requests?: Numeric;
+    } | null;
+    trends?: {
+        requests?: string;
+        errors?: string;
+        requestsPercent?: Numeric;
+        errorsPercent?: Numeric;
+    };
 }
-type EndpointRegion = "us_east" | "us_west" | "eu_west" | "eu_central" | "asia_east" | "asia_south";
+type EndpointRegion = "eu_central" | "us_east" | "us_central" | "us_west" | "uk" | "asia_southeast" | "asia_east" | "australia" | "india" | "eu_west" | "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;
+    type?: OpenString<NetworkType>;
+    environment?: string;
+    name?: string;
+    chainId?: number;
+    nativeCurrency?: string;
+    nativeCurrencyName?: string;
+    nativeCurrencyDecimals?: number;
+    blockExplorerUrl?: string | null;
+    iconUrl?: string | null;
+    isActive?: boolean;
+    createdAt?: string;
+    updatedAt?: string;
+    /** Only on the list call. */
+    availableNodes?: number;
 }
 interface Endpoint {
     id: string;
-    organizationId: string;
-    networkId: 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;
+    region?: OpenString<EndpointRegion>;
+    name?: string;
+    priority?: number;
+    status?: OpenString<EndpointStatus>;
+    isEnabled?: boolean;
+    rateLimitOverride?: number | null;
+    timeoutMs?: number;
+    retryCount?: number;
+    lastHealthCheck?: string | null;
+    healthCheckStatus?: string | null;
+    avgLatencyMs?: Numeric | null;
+    successRate?: Numeric | null;
+    totalRequests?: Numeric;
+    totalErrors?: Numeric;
+    uptime?: Numeric | null;
+    createdAt?: string;
+    updatedAt?: string;
 }
 interface CreateEndpointRequest {
     networkId: string;
@@ -230,185 +339,420 @@ interface UpdateEndpointRequest {
     name?: string;
     region?: EndpointRegion;
     priority?: number;
+    isEnabled?: boolean;
     timeoutMs?: number;
     retryCount?: number;
     rateLimitOverride?: number;
 }
+/** Answer of `POST .../health-check`. */
+interface EndpointHealthCheck {
+    status?: string;
+    latencyMs?: Numeric | null;
+    checkedAt?: string | null;
+}
+/** Answer of `GET .../health`. */
+interface EndpointHealth {
+    endpointId?: string;
+    name?: string;
+    network?: string;
+    region?: string;
+    status?: OpenString<"healthy" | "degraded" | "down" | "unknown">;
+    nodeCount?: number;
+    healthyNodeCount?: number;
+    latencyMs?: Numeric | null;
+    lastCheck?: string | null;
+    successRate?: Numeric | null;
+    uptime?: Numeric | null;
+    totalRequests?: Numeric;
+    totalErrors?: Numeric;
+}
+/** Answer of `GET .../endpoints/summary`. */
+interface EndpointSummary {
+    total?: number;
+    active?: number;
+    degraded?: number;
+    down?: number;
+    /** Endpoint count keyed by network name. */
+    byNetwork?: Record<string, number>;
+    /** Endpoint count keyed by region. */
+    byRegion?: Record<string, number>;
+    totalRequests?: Numeric;
+    avgLatencyMs?: Numeric;
+    avgSuccessRate?: Numeric;
+}
 interface EndpointMetric {
-    id: string;
-    endpointId: string;
-    timestamp: string;
-    requests: number;
-    errors: number;
-    avgLatencyMs: number;
-    p50LatencyMs?: number;
-    p95LatencyMs?: number;
-    p99LatencyMs?: number;
-    throttled: number;
+    id?: string;
+    endpointId?: string;
+    timestamp?: string;
+    requests?: Numeric;
+    errors?: Numeric;
+    avgLatencyMs?: Numeric;
+    p50LatencyMs?: Numeric;
+    p95LatencyMs?: Numeric;
+    p99LatencyMs?: Numeric;
+    throttled?: Numeric;
+}
+/** One row of `usage.get`: usage of one key on one day. */
+interface UsageRow {
+    date?: string;
+    requests?: Numeric;
+    errors?: Numeric;
+    avgLatencyMs?: Numeric;
+    throttled?: Numeric;
+    keyName?: string;
+    keyPrefix?: string;
 }
 interface UsageSummary {
-    totalRequests: number;
-    totalErrors: number;
-    avgLatencyMs: number;
-    byNetwork: UsageByNetwork[];
-    byRegion: UsageByRegion[];
-    byMethod: UsageByMethod[];
-    daily: DailyUsage[];
+    period?: {
+        from?: string;
+        to?: string;
+    };
+    totals?: {
+        requests?: Numeric;
+        errors?: Numeric;
+        throttled?: Numeric;
+        avgLatencyMs?: Numeric;
+        errorRate?: Numeric;
+    };
+    last7Days?: {
+        requests?: Numeric;
+        errors?: Numeric;
+    };
+    dailyAvgRequests?: Numeric;
+    byKey?: UsageByKey[];
+    dailyData?: DailyUsage[];
+    byNetwork?: UsageByNetwork[];
+    byRegion?: UsageByRegion[];
+    byMethod?: UsageByMethod[];
+    quotaForecast?: QuotaForecast;
+}
+interface UsageByKey {
+    keyId?: string;
+    keyName?: string;
+    keyPrefix?: string;
+    requests?: Numeric;
+    errors?: Numeric;
+    throttled?: Numeric;
 }
 interface UsageByNetwork {
-    networkId: string;
-    networkName: string;
-    networkType: string;
-    requests: number;
-    errors: number;
-    avgLatencyMs: number;
+    networkId?: string;
+    networkName?: string;
+    networkType?: string;
+    chainId?: number;
+    iconUrl?: string | null;
+    requests?: Numeric;
+    errors?: Numeric;
+    avgLatencyMs?: Numeric;
+    latencySum?: Numeric;
+    requestCount?: Numeric;
 }
 interface UsageByRegion {
-    region: string;
-    requests: number;
-    errors: number;
-    avgLatencyMs: number;
+    region?: string;
+    requests?: Numeric;
+    errors?: Numeric;
+    avgLatencyMs?: Numeric;
+    latencySum?: Numeric;
+    requestCount?: Numeric;
 }
 interface UsageByMethod {
-    method: string;
-    requests: number;
-    errors: number;
-    avgLatencyMs: number;
+    method?: string;
+    requests?: Numeric;
+    errors?: Numeric;
+    avgLatencyMs?: Numeric;
+    latencySum?: Numeric;
+    requestCount?: Numeric;
 }
 interface DailyUsage {
-    date: string;
-    requests: number;
-    errors: number;
-    avgLatencyMs: number;
+    date?: string;
+    requests?: Numeric;
+    errors?: Numeric;
+    throttled?: Numeric;
+    avgLatencyMs?: Numeric;
+}
+interface QuotaForecast {
+    hasQuota?: boolean;
+    unlimited?: boolean;
+    monthlyQuota?: Numeric;
+    usedThisMonth?: Numeric;
+    remainingQuota?: Numeric;
+    usagePercentage?: Numeric;
+    dailyAverage?: Numeric;
+    daysRemainingInMonth?: Numeric;
+    daysUntilExhaustion?: Numeric | null;
+    projectedUsage?: Numeric;
+    projectedPercentage?: Numeric;
+    status?: string;
 }
-interface DashboardData {
-    quickStats: QuickStats;
-    requestRate: DataPoint[];
-    errorRate: DataPoint[];
-}
-interface QuickStats {
-    totalRequests: number;
-    totalErrors: number;
-    avgLatencyMs: number;
-    successRate: number;
-    activeEndpoints: number;
+/**
+ * Dashboard time range. The API values are `last_hour`, `last_24_hours`
+ * (default), `last_7_days`, `last_30_days` and `custom` (needs `from` and
+ * `to`). The short forms `1h`, `24h`, `7d` and `30d` are translated.
+ */
+type DashboardTimeRange = "last_hour" | "last_24_hours" | "last_7_days" | "last_30_days" | "custom" | "1h" | "24h" | "7d" | "30d";
+/** ISO 8601 dates for `timeRange: "custom"`. */
+interface CustomRange {
+    from?: string;
+    to?: string;
 }
 interface DataPoint {
-    timestamp: string;
-    value: number;
+    timestamp?: string;
+    value?: Numeric;
+}
+interface ServiceStatus {
+    status?: string;
+    latency?: Numeric;
 }
+interface EndpointHealthEntry {
+    endpoint?: string;
+    status?: string;
+    latency?: Numeric;
+    uptime?: Numeric;
+    lastCheck?: string | null;
+}
+/** Answer of `dashboard.getHealth` (also `DashboardData.health`). */
 interface HealthStatus {
-    status: "healthy" | "degraded" | "down";
-    endpoints: {
-        id: string;
-        name: string;
-        status: string;
+    overallStatus?: string;
+    database?: ServiceStatus;
+    redis?: ServiceStatus;
+    endpoints?: EndpointHealthEntry[];
+    timestamp?: string;
+}
+interface QuickStats {
+    totalRequests?: Numeric;
+    totalErrors?: Numeric;
+    avgLatency?: Numeric;
+    activeKeys?: Numeric;
+    quotaUsed?: Numeric;
+    quotaLimit?: Numeric;
+    quotaPercentage?: Numeric;
+    quotaPeriodStart?: string;
+    quotaPeriodEnd?: string;
+    quotaUnmetered?: boolean;
+    quotaMode?: string;
+    quotaLabel?: string | null;
+    overageEnabled?: boolean;
+    overageRatePer1k?: Numeric;
+    overageRequests?: Numeric;
+    overageCapUsd?: Numeric;
+    hardLimitRequests?: Numeric;
+}
+interface RequestRate {
+    currentRate?: Numeric;
+    avgRate?: Numeric;
+    peakRate?: Numeric;
+    totalRequests?: Numeric;
+    trend?: string;
+    trendPercent?: Numeric;
+    timeSeries?: DataPoint[];
+}
+interface ErrorRate {
+    currentErrorRate?: Numeric;
+    avgErrorRate?: Numeric;
+    totalErrors?: Numeric;
+    trend?: string;
+    trendPercent?: Numeric;
+    timeSeries?: DataPoint[];
+    topErrors?: {
+        code?: string;
+        count?: Numeric;
+        percentage?: Numeric;
     }[];
 }
-type AlertSeverity = "info" | "warning" | "critical";
+interface LatencyStats {
+    currentLatency?: Numeric;
+    avgLatency?: Numeric;
+    p50?: Numeric;
+    p95?: Numeric;
+    p99?: Numeric;
+    trend?: string;
+    trendPercent?: Numeric;
+    timeSeries?: DataPoint[];
+}
+/** Answer of `dashboard.getPerformance`. Sub-objects vary, so they are loosely typed. */
+interface PerformanceStats {
+    latency?: LatencyStats;
+    cache?: Record<string, unknown>;
+    saturation?: Record<string, unknown>;
+    failover?: Record<string, unknown>;
+    timestamp?: string;
+}
+interface DashboardData {
+    health?: HealthStatus;
+    quickStats?: QuickStats;
+    requestRate?: RequestRate;
+    errorRate?: ErrorRate;
+    latency?: LatencyStats;
+    alerts?: {
+        alerts?: Alert[];
+        unacknowledgedCount?: Numeric;
+        criticalCount?: Numeric;
+    };
+}
+type AlertSeverity = "info" | "warning" | "error" | "critical";
 type AlertStatus = "active" | "acknowledged" | "resolved";
-type AlertMetric = "error_rate" | "latency" | "request_count" | "uptime";
-type AlertCondition = "greater_than" | "less_than" | "equals";
+type AlertRuleType = "high_error_rate" | "high_latency" | "rate_limit_exceeded" | "quota_warning" | "service_down" | "key_expiring" | "unusual_traffic";
+type AlertChannelType = "email" | "webhook" | "slack";
 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;
+    ruleId?: string;
+    ruleName?: string;
+    type?: OpenString<AlertRuleType>;
+    severity?: OpenString<AlertSeverity>;
+    status?: OpenString<AlertStatus>;
+    title?: string;
+    message?: string;
+    metadata?: Record<string, unknown> | null;
+    firedAt?: string;
+    acknowledgedAt?: string | null;
+    resolvedAt?: string | null;
+}
+/**
+ * What `GET .../alerts` answers. `alerts.list` returns only the `alerts`
+ * array of it; the counters are available through `alerts.overview`.
+ */
+interface AlertsOverview {
+    alerts: Alert[];
+    total?: number;
+    activeCount?: number;
+    acknowledgedCount?: number;
+    criticalCount?: number;
+    rules?: AlertRule[];
+    channels?: AlertChannel[];
 }
 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;
+    name?: string;
+    type?: OpenString<AlertRuleType>;
+    severity?: OpenString<AlertSeverity>;
+    isEnabled?: boolean;
+    /** Rule settings; the keys depend on `type`, e.g. `{ threshold: 5 }`. */
+    config?: Record<string, unknown>;
+    cooldownSeconds?: number;
+    createdAt?: string;
+    updatedAt?: string;
 }
 interface CreateAlertRuleRequest {
     name: string;
-    description?: string;
-    metric: AlertMetric;
-    condition: AlertCondition;
-    threshold: number;
-    severity: AlertSeverity;
-    cooldownMinutes?: number;
+    type: AlertRuleType;
+    config: Record<string, unknown>;
+    severity?: AlertSeverity;
+    /** At least 60. */
+    cooldownSeconds?: number;
+    isEnabled?: boolean;
+}
+/** Update body: `type` cannot be changed. */
+interface UpdateAlertRuleRequest {
+    name?: string;
+    config?: Record<string, unknown>;
+    severity?: AlertSeverity;
+    cooldownSeconds?: number;
+    isEnabled?: boolean;
 }
 interface AlertChannel {
     id: string;
-    organizationId: string;
-    type: "email" | "webhook" | "slack";
-    name: string;
-    config: Record<string, unknown>;
-    isEnabled: boolean;
-    createdAt: string;
+    name?: string;
+    type?: OpenString<AlertChannelType>;
+    isEnabled?: boolean;
+    /** email: `{ recipients }`, webhook: `{ url, secret? }`, slack: `{ webhookUrl }`. */
+    config?: Record<string, unknown>;
+    createdAt?: string;
+    updatedAt?: string;
 }
 interface CreateAlertChannelRequest {
-    type: "email" | "webhook" | "slack";
     name: string;
+    type: AlertChannelType;
     config: Record<string, unknown>;
+    isEnabled?: boolean;
+}
+/** Update body: `type` cannot be changed. */
+interface UpdateAlertChannelRequest {
+    name?: string;
+    config?: Record<string, unknown>;
+    isEnabled?: boolean;
+}
+interface TestChannelResult {
+    success?: boolean;
+    message?: string;
 }
 type LogStatus = "success" | "error" | "timeout" | "throttled";
 interface RequestLog {
     id: string;
-    organizationId: string;
-    apiKeyId?: string;
-    apiKeyPrefix?: string;
-    method: 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;
+    region?: string | null;
+    status?: OpenString<LogStatus>;
+    statusCode?: number | null;
+    latencyMs?: Numeric;
+    responseSize?: Numeric | null;
+    errorCode?: string | null;
+    errorMessage?: string | null;
+    apiKeyId?: string | null;
+    apiKeyPrefix?: string | null;
+    ipAddress?: string | null;
+    userAgent?: string | null;
+    requestBody?: unknown;
+    responseBody?: unknown;
+    timestamp?: string;
+}
+interface LogStats {
+    totalRequests?: Numeric;
+    successCount?: Numeric;
+    errorCount?: Numeric;
+    timeoutCount?: Numeric;
+    throttledCount?: Numeric;
+    avgLatencyMs?: Numeric;
+    p50LatencyMs?: Numeric;
+    p95LatencyMs?: Numeric;
+    p99LatencyMs?: Numeric;
+    /** Percentage, 0-100. */
+    errorRate?: Numeric;
+    topMethods?: {
+        method?: string;
+        count?: Numeric;
+    }[];
+    topErrors?: {
+        errorCode?: string;
+        count?: Numeric;
+        message?: string;
+    }[];
+    statusBreakdown?: {
+        status?: string;
+        count?: Numeric;
+    }[];
 }
 interface LogsResponse {
     logs: RequestLog[];
-    total: number;
-    page: number;
-    pageSize: number;
-    totalPages: number;
+    total?: number;
+    stats?: LogStats;
 }
 interface LogFilterOptions {
-    methods: string[];
-    networks: string[];
-    regions: string[];
-    apiKeys: {
+    methods?: string[];
+    networks?: string[];
+    regions?: string[];
+    apiKeys?: {
         id: string;
-        name: string;
-        prefix: string;
+        name?: string;
+        prefix?: string;
     }[];
 }
 interface LogQueryParams {
-    page?: number;
-    pageSize?: number;
+    /** 1-200. */
+    limit?: number;
+    offset?: number;
     status?: LogStatus;
     method?: string;
+    apiKeyId?: string;
     network?: string;
     region?: string;
-    apiKeyId?: string;
     search?: string;
+    statusCode?: number;
+    minLatencyMs?: number;
+    maxLatencyMs?: number;
+    /** ISO 8601 date. */
     from?: string;
+    /** ISO 8601 date. */
     to?: string;
-    minLatency?: number;
-    maxLatency?: number;
     sortBy?: "timestamp" | "latencyMs" | "statusCode";
     sortOrder?: "asc" | "desc";
 }
@@ -420,34 +764,85 @@ interface ChangePlanOptions {
      */
     acceptedTerms: boolean;
 }
+interface SubscriptionPlan {
+    id: string;
+    name?: string;
+    displayName?: string;
+    price?: Numeric;
+    priceMonthly?: Numeric;
+    priceAnnual?: Numeric | null;
+    limits?: PlanLimits;
+    features?: string[];
+}
 interface Subscription {
     id: string;
-    organizationId: string;
-    planId: string;
-    status: "active" | "cancelled" | "past_due" | "trialing";
-    currentPeriodStart: string;
-    currentPeriodEnd: string;
-    cancelAtPeriodEnd: boolean;
-    plan: Plan;
+    plan?: SubscriptionPlan;
+    status?: OpenString<"active" | "cancelled" | "past_due" | "trialing">;
+    billingInterval?: string;
+    currentPeriodStart?: string;
+    currentPeriodEnd?: string;
+    usagePeriod?: {
+        start?: string;
+        end?: string;
+    };
+    cancelAtPeriodEnd?: boolean;
+    trialStart?: string | null;
+    trialEnd?: string | null;
+    recentInvoices?: Invoice[];
+}
+/** Answer of `subscriptions.changePlan`. */
+interface ChangePlanResult {
+    message?: string;
+    subscription?: {
+        id: string;
+        plan?: {
+            id: string;
+            name?: string;
+            displayName?: string;
+            price?: Numeric;
+        };
+        billingInterval?: string;
+        status?: string;
+    };
+}
+/** Answer of `subscriptions.cancel`. */
+interface CancelSubscriptionResult {
+    message?: string;
+    cancelAt?: string;
+    accessEndsAt?: string;
+    pendingOverageEstimate?: Numeric;
+    currency?: string;
 }
 interface Plan {
     id: string;
-    name: string;
-    slug: string;
-    price: number;
-    currency: string;
-    interval: "month" | "year";
-    features: Record<string, unknown>;
-    limits: PlanLimits;
-    isActive: boolean;
+    name?: string;
+    tier?: string;
+    displayName?: string;
+    description?: string;
+    priceMonthly?: Numeric;
+    priceAnnual?: Numeric | null;
+    stripePriceId?: string | null;
+    stripePriceIdAnnual?: string | null;
+    paddlePriceId?: string | null;
+    paddlePriceIdAnnual?: string | null;
+    contactSalesOnly?: boolean;
+    limits?: PlanLimits;
+    features?: string[];
+    isActive?: boolean;
+    annualAvailable?: boolean;
+    createdAt?: string;
+    updatedAt?: string;
 }
 interface PlanLimits {
-    requestsPerMonth: number;
-    requestsPerSecond: number;
-    apiKeys: number;
-    endpoints: number;
-    teamMembers: number;
-    logRetentionDays: number;
+    rps?: Numeric;
+    burst?: Numeric;
+    concurrency?: Numeric;
+    monthlyRequests?: Numeric;
+    overageEnabled?: boolean;
+    overageRatePer1k?: Numeric;
+    overageCapUsd?: Numeric;
+    overageRequestsAllowed?: Numeric;
+    dedicated?: boolean;
     /**
      * Limits sold as something other than a plain number, keyed by the API's
      * limit name (`rps`, `concurrency`, `maxApiKeys`, `monthlyRequests`,
@@ -465,39 +860,70 @@ type PlanLimitMode = "unlimited" | "custom";
 type PlanLimitKey = "rps" | "concurrency" | "maxApiKeys" | "monthlyRequests" | "overageRatePer1k" | "overageCapUsd";
 interface Invoice {
     id: string;
-    amount: number;
-    currency: string;
-    status: string;
-    periodStart: string;
-    periodEnd: string;
-    paidAt?: string;
-    createdAt: string;
+    amount?: Numeric;
+    currency?: string;
+    status?: string;
+    periodStart?: string;
+    periodEnd?: string;
+    paidAt?: string | null;
+    createdAt?: string;
 }
 type TicketPriority = "low" | "medium" | "high" | "urgent";
-type TicketStatus = "open" | "in_progress" | "waiting" | "resolved" | "closed";
-type TicketCategory = "billing" | "technical" | "account" | "feature_request" | "other";
+type TicketStatus = "open" | "in_progress" | "waiting_on_customer" | "resolved" | "closed";
+type TicketCategory = "general" | "billing" | "technical" | "api_keys" | "endpoints" | "performance" | "security" | "feature_request" | "bug_report";
+interface TicketAuthor {
+    id: string;
+    email?: string;
+}
+interface TicketMessage {
+    id: string;
+    ticketId?: string;
+    authorId?: string;
+    body?: string;
+    isStaff?: boolean;
+    createdAt?: string;
+    author?: TicketAuthor;
+}
 interface SupportTicket {
     id: string;
-    organizationId: string;
-    subject: string;
-    category: TicketCategory;
-    priority: TicketPriority;
-    status: TicketStatus;
-    createdAt: string;
-    updatedAt: string;
+    organizationId?: string;
+    createdById?: string;
+    assignedToId?: string | null;
+    subject?: string;
+    category?: OpenString<TicketCategory>;
+    priority?: OpenString<TicketPriority>;
+    status?: OpenString<TicketStatus>;
+    closedAt?: string | null;
+    createdAt?: string;
+    updatedAt?: string;
+    createdBy?: TicketAuthor;
+    /** On create and get only. */
+    messages?: TicketMessage[];
+    /** On list and status update only. */
+    _count?: {
+        messages?: number;
+    };
 }
 interface CreateTicketRequest {
+    /** 5-200 characters. */
     subject: string;
-    message: string;
-    category: TicketCategory;
-    priority: TicketPriority;
-}
-interface TicketMessage {
-    id: string;
-    ticketId: string;
-    content: string;
-    isStaff: boolean;
-    createdAt: string;
+    /** The first message, 10-5000 characters. */
+    body: string;
+    category?: TicketCategory;
+    priority?: TicketPriority;
+}
+interface TicketStats {
+    open?: number;
+    inProgress?: number;
+    waitingOnCustomer?: number;
+    resolved?: number;
+    closed?: number;
+    total?: number;
+}
+/** What `GET .../support/tickets` answers; `support.listTickets` returns only `tickets`. */
+interface TicketList {
+    tickets: SupportTicket[];
+    total?: number;
 }
 interface IteradianConfig {
     /** Base URL of the Iteradian control-plane API (default: https://api.iteradian.com/api/v1) */
@@ -639,36 +1065,40 @@ declare class AuthResource {
      * has ticked the agreement.
      */
     register(data: RegisterRequest): Promise<RegisterResponse>;
-    /** Login with email/password (optionally with 2FA code) */
-    login(data: LoginRequest): Promise<AuthTokens>;
+    /**
+     * Login with email/password (optionally with a 2FA code or a backup code).
+     *
+     * When two-factor auth is on and no code was sent, the API answers
+     * `{ requires2FA: true }` with no tokens. Check `requires2FA` and call
+     * again with `twoFactorCode` or `backupCode`. The stored access token is
+     * only replaced when the answer carries one.
+     */
+    login(data: LoginRequest): Promise<LoginResult>;
+    private storeToken;
     /** Logout current session */
     logout(): Promise<void>;
     /** Refresh the access token */
     refresh(refreshToken: string): Promise<AuthTokens>;
     /** Verify email with token */
-    verifyEmail(token: string): Promise<void>;
+    verifyEmail(token: string): Promise<MessageResponse>;
     /** Resend email verification */
-    resendVerification(email: string): Promise<void>;
+    resendVerification(email: string): Promise<MessageResponse>;
     /** Request password reset email */
-    forgotPassword(email: string): Promise<void>;
+    forgotPassword(email: string): Promise<MessageResponse>;
     /** Reset password with token */
-    resetPassword(token: string, newPassword: string): Promise<void>;
+    resetPassword(token: string, newPassword: string): Promise<MessageResponse>;
     /** Request a magic login link */
-    requestMagicLink(email: string): Promise<void>;
+    requestMagicLink(email: string): Promise<MessageResponse>;
     /** Login via magic link token */
-    loginWithMagicLink(token: string): Promise<AuthTokens>;
+    loginWithMagicLink(token: string): Promise<LoginResult>;
     /** 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[];
-    }>;
+    verify2FA(code: string): Promise<BackupCodes>;
     /** Disable 2FA */
-    disable2FA(password: string, code: string): Promise<void>;
+    disable2FA(password: string, code: string): Promise<MessageResponse>;
     /** Regenerate backup codes */
-    regenerateBackupCodes(password: string): Promise<{
-        backupCodes: string[];
-    }>;
+    regenerateBackupCodes(password: string): Promise<BackupCodes>;
 }
 
 declare class OrganizationsResource {
@@ -676,22 +1106,20 @@ declare class OrganizationsResource {
     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>;
+    /**
+     * Create a new organization. `name`, `planId` and `acceptedTerms` are
+     * required by the API; pass `acceptedTerms: true` only after the user
+     * agreed to the terms.
+     */
+    create(data: CreateOrganizationRequest): Promise<Organization>;
     /** Get organization details */
     get(orgId: string): Promise<Organization>;
     /** Update an organization */
-    update(orgId: string, data: {
-        name?: string;
-        slug?: string;
-    }): Promise<Organization>;
+    update(orgId: string, data: UpdateOrganizationRequest): Promise<Organization>;
     /** Delete an organization */
-    delete(orgId: string): Promise<void>;
+    delete(orgId: string): Promise<MessageResponse | void>;
     /** Leave an organization */
-    leave(orgId: string): Promise<void>;
+    leave(orgId: string): Promise<MessageResponse | void>;
     /** List organization members */
     listMembers(orgId: string): Promise<OrgMember[]>;
     /**
@@ -701,14 +1129,12 @@ declare class OrganizationsResource {
      */
     inviteMember(orgId: string, data: {
         email: string;
-        role: string;
+        role: OrgRole;
     }): Promise<OrgInvite>;
     /** Open invitations of the organization (owner/admin) */
     listInvites(orgId: string): Promise<OrgInvite[]>;
     /** Revoke an open invitation (owner/admin) */
-    revokeInvite(orgId: string, inviteId: string): Promise<{
-        message: string;
-    }>;
+    revokeInvite(orgId: string, inviteId: string): Promise<MessageResponse>;
     /** Invitations addressed to the signed-in user */
     listMyInvites(): Promise<MyInvites>;
     /**
@@ -722,13 +1148,11 @@ declare class OrganizationsResource {
      */
     acceptInvite(inviteId: string, options?: AcceptInviteOptions): Promise<InviteAcceptance>;
     /** Decline an invitation addressed to the signed-in user */
-    declineInvite(inviteId: string): Promise<{
-        message: string;
-    }>;
+    declineInvite(inviteId: string): Promise<MessageResponse>;
     /** Update a member's role */
-    updateMemberRole(orgId: string, memberId: string, role: string): Promise<OrgMember>;
+    updateMemberRole(orgId: string, memberId: string, role: OrgRole): Promise<OrgMember>;
     /** Remove a member from the organization */
-    removeMember(orgId: string, memberId: string): Promise<void>;
+    removeMember(orgId: string, memberId: string): Promise<MessageResponse | void>;
     /** Get current user's permissions in the organization */
     getMyPermissions(orgId: string): Promise<UserPermissions>;
 }
@@ -740,13 +1164,19 @@ declare class ApiKeysResource {
     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 a new API key. The full key comes back once, in `secret`
+     * (`key` is a deprecated alias with the same value).
+     */
     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) */
+    revoke(orgId: string, keyId: string): Promise<MessageResponse>;
+    /**
+     * Rotate an API key (revoke old, create new). The new full key is in
+     * `secret`; `key` is a deprecated alias.
+     */
     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>;
@@ -768,32 +1198,34 @@ declare class EndpointsResource {
     /** Update an endpoint */
     update(orgId: string, endpointId: string, data: UpdateEndpointRequest): Promise<Endpoint>;
     /** Delete an endpoint */
-    delete(orgId: string, endpointId: string): Promise<void>;
+    delete(orgId: string, endpointId: string): Promise<MessageResponse>;
     /** 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;
-    }>;
+    /** Trigger a health check (POST .../health-check) */
+    checkHealth(orgId: string, endpointId: string): Promise<EndpointHealthCheck>;
+    /** Get the current health of an endpoint (GET .../health) */
+    getHealth(orgId: string, endpointId: string): Promise<EndpointHealth>;
     /** Get endpoint health summary */
-    getHealthOverview(orgId: string): Promise<unknown>;
+    getHealthOverview(orgId: string): Promise<EndpointSummary>;
     /** 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>;
+    }[]): Promise<MessageResponse>;
 }
 
 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 rows (one per key per day) for a date range. `from` and `to`
+     * are ISO dates, e.g. `2026-01-31`.
+     */
+    get(orgId: string, from: string, to: string): Promise<UsageRow[]>;
     /** Get usage summary */
     getSummary(orgId: string): Promise<UsageSummary>;
 }
@@ -802,32 +1234,38 @@ declare class DashboardResource {
     private http;
     constructor(http: HttpClient);
     /** Get full dashboard data */
-    get(orgId: string, period?: string): Promise<DashboardData>;
+    get(orgId: string, timeRange?: DashboardTimeRange, custom?: CustomRange): Promise<DashboardData>;
     /** Get system health overview */
     getHealth(orgId: string): Promise<HealthStatus>;
     /** Get quick stats */
-    getQuickStats(orgId: string, period?: string): Promise<QuickStats>;
+    getQuickStats(orgId: string, timeRange?: DashboardTimeRange, custom?: CustomRange): Promise<QuickStats>;
     /** Get request rate time series */
-    getRequestRate(orgId: string, period?: string): Promise<DataPoint[]>;
+    getRequestRate(orgId: string, timeRange?: DashboardTimeRange, custom?: CustomRange): Promise<RequestRate>;
     /** Get error rate time series */
-    getErrorRate(orgId: string, period?: string): Promise<DataPoint[]>;
+    getErrorRate(orgId: string, timeRange?: DashboardTimeRange, custom?: CustomRange): Promise<ErrorRate>;
     /** Get latency metrics */
-    getLatency(orgId: string, period?: string): Promise<DataPoint[]>;
+    getLatency(orgId: string, timeRange?: DashboardTimeRange, custom?: CustomRange): Promise<LatencyStats>;
     /** Get performance metrics */
-    getPerformance(orgId: string): Promise<unknown>;
+    getPerformance(orgId: string): Promise<PerformanceStats>;
 }
 
 declare class AlertsResource {
     private http;
     constructor(http: HttpClient);
-    /** List alerts for an organization */
+    /**
+     * List alerts for an organization. The API answers an overview object
+     * (`alerts`, counters, rules, channels); this returns just the alerts.
+     * Use `overview()` for the rest.
+     */
     list(orgId: string): Promise<Alert[]>;
+    /** The full alerts overview: alerts, counters, rules and channels. */
+    overview(orgId: string): Promise<AlertsOverview>;
     /** 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>;
+    evaluate(orgId: string): Promise<MessageResponse>;
     /** List alert rules */
     listRules(orgId: string): Promise<AlertRule[]>;
     /** Create a new alert rule */
@@ -835,13 +1273,13 @@ declare class AlertsResource {
     /** 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>;
+    updateRule(orgId: string, ruleId: string, data: UpdateAlertRuleRequest): 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[]>;
+    seedDefaults(orgId: string): Promise<MessageResponse>;
     /** List notification channels */
     listChannels(orgId: string): Promise<AlertChannel[]>;
     /** Create a notification channel */
@@ -849,22 +1287,22 @@ declare class AlertsResource {
     /** 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>;
+    updateChannel(orgId: string, channelId: string, data: UpdateAlertChannelRequest): Promise<AlertChannel>;
     /** Delete a notification channel */
     deleteChannel(orgId: string, channelId: string): Promise<void>;
     /** Test a notification channel */
-    testChannel(orgId: string, channelId: string): Promise<void>;
+    testChannel(orgId: string, channelId: string): Promise<TestChannelResult>;
 }
 
 declare class LogsResource {
     private http;
     constructor(http: HttpClient);
-    /** Query request logs with filters and pagination */
+    /** Query request logs with filters (`limit` / `offset` paginate) */
     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>;
+    getStats(orgId: string): Promise<LogStats>;
     /** Get available filter options */
     getFilterOptions(orgId: string): Promise<LogFilterOptions>;
 }
@@ -882,11 +1320,11 @@ declare class SubscriptionsResource {
      * always sent. Pass `{ acceptedTerms: true }` only after the user has
      * accepted the terms.
      */
-    changePlan(orgId: string, planId: string, options: ChangePlanOptions): Promise<Subscription>;
+    changePlan(orgId: string, planId: string, options: ChangePlanOptions): Promise<ChangePlanResult>;
     /** Cancel subscription */
-    cancel(orgId: string): Promise<Subscription>;
+    cancel(orgId: string): Promise<CancelSubscriptionResult>;
     /** Reactivate a cancelled subscription */
-    reactivate(orgId: string): Promise<Subscription>;
+    reactivate(orgId: string): Promise<MessageResponse>;
     /** Get invoices */
     getInvoices(orgId: string, limit?: number): Promise<Invoice[]>;
 }
@@ -905,16 +1343,21 @@ declare class SupportResource {
     constructor(http: HttpClient);
     /** Create a support ticket */
     createTicket(orgId: string, data: CreateTicketRequest): Promise<SupportTicket>;
-    /** List support tickets */
+    /**
+     * List support tickets. The API answers `{ tickets, total }`; this
+     * returns the tickets. Use `listTicketsWithTotal()` for the total.
+     */
     listTickets(orgId: string): Promise<SupportTicket[]>;
+    /** List support tickets with the total count. */
+    listTicketsWithTotal(orgId: string): Promise<TicketList>;
     /** Get ticket statistics */
-    getStats(orgId: string): Promise<unknown>;
+    getStats(orgId: string): Promise<TicketStats>;
     /** 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>;
+    updateStatus(orgId: string, ticketId: string, status: TicketStatus): Promise<SupportTicket>;
 }
 
 declare class RpcResource {
@@ -1031,4 +1474,4 @@ declare class IteradianClient {
 }
 
 export { AlertsResource, ApiKeysResource, AuthResource, DashboardResource, EndpointsResource, IteradianClient, IteradianError, LogsResource, OrganizationsResource, PlansResource, RpcResource, SubscriptionsResource, SupportResource, UsageResource };
-export type { AcceptInviteOptions, Alert, AlertChannel, AlertCondition, AlertMetric, AlertRule, AlertSeverity, AlertStatus, ApiError, ApiKey, ApiKeyAnalytics, ApiKeyWithSecret, ApiResponse, AuthTokens, ChangePlanOptions, CreateAlertChannelRequest, CreateAlertRuleRequest, CreateApiKeyRequest, CreateEndpointRequest, CreateTicketRequest, DailyUsage, DashboardData, DataPoint, Endpoint, EndpointMetric, EndpointRegion, EndpointStatus, HealthStatus, InviteAcceptance, Invoice, IteradianConfig, JsonRpcError, JsonRpcRequest, JsonRpcResponse, LogFilterOptions, LogQueryParams, LogStatus, LoginRequest, LogsResponse, Membership, MyInvite, MyInvites, Network, NetworkType, OrgInvite, OrgMember, OrgRole, Organization, PaginatedResponse, Plan, PlanLimitKey, PlanLimitMode, PlanLimits, QuickStats, RegisterRequest, RegisterResponse, RequestLog, Subscription, SupportTicket, TicketCategory, TicketMessage, TicketPriority, TicketStatus, TwoFASetup, UpdateApiKeyRequest, UpdateEndpointRequest, UsageByMethod, UsageByNetwork, UsageByRegion, UsageSummary, User, UserPermissions };
+export type { AcceptInviteOptions, Alert, AlertChannel, AlertChannelType, AlertRule, AlertRuleType, AlertSeverity, AlertStatus, AlertsOverview, ApiError, ApiKey, ApiKeyAnalytics, ApiKeyWithSecret, ApiResponse, AuthTokens, AuthUser, BackupCodes, BillingInterval, CancelSubscriptionResult, ChangePlanOptions, ChangePlanResult, CreateAlertChannelRequest, CreateAlertRuleRequest, CreateApiKeyRequest, CreateEndpointRequest, CreateOrganizationRequest, CreateTicketRequest, CustomRange, DailyUsage, DashboardData, DashboardTimeRange, DataPoint, Endpoint, EndpointHealth, EndpointHealthCheck, EndpointHealthEntry, EndpointMetric, EndpointRegion, EndpointStatus, EndpointSummary, ErrorRate, HealthStatus, InviteAcceptance, Invoice, IteradianConfig, JsonRpcError, JsonRpcRequest, JsonRpcResponse, LatencyStats, LogFilterOptions, LogQueryParams, LogStats, LogStatus, LoginRequest, LoginResult, LogsResponse, Membership, MessageResponse, MyInvite, MyInvites, Network, NetworkType, Numeric, OpenString, OrgInvite, OrgMember, OrgPlanSummary, OrgRole, OrgSubscriptionSummary, Organization, PaginatedResponse, PerformanceStats, Plan, PlanLimitKey, PlanLimitMode, PlanLimits, QuickStats, QuotaForecast, RegisterRequest, RegisterResponse, RequestLog, RequestRate, ServiceStatus, Subscription, SubscriptionPlan, SupportTicket, TestChannelResult, TicketAuthor, TicketCategory, TicketList, TicketMessage, TicketPriority, TicketStats, TicketStatus, TwoFASetup, UpdateAlertChannelRequest, UpdateAlertRuleRequest, UpdateApiKeyRequest, UpdateEndpointRequest, UpdateOrganizationRequest, UsageByKey, UsageByMethod, UsageByNetwork, UsageByRegion, UsageRow, UsageSummary, User, UserPermissions };