@iteradian-rpc/sdk 1.0.1 → 1.2.0

package/dist/index.d.ts

@@ -1,73 +1,225 @@
+/** 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;
+    /**
+     * The caller confirms the user agreed to the Terms of Service, Privacy
+     * Policy and DPA (https://iteradian.com/terms, /privacy, /dpa). Always
+     * sent; the server rejects registration (400) unless this is `true`.
+     */
+    acceptedTerms: boolean;
+    /** @deprecated Ignored by the API. */
     organizationName?: string;
 }
 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;
 }
+/**
+ * What `POST /auth/register` answers — whether or not the address already has
+ * an account (so it cannot be used to probe for accounts). No session is
+ * created: the user confirms their address from the email, then logs in.
+ */
+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;
+    /** "expired" invitations stay listed until revoked or re-sent. */
+    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?: {
+        id: 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;
+    invites: MyInvite[];
+}
+/** Options for `organizations.acceptInvite`. */
+interface AcceptInviteOptions {
+    /**
+     * The caller confirms the user agreed to the current Terms of Service,
+     * Privacy Policy and DPA. Only needed when the user has not accepted the
+     * current terms version yet; without it the API answers 403
+     * `TERMS_ACCEPTANCE_REQUIRED`. Sent only when given.
+     */
+    acceptedTerms?: boolean;
+}
+/** The membership created by accepting an invitation. */
+interface InviteAcceptance {
+    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 {
@@ -78,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;
@@ -87,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;
@@ -167,252 +339,591 @@ 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;
-}
-interface DashboardData {
-    quickStats: QuickStats;
-    requestRate: DataPoint[];
-    errorRate: DataPoint[];
+    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 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";
 }
+/** Options for `subscriptions.changePlan`. */
+interface ChangePlanOptions {
+    /**
+     * The caller confirms the user accepted the plan-change billing terms.
+     * The server rejects the change (400) unless this is `true`.
+     */
+    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`,
+     * `overageRatePer1k`, `overageCapUsd`). `"unlimited"`: not enforced per
+     * plan. `"custom"`: negotiated per contract. Such a limit carries no number.
+     * Absent on plans where every limit is a number.
+     */
+    limitModes?: Partial<Record<PlanLimitKey, PlanLimitMode>>;
+    /** Display text for those limits, e.g. "Quoted per contract". */
+    limitLabels?: Partial<Record<PlanLimitKey, string>>;
+}
+/** How a plan limit is sold. Absent from `limitModes` means a plain number. */
+type PlanLimitMode = "unlimited" | "custom";
+/** Limit names that may appear in `PlanLimits.limitModes`. */
+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) */
@@ -482,6 +993,8 @@ declare class IteradianError extends Error {
      *   -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)
+     *   -32008  per-API-key daily limit reached (no retry until `data.resetsAt`,
+     *           the next 00:00 UTC)
      */
     readonly rpcCode?: number;
     /** Seconds to wait before retrying, when the gateway supplied one. */
@@ -493,8 +1006,18 @@ declare class IteradianError extends Error {
         retryAfter?: number;
         data?: Record<string, unknown>;
     });
-    /** True when the request failed because the subscription is out of allowance. */
+    /**
+     * True when the request failed because an allowance is used up and retrying
+     * will not help until it resets: the subscription quota (-32006), the
+     * overage spend cap (-32007) or the API key's daily limit (-32008).
+     */
     get isQuotaExhausted(): boolean;
+    /**
+     * True when the API key's own daily limit is reached (-32008). `data` then
+     * carries `{ dailyLimit, used, cost, resetsAt }`; `resetsAt` is the next
+     * 00:00 UTC.
+     */
+    get isDailyLimitReached(): boolean;
     /** True when the request was throttled and is worth retrying. */
     get isRateLimited(): boolean;
 }
@@ -530,38 +1053,52 @@ declare class HttpClient {
 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>;
+    /**
+     * Register a new user account. Does not sign in: the API answers
+     * `{ message, email }` (the same for an address that already has an
+     * account) and emails a confirmation link. Call `login()` once the address
+     * is confirmed.
+     *
+     * The server rejects registration (400) unless the user agreed to the
+     * Terms of Service, Privacy Policy and DPA, so `data.acceptedTerms` is
+     * required and always sent. Pass `acceptedTerms: true` only after the user
+     * has ticked the agreement.
+     */
+    register(data: RegisterRequest): Promise<RegisterResponse>;
+    /**
+     * 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 {
@@ -569,33 +1106,53 @@ 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[]>;
-    /** Invite a member to the organization */
+    /**
+     * Invite someone to the organization by email. Creates (or refreshes) a
+     * pending invitation — nobody becomes a member until the invitee accepts
+     * it while signed in with a verified address.
+     */
     inviteMember(orgId: string, data: {
         email: string;
-        role: string;
-    }): Promise<OrgMember>;
+        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<MessageResponse>;
+    /** Invitations addressed to the signed-in user */
+    listMyInvites(): Promise<MyInvites>;
+    /**
+     * Accept an invitation addressed to the signed-in user.
+     *
+     * If the user has not accepted the current terms version yet, the API
+     * answers 403 (`TERMS_ACCEPTANCE_REQUIRED`) unless
+     * `{ acceptedTerms: true }` is passed — only after the user agreed to the
+     * Terms of Service, Privacy Policy and DPA. `acceptedTerms` is sent only
+     * when given.
+     */
+    acceptInvite(inviteId: string, options?: AcceptInviteOptions): Promise<InviteAcceptance>;
+    /** Decline an invitation addressed to the signed-in user */
+    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>;
 }
@@ -607,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>;
@@ -635,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>;
 }
@@ -669,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 */
@@ -702,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 */
@@ -716,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>;
 }
@@ -741,12 +1312,19 @@ declare class SubscriptionsResource {
     constructor(http: HttpClient);
     /** Get current subscription */
     get(orgId: string): Promise<Subscription>;
-    /** Change subscription plan */
-    changePlan(orgId: string, planId: string): Promise<Subscription>;
+    /**
+     * Change subscription plan.
+     *
+     * The server rejects a plan change unless the caller confirms the
+     * plan-change billing terms, so `options.acceptedTerms` is required and
+     * always sent. Pass `{ acceptedTerms: true }` only after the user has
+     * accepted the terms.
+     */
+    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[]>;
 }
@@ -765,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 {
@@ -837,7 +1420,7 @@ declare class RpcResource {
  *
  * @example
  * ```typescript
- * import { IteradianClient } from '@iteradian/sdk';
+ * import { IteradianClient } from '@iteradian-rpc/sdk';
  *
  * const client = new IteradianClient({
  *   baseUrl: 'https://api.iteradian.com/api/v1',
@@ -890,4 +1473,5 @@ declare class IteradianClient {
     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 };
+export { AlertsResource, ApiKeysResource, AuthResource, DashboardResource, EndpointsResource, IteradianClient, IteradianError, LogsResource, OrganizationsResource, PlansResource, RpcResource, SubscriptionsResource, SupportResource, UsageResource };
+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 };