@usagetap/sdk 1.3.2 → 1.7.0

package/dist/client-C0UiaqVB.d.ts

@@ -0,0 +1,1305 @@
+type ReasoningLevel = "NONE" | "LOW" | "MEDIUM" | "HIGH";
+/** Provider execution setting used for a completed call. */
+type ReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+/** How UsageTap learned the execution reasoning effort. */
+type ReasoningEffortSource = "provider_response" | "provider_request" | "gateway_config" | "model_default";
+type LimitType = "NONE" | "BLOCK" | "DOWNGRADE";
+interface RequestedEntitlements {
+    standard?: boolean;
+    premium?: boolean;
+    audio?: boolean;
+    image?: boolean;
+    search?: boolean;
+    reasoningLevel?: ReasoningLevel;
+}
+type AllowedEntitlements = Required<RequestedEntitlements>;
+type ModelTier = "premium" | "standard" | "none";
+interface EntitlementDowngradeHint {
+    reason: string;
+    fallbackTier?: ModelTier;
+}
+interface EntitlementHints {
+    suggestedModelTier: ModelTier;
+    reasoningLevel: ReasoningLevel;
+    policy: LimitType;
+    downgrade?: EntitlementDowngradeHint;
+}
+interface MeterSummary {
+    /** Always numeric. Check the `unlimited` flag to detect unbounded meters. */
+    remaining: number;
+    limit: number | null;
+    /** Always numeric (0 when no usage recorded). */
+    used: number;
+    /** When true this meter is unbounded; `remaining` is informational only. */
+    unlimited: boolean;
+    /** remaining / limit (0-1). null when unlimited or limit is null/0. */
+    ratio: number | null;
+    label?: string;
+}
+type MeterSnapshot = Record<string, MeterSummary>;
+type RemainingRatios = Record<string, number | null | undefined>;
+interface RollingCallsRateLimitState {
+    windowType: "rolling_calls";
+    limit: number;
+    used: number;
+    remaining: number;
+    windowSeconds: number;
+    state: "fresh" | "estimated" | "stale" | "unknown";
+    source?: "current_rolling_check" | "call_records";
+    nextAvailableAt?: string;
+    scope?: {
+        callType?: "standard";
+        tier?: "standard" | "premium";
+    };
+}
+interface RateLimitsSnapshot {
+    rollingCalls?: RollingCallsRateLimitState | Record<string, RollingCallsRateLimitState>;
+}
+interface SubscriptionSnapshot {
+    id: string | null;
+    usagePlanVersionId: string | null;
+    planName: string | null;
+    planVersion: string | null;
+    limitType: LimitType;
+    reasoningLevel: ReasoningLevel;
+    lastReplenishedAt: string | null;
+    nextReplenishAt: string | null;
+    subscriptionVersion: number | null;
+    customerFriendlyName?: string | null;
+    customerEmail?: string | null;
+    pending?: {
+        usagePlanVersionId: string | null;
+        strategy: string | null;
+        effectiveAt: string | null;
+    };
+    stripeCustomerId?: string | null;
+}
+type ModelHints = Record<string, string[]>;
+interface IdempotencyMetadata {
+    key: string;
+    source: "explicit" | "derived";
+}
+interface VendorHints {
+    preferredModel?: string;
+    reasoning?: ReasoningLevel;
+    maxInputTokens?: number;
+    maxResponseTokens?: number;
+}
+interface PromptCompressionRequest {
+    callId: string;
+    input?: unknown;
+    text?: string;
+    provider?: "heuristic" | "toon" | "thetokencompany" | "usagetap";
+    model?: string;
+    tokenCompanyModel?: string;
+    /** Provider-neutral compression aggressiveness from 0.0 to 1.0. */
+    aggressiveness?: number;
+    /** @deprecated Use aggressiveness instead. */
+    tokenCompanyAggressiveness?: number;
+    tokenCompanyAppId?: string;
+    usageTapCompressionModel?: string;
+    /** @deprecated Use aggressiveness instead. */
+    usageTapCompressionAggressiveness?: number;
+}
+interface PromptCompressionTelemetry {
+    provider: "heuristic" | "toon" | "thetokencompany" | "usagetap";
+    originalTokens: number;
+    compressedTokens: number;
+    savedTokens: number;
+    tokenSavingsRatio: number;
+    techniques: string[];
+}
+interface BeginCallRequest {
+    customerId: string;
+    /**
+     * Identifies one application workflow or agent run for local circuit-breaker
+     * enforcement. This value is used by the SDK only and is not sent to UsageTap.
+     */
+    runId?: string;
+    requested?: RequestedEntitlements;
+    feature?: string;
+    tags?: string[];
+    /**
+     * Idempotency key for safe retries.
+     * The SDK generates a unique key by default. Direct API callers should send
+     * one explicitly and reuse it only when retrying the same logical call.
+     * @deprecated Use idempotencyKey instead
+     */
+    idempotency?: string;
+    /**
+     * Idempotency key for safe retries.
+     * The SDK generates a unique key by default. Direct API callers should send
+     * one explicitly and reuse it only when retrying the same logical call.
+     */
+    idempotencyKey?: string;
+    customerName?: string;
+    customerEmail?: string;
+    /** Stable identifier for the end user who initiated this call. */
+    customerUserId?: string;
+    /** Display name for the end user who initiated this call. */
+    customerUserName?: string;
+    /** Email address for the end user who initiated this call. */
+    customerUserEmail?: string;
+    stripeCustomerId?: string;
+    /**
+     * Compatibility flag for batch pricing (typically 50% of standard rates).
+     * When both fields are supplied, pricingMode is authoritative.
+     */
+    batch?: boolean;
+    /**
+     * Explicit pricing mode for this call. Takes precedence over batch.
+     */
+    pricingMode?: "batch" | "standard";
+}
+interface RuntimeCompressionMeasurement {
+    status: "SHADOW" | "ACTIVE";
+    configurationUpdatedAt?: string;
+    decision: "compressed" | "skipped" | "fallback" | "bypassed" | "error";
+    reasonCode?: string;
+    methodsAttempted: string[];
+    methodsApplied: string[];
+    originalTokens: number;
+    resultTokens: number;
+    savedTokens: number;
+    reductionPercentage: number;
+    compressionLatencyMs: number;
+    compressionComputeCostUsd: number;
+    financialsEstimated: boolean;
+}
+interface BalanceSummary {
+    standardCallsRemaining?: number;
+    premiumCallsRemaining?: number;
+    tokensRemaining?: number;
+    searchesRemaining?: number;
+    audioSecondsRemaining?: number;
+    agenticApiRemaining?: number;
+    customMeter1Remaining?: number;
+    customMeter2Remaining?: number;
+}
+type SpendVelocityWindowKey = "hour" | "day";
+interface SpendVelocityWindow {
+    bucket: string;
+    windowMinutes: number;
+    startedAt: string;
+    endedAt: string;
+    completedCostUsd: number;
+    completedCalls: number;
+}
+interface SpendVelocitySnapshot {
+    currency: "USD";
+    source: "usage_aggregate";
+    generatedAt: string;
+    customerId: string;
+    currentCallCostUsd: number;
+    windows: Record<SpendVelocityWindowKey, SpendVelocityWindow>;
+}
+interface PlanSummary {
+    id: string | null;
+    name: string | null;
+    version: string | null;
+}
+interface BeginCallResponseBody {
+    callId: string;
+    callType?: "standard";
+    startTime: string;
+    feature?: string;
+    tags?: string[];
+    newCustomer: boolean;
+    canceled: boolean;
+    policy: LimitType;
+    allowed: AllowedEntitlements;
+    entitlementHints: EntitlementHints;
+    rateLimits?: RateLimitsSnapshot;
+    meters: MeterSnapshot;
+    remainingRatios: RemainingRatios;
+    subscription: SubscriptionSnapshot;
+    models?: ModelHints;
+    idempotency?: IdempotencyMetadata;
+    vendorHints?: VendorHints;
+    plan?: PlanSummary;
+    balances?: BalanceSummary;
+    stripeCustomerId?: string | null;
+    batch?: boolean;
+    pricingMode?: "batch" | "standard";
+}
+interface EndCallRequest {
+    callId: string;
+    /** Optional customer ID for metric tracking. Not sent to API, used for onUsageMetric callback. */
+    customerId?: string;
+    /** Optional feature for metric tracking. Not sent to API, used for onUsageMetric callback. */
+    feature?: string;
+    /** Optional tags for metric tracking. Not sent to API, used for onUsageMetric callback. */
+    tags?: string[];
+    /** Vendor that executed the request, for example `openai` or `anthropic`. */
+    providerUsed?: string;
+    modelUsed?: string;
+    /** Reasoning effort actually used, or the best-known requested/configured value. */
+    reasoningEffort?: ReasoningEffort;
+    /** Provenance for reasoningEffort. Provider responses are most authoritative. */
+    reasoningEffortSource?: ReasoningEffortSource;
+    /** Provider-specific reasoning mode, such as `enabled` or `adaptive`. */
+    reasoningMode?: string;
+    /** Explicit reasoning/thinking token budget when the provider supports one. */
+    reasoningBudgetTokens?: number;
+    /**
+     * Total prompt/input tokens for the call (including any cached prompt tokens).
+     */
+    inputTokens?: number;
+    responseTokens?: number;
+    /**
+     * Prompt/input tokens served from cache.
+     * Preferred over legacy aliases.
+     */
+    cachedInputTokens?: number;
+    /**
+     * Prompt/input tokens written to a provider prompt cache.
+     * inputTokens must include these tokens.
+     */
+    cacheWriteInputTokens?: number;
+    /** Cache writes using the provider's five-minute cache lifetime. */
+    cacheWrite5mInputTokens?: number;
+    /** Cache writes using the provider's one-hour cache lifetime. */
+    cacheWrite1hInputTokens?: number;
+    reasoningTokens?: number;
+    searches?: number;
+    audio?: number;
+    audioSeconds?: number;
+    imageInputCount?: number;
+    imageInputTokens?: number;
+    imageOutputCount?: number;
+    imageOutputTokens?: number;
+    audioInputTokens?: number;
+    cachedAudioInputTokens?: number;
+    audioOutputTokens?: number;
+    error?: {
+        code: string;
+        message: string;
+    };
+    /**
+     * Optional downstream status metadata for direct integrations.
+     * Prefer `error` for failed provider calls.
+     */
+    responseStatusCode?: number;
+    /**
+     * Optional downstream error metadata for direct integrations.
+     * Prefer `error` for failed provider calls.
+     */
+    responseErrorMessage?: string;
+    /**
+     * Advanced compatibility override for model-tier classification.
+     */
+    isPremium?: boolean;
+    stripeCustomerId?: string;
+    /**
+     * Compatibility flag for batch pricing (typically 50% of standard rates).
+     * When both fields are supplied, pricingMode is authoritative.
+     */
+    batch?: boolean;
+    /**
+     * Explicit pricing mode for this call. Takes precedence over batch.
+     */
+    pricingMode?: "batch" | "standard";
+    runtimeCompression?: RuntimeCompressionMeasurement;
+}
+interface MeteredUsage {
+    calls?: number;
+    /** Provider-reported output tokens used by plan limits and Stripe token meters. */
+    tokens?: number;
+    reasoningTokens?: number;
+    searches?: number;
+    audio?: number;
+    audioSeconds?: number;
+}
+interface EndCallResponseBody {
+    callId: string;
+    status?: "COMPLETED" | "FAILED";
+    error?: {
+        code: string;
+        message: string;
+    };
+    providerUsed?: string;
+    modelUsed?: string;
+    reasoningEffort?: ReasoningEffort;
+    reasoningEffortSource?: ReasoningEffortSource;
+    reasoningMode?: string;
+    reasoningBudgetTokens?: number;
+    /** Final model cost after the selected pricing mode is applied. */
+    costUSD: number;
+    /** Integer decimal representation used by the API for high-precision cost storage. */
+    costUsdNano?: string;
+    costBreakdown?: Record<string, unknown>;
+    /** Model cost before a vendor-batch discount is applied. */
+    standardCostUSD?: number;
+    /** Effective multiplier relating final costUSD to standardCostUSD. */
+    pricingMultiplier?: number;
+    usage?: {
+        inputTokens: number;
+        cachedInputTokens: number;
+        cacheWriteInputTokens: number;
+        cacheWrite5mInputTokens?: number;
+        cacheWrite1hInputTokens?: number;
+        billableInputTokens: number;
+        responseTokens: number;
+        reasoningTokens: number;
+        imageInputCount?: number;
+        imageInputTokens?: number;
+        imageOutputCount?: number;
+        imageOutputTokens?: number;
+        audioInputTokens?: number;
+        cachedAudioInputTokens?: number;
+        audioOutputTokens?: number;
+    };
+    metered?: MeteredUsage;
+    spendVelocity?: SpendVelocitySnapshot;
+    policy?: LimitType;
+    allowed?: AllowedEntitlements;
+    entitlementHints?: EntitlementHints;
+    meters?: MeterSnapshot;
+    remainingRatios?: RemainingRatios;
+    subscription?: SubscriptionSnapshot;
+    models?: ModelHints;
+    plan?: PlanSummary;
+    balances?: BalanceSummary;
+    stripeCustomerId?: string | null;
+    batch?: boolean;
+    pricingMode?: "batch" | "standard";
+}
+type UsageTapResultStatus = "ACCEPTED" | "ERROR";
+interface UsageTapResultEnvelope {
+    status: UsageTapResultStatus;
+    code?: string;
+    message?: string;
+    timestamp?: string;
+}
+interface UsageTapErrorPayload {
+    code: string;
+    message: string;
+    details?: Record<string, unknown>;
+}
+interface UsageTapSuccessResponse<TData> {
+    result: UsageTapResultEnvelope;
+    data: TData;
+    correlationId: string;
+}
+interface UsageTapErrorResponse {
+    result: UsageTapResultEnvelope;
+    error: UsageTapErrorPayload;
+    correlationId: string;
+}
+interface RetryOptions {
+    /**
+     * Maximum number of attempts including the initial try.
+     * @default 3
+     */
+    maxAttempts?: number;
+    /**
+     * Base backoff delay in milliseconds.
+     * @default 250
+     */
+    baseDelayMs?: number;
+    /**
+     * Maximum backoff delay in milliseconds.
+     * @default 5000
+     */
+    maxDelayMs?: number;
+    /**
+     * Jitter ratio between 0 and 1 applied to the computed delay.
+     * @default 0.2
+     */
+    jitterRatio?: number;
+}
+interface UsageTapLogEntry {
+    event: "request:start" | "request:success" | "request:error" | "retry:scheduled" | "retry:exhausted";
+    path: string;
+    attempt: number;
+    elapsedMs?: number;
+    idempotencyKey?: string;
+    correlationId?: string;
+    error?: unknown;
+}
+interface UsageTapClientOptions {
+    /**
+     * UsageTap API key. Defaults to the server-side USAGETAP_API_KEY environment variable.
+     */
+    apiKey?: string;
+    /**
+     * UsageTap API base URL. Defaults to USAGETAP_BASE_URL, then https://api.usagetap.com.
+     */
+    baseUrl?: string;
+    /**
+     * UsageTap Gateway base URL. Defaults to USAGETAP_GATEWAY_URL, then
+     * https://gateway.usagetap.com.
+     */
+    gatewayBaseUrl?: string;
+    defaultFeature?: string;
+    defaultTags?: string[];
+    fetchImpl?: typeof fetch;
+    headers?: Record<string, string>;
+    retries?: RetryOptions;
+    idempotencyGenerator?: () => string;
+    /**
+     * When true (default), the client auto-generates an idempotency key when one is not provided.
+     * Set to false to rely on the backend's deterministic fallback.
+     */
+    autoIdempotency?: boolean;
+    onLog?: (entry: UsageTapLogEntry) => void;
+    /**
+     * Callback invoked when usage metrics are recorded (call_end, custom_meter).
+     * Use this to export metrics to OpenTelemetry or other observability systems.
+     */
+    onUsageMetric?: (event: UsageMetricEvent) => void;
+    /**
+     * Override the default Authorization header with x-api-key when true.
+     */
+    useApiKeyHeader?: boolean;
+    /**
+     * Allow constructing the client in browser-like environments for testing.
+     */
+    allowBrowser?: boolean;
+    /** API key for The Token Company Bear compression API. */
+    tokenCompanyApiKey?: string;
+    /** Override endpoint for The Token Company compatible compression APIs. */
+    tokenCompanyEndpoint?: string;
+    /** Default model for The Token Company compression. */
+    model?: string;
+    tokenCompanyModel?: string;
+    /** Default compression aggressiveness, from 0.0 to 1.0. */
+    aggressiveness?: number;
+    /** @deprecated Use aggressiveness instead. */
+    tokenCompanyAggressiveness?: number;
+    /** Optional application identifier sent to The Token Company. */
+    tokenCompanyAppId?: string;
+    /** API key for UsageTap prompt compression. Defaults to apiKey when omitted. */
+    usageTapCompressionApiKey?: string;
+    /** Override endpoint for UsageTap-compatible prompt compression APIs. */
+    usageTapCompressionEndpoint?: string;
+    /** Override endpoint for UsageTap-compatible message/request compression APIs. */
+    usageTapCompressionMessagesEndpoint?: string;
+    /** Default model for UsageTap prompt compression. */
+    usageTapCompressionModel?: string;
+    /** @deprecated Use aggressiveness instead. */
+    usageTapCompressionAggressiveness?: number;
+    /** Local policy override. Omit to load the saved UsageTap policy; false disables sampling. */
+    sampling?: SamplingOptions | false;
+    /** Maximum local lifetime for remotely loaded sampling settings. Defaults to 5 minutes. */
+    samplingSettingsCacheMs?: number;
+    /**
+     * Optional local hard stop for recursive or runaway workflows.
+     * Calls without a runId are not affected.
+     */
+    circuitBreaker?: CircuitBreakerOptions | false;
+}
+interface CircuitBreakerOptions {
+    /** Maximum call_begin attempts allowed for one customerId + runId pair. */
+    maxCallsPerRun: number;
+    /**
+     * Forget inactive runs after this many milliseconds.
+     * Defaults to 60 minutes. Call resetRun() when a run completes to release it sooner.
+     */
+    runInactivityMs?: number;
+}
+interface CircuitBreakerDecision {
+    allowed: boolean;
+    reason?: "max_calls_per_run";
+    customerId: string;
+    runId: string;
+    calls: number;
+    limit: number;
+    remaining: number;
+}
+interface RequestOptions {
+    signal?: AbortSignal;
+    headers?: Record<string, string>;
+    retries?: RetryOptions;
+}
+interface SamplingOptions {
+    /** Fraction of eligible calls to retain, from 0 to 1. */
+    rate: number;
+    /** Skip inputs below this local estimated-token threshold. */
+    minInputTokens?: number;
+    features?: {
+        include?: string[];
+        exclude?: string[];
+    };
+    customers?: {
+        exclude?: string[];
+    };
+    /** Optional deterministic random source, primarily for testing. */
+    random?: () => number;
+}
+interface SamplingDecisionInput {
+    customerId?: string;
+    feature?: string;
+    input: unknown;
+}
+interface SamplingSettings extends Omit<SamplingOptions, "random"> {
+    version: string;
+    retentionDays: number;
+    cacheSeconds: number;
+    settingsExpiresAt: string;
+}
+interface GetSamplingSettingsOptions extends RequestOptions {
+    correlationId?: string;
+    forceRefresh?: boolean;
+}
+interface SamplingDecisionRequest {
+    samplingKey?: string;
+    customerId?: string;
+    feature?: string;
+    inputTokens?: number;
+    inputCharacters?: number;
+}
+interface SamplingDecisionResponseBody {
+    sample: boolean;
+    reason: "selected" | "watch_selected" | "rate_disabled" | "customer_excluded" | "feature_excluded" | "feature_not_included" | "below_minimum_tokens" | "rate_not_selected";
+    decisionId: string;
+    samplingKey: string;
+    policyVersion: string;
+    settingsExpiresAt: string;
+    score?: number;
+    watchId?: string;
+}
+interface SamplingDecisionOptions extends RequestOptions {
+    correlationId?: string;
+}
+interface CaptureSampleRequest extends SamplingDecisionInput {
+    sampleId?: string;
+    /** Exact UsageTap call ID when this sample belongs to a metered call. */
+    callId?: string;
+    environment?: string;
+    tags?: string[];
+    provider: string;
+    model?: string;
+    output?: unknown;
+    usage?: unknown;
+    latencyMs?: number;
+    error?: unknown;
+    decisionId?: string;
+    policyVersion?: string;
+    watchId?: string;
+}
+interface CaptureSampleOptions extends RequestOptions {
+    correlationId?: string;
+}
+interface CaptureSampleResponseBody {
+    sampleId: string;
+    stored?: boolean;
+    receivedAt: string;
+    expiresAt: string;
+    retentionDays: number;
+    policyVersion?: string;
+    payloadStorage?: "dynamodb" | "s3";
+}
+interface PromptCompressionStandaloneOptions {
+    signal?: AbortSignal;
+    provider?: "heuristic" | "toon" | "thetokencompany" | "usagetap";
+    failOpen?: boolean;
+    model?: string;
+    tokenCompanyModel?: string;
+    /** Provider-neutral compression aggressiveness from 0.0 to 1.0. */
+    aggressiveness?: number;
+    /** @deprecated Use aggressiveness instead. */
+    tokenCompanyAggressiveness?: number;
+    tokenCompanyAppId?: string;
+    usageTapCompressionModel?: string;
+    /** @deprecated Use aggressiveness instead. */
+    usageTapCompressionAggressiveness?: number;
+}
+type PromptCompressionMessageRole$1 = "system" | "user" | "tool" | "assistant";
+type PromptCompressionRoleAggressiveness$1 = Partial<Record<PromptCompressionMessageRole$1, number>>;
+type PromptCompressionMessagesAggressiveness$1 = number | PromptCompressionRoleAggressiveness$1;
+interface PromptCompressionMessagesOptions extends RequestOptions {
+    provider?: "usagetap";
+    failOpen?: boolean;
+    /** Select deterministic-only, automatic model gating, or a forced model pass. */
+    mode?: "deterministic" | "model_auto" | "model_force";
+    /** Provider-neutral scalar or per-role compression aggressiveness. */
+    aggressiveness?: PromptCompressionMessagesAggressiveness$1;
+    /** Maximum compression latency the service should target. */
+    latencyBudgetMs?: number;
+    /** Remove empty user messages before compression. */
+    compactEmptyUserMessages?: boolean;
+    /** Deduplicate repeated text parts within user messages. */
+    compactDuplicateUserTextParts?: boolean;
+    /** @deprecated Use aggressiveness instead. */
+    usageTapCompressionAggressiveness?: PromptCompressionMessagesAggressiveness$1;
+}
+interface RecordPromptCompressionRequest {
+    callId: string;
+    promptCompression: PromptCompressionTelemetry;
+}
+interface BeginCallOptions extends RequestOptions {
+    correlationId?: string;
+}
+interface EndCallOptions extends RequestOptions {
+    correlationId?: string;
+}
+interface PromptCompressionOptions extends RequestOptions {
+    correlationId?: string;
+}
+interface PromptCompressionResponseBody extends PromptCompressionTelemetry {
+    callId: string;
+    updated: boolean;
+}
+interface WithUsageContext {
+    begin: UsageTapSuccessResponse<BeginCallResponseBody>;
+    setUsage: (usage: Partial<Omit<EndCallRequest, "callId" | "error">>) => void;
+    setError: (error: EndCallRequest["error"]) => void;
+    /**
+     * Defer call_end until a streaming operation has finished. The returned
+     * function settles the call exactly once using the latest usage and error.
+     * Adapters should call it on completion, cancellation, and failure.
+     */
+    deferFinalization?: () => () => Promise<void>;
+}
+interface WithUsageOptions {
+    signal?: AbortSignal;
+    headers?: Record<string, string>;
+    retries?: RetryOptions;
+    correlationId?: string;
+    /**
+     * Default error payload applied when the handler throws and setError was never invoked.
+     */
+    defaultErrorCode?: string;
+}
+interface CheckUsageRequest {
+    customerId: string;
+}
+interface CheckUsageOptions extends RequestOptions {
+    correlationId?: string;
+}
+interface CheckUsageResponseBody {
+    customerId: string;
+    canceled: boolean;
+    policy: LimitType;
+    allowed: AllowedEntitlements;
+    entitlementHints: EntitlementHints;
+    rateLimits?: RateLimitsSnapshot;
+    meters: MeterSnapshot;
+    remainingRatios: RemainingRatios;
+    subscription: SubscriptionSnapshot;
+    models?: ModelHints;
+    plan?: PlanSummary;
+    balances?: BalanceSummary;
+    stripeCustomerId?: string | null;
+}
+interface CreateCustomerRequest {
+    customerId: string;
+    customerFriendlyName?: string;
+    customerName?: string;
+    customerEmail?: string;
+    stripeCustomerId?: string;
+}
+interface CreateCustomerOptions extends RequestOptions {
+    correlationId?: string;
+    idempotencyKey?: string;
+}
+interface CreateCustomerResponseBody extends CheckUsageResponseBody {
+    newCustomer: boolean;
+}
+type ChangePlanStrategy = "IMMEDIATE_RESET" | "IMMEDIATE_PRORATED" | "AT_NEXT_REPLENISH";
+interface ChangePlanRequest {
+    customerId: string;
+    planId: string;
+    strategy?: ChangePlanStrategy;
+}
+interface ChangePlanOptions extends RequestOptions {
+    correlationId?: string;
+    idempotencyKey?: string;
+}
+interface ChangePlanResponseBody {
+    success: boolean;
+    subscription: SubscriptionSnapshot;
+}
+type CustomMeterSlot = "CUSTOM1" | "CUSTOM2" | "AGENTIC_API";
+interface IncrementCustomMeterRequest {
+    customerId: string;
+    /** Stable identifier for the end user responsible for this meter event. */
+    customerUserId?: string;
+    /** Display name for the end user responsible for this meter event. */
+    customerUserName?: string;
+    /** Email address for the end user responsible for this meter event. */
+    customerUserEmail?: string;
+    meterSlot: CustomMeterSlot;
+    amount: number;
+    feature?: string;
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+}
+interface IncrementCustomMeterOptions extends RequestOptions {
+    correlationId?: string;
+    idempotencyKey?: string;
+}
+interface IncrementCustomMeterResponseBody {
+    success: boolean;
+    eventId: string;
+    meterSlot: CustomMeterSlot;
+    amount: number;
+    meter: MeterSummary;
+    blocked: boolean;
+}
+/**
+ * Event emitted when usage metrics are recorded.
+ * Use with `onUsageMetric` callback to export to OpenTelemetry or other observability systems.
+ */
+interface UsageMetricEvent {
+    /** Type of metric event */
+    type: "call_end" | "custom_meter";
+    /** Timestamp in ISO 8601 format */
+    timestamp: string;
+    /** Customer identifier */
+    customerId: string;
+    /** Unique call identifier (for call_end events) */
+    callId?: string;
+    /** Feature tag */
+    feature?: string;
+    /** Additional tags */
+    tags?: string[];
+    /** Model used for the call */
+    modelUsed?: string;
+    /** Vendor that executed the request */
+    providerUsed?: string;
+    /** Reasoning effort used for the call */
+    reasoningEffort?: ReasoningEffort;
+    /** Provenance for the reasoning effort */
+    reasoningEffortSource?: ReasoningEffortSource;
+    /** Provider-specific reasoning mode */
+    reasoningMode?: string;
+    /** Explicit reasoning/thinking token budget */
+    reasoningBudgetTokens?: number;
+    /** Usage metrics */
+    metrics: {
+        inputTokens?: number;
+        cachedInputTokens?: number;
+        cacheWriteInputTokens?: number;
+        cacheWrite5mInputTokens?: number;
+        cacheWrite1hInputTokens?: number;
+        responseTokens?: number;
+        reasoningTokens?: number;
+        searches?: number;
+        audioSeconds?: number;
+        imageInputCount?: number;
+        imageInputTokens?: number;
+        imageOutputCount?: number;
+        imageOutputTokens?: number;
+        audioInputTokens?: number;
+        cachedAudioInputTokens?: number;
+        audioOutputTokens?: number;
+        costUsd?: number;
+        /** Custom meter slot (for custom_meter events) */
+        customMeterSlot?: CustomMeterSlot;
+        /** Custom meter amount (for custom_meter events) */
+        customMeterAmount?: number;
+    };
+    /** Correlation ID for tracing */
+    correlationId?: string;
+}
+
+type PromptCompressionProvider = "heuristic" | "toon" | "thetokencompany" | "usagetap";
+type PromptCompressionMessageRole = "system" | "user" | "tool" | "assistant";
+type PromptCompressionMode = "deterministic" | "model_auto" | "model_force";
+type PromptCompressionRoleAggressiveness = Partial<Record<PromptCompressionMessageRole, number>>;
+type PromptCompressionMessagesAggressiveness = number | PromptCompressionRoleAggressiveness;
+interface PromptCompressionInput {
+    input?: unknown;
+    text?: string;
+    provider?: PromptCompressionProvider;
+    tokenCompanyApiKey?: string;
+    tokenCompanyEndpoint?: string;
+    model?: string;
+    tokenCompanyModel?: string;
+    aggressiveness?: number;
+    tokenCompanyAggressiveness?: number;
+    tokenCompanyAppId?: string;
+    usageTapCompressionApiKey?: string;
+    usageTapCompressionEndpoint?: string;
+    usageTapCompressionModel?: string;
+    usageTapCompressionAggressiveness?: number;
+    fetchImpl?: typeof fetch;
+    signal?: AbortSignal;
+    failOpen?: boolean;
+}
+interface PromptCompressionMessagesInput<TInput = unknown> {
+    input: TInput;
+    provider?: Extract<PromptCompressionProvider, "usagetap">;
+    usageTapCompressionApiKey?: string;
+    usageTapCompressionMessagesEndpoint?: string;
+    aggressiveness?: PromptCompressionMessagesAggressiveness;
+    usageTapCompressionAggressiveness?: PromptCompressionMessagesAggressiveness;
+    /** Select deterministic-only, automatic model gating, or a forced model pass. */
+    mode?: PromptCompressionMode;
+    /** Maximum compression latency the service should target. */
+    latencyBudgetMs?: number;
+    /** Remove empty user messages before compression. */
+    compactEmptyUserMessages?: boolean;
+    /** Deduplicate repeated text parts within user messages. */
+    compactDuplicateUserTextParts?: boolean;
+    fetchImpl?: typeof fetch;
+    signal?: AbortSignal;
+    failOpen?: boolean;
+}
+interface PromptCompressionResult<TInput = unknown> {
+    input: TInput;
+    compressedInput: unknown;
+    provider: PromptCompressionProvider;
+    originalCharacters: number;
+    compressedCharacters: number;
+    savedCharacters: number;
+    originalTokens: number;
+    compressedTokens: number;
+    savedTokens: number;
+    tokenSavingsRatio: number;
+    savingsRatio: number;
+    techniques: string[];
+}
+declare function protectPromptText(text: string): string;
+declare const protect: typeof protectPromptText;
+declare function compressPrompt<TInput = unknown>(options: PromptCompressionInput): Promise<PromptCompressionResult<TInput>>;
+declare function compressPromptHeuristic<TInput = unknown>(input: TInput): PromptCompressionResult<TInput>;
+declare function compressPromptToon<TInput = unknown>(input: TInput): PromptCompressionResult<TInput>;
+declare function compressPromptMessages<TInput = unknown>(options: PromptCompressionMessagesInput<TInput>): Promise<PromptCompressionResult<TInput>>;
+declare function estimatePromptTokens(input: unknown): number;
+
+type JsonRecord = Record<string, unknown>;
+interface ResourceRequestOptions {
+    signal?: AbortSignal;
+    headers?: Record<string, string>;
+    idempotencyKey?: string;
+}
+interface WaitOptions extends ResourceRequestOptions {
+    /** Delay between status requests. */
+    pollIntervalMs?: number;
+    /** Maximum total polling time. */
+    timeoutMs?: number;
+}
+interface SummarizationContext {
+    id: string;
+    type: string;
+    content: string;
+    version?: string;
+    contentType?: string;
+}
+type SummarizationStatus = "QUEUED" | "RUNNING" | "COMPLETE" | "FAILED";
+interface SummarizationJob {
+    jobId: string;
+    status: SummarizationStatus;
+    phase?: string;
+    profile?: string;
+    version?: number;
+    statusUrl?: string;
+    progress?: JsonRecord;
+    billing?: JsonRecord;
+    result?: JsonRecord;
+    error?: string;
+}
+interface SummarizationCreateParams {
+    profile: string;
+    context: SummarizationContext;
+    wait?: boolean;
+}
+interface SummarizationBatchCreateParams {
+    profile: string;
+    items: SummarizationContext[];
+}
+interface SummarizationBatchJob extends Partial<SummarizationJob> {
+    jobId: string;
+    contextId?: string;
+}
+interface SummarizationBatch {
+    batchId: string;
+    status: SummarizationStatus;
+    profile?: string;
+    version?: number;
+    submittedAt?: string;
+    statusUrl?: string;
+    jobs: SummarizationBatchJob[];
+}
+interface SummarizationProfile {
+    profile: string;
+    version: number;
+    name: string;
+    description?: string;
+    settings: {
+        model: string;
+        reasoningEffort?: string;
+        maxOutputTokens?: number;
+        outputFormat?: string;
+        outputSchema?: unknown;
+        temperature?: number;
+    };
+    prompt: {
+        system: string;
+        userTemplate: string;
+        contextPlaceholder: string;
+        assetId?: string;
+        schemaVersion?: string;
+    };
+    measurementUrl: string;
+}
+interface SummarizationMeasurementCreateParams {
+    profile: string;
+    contextId?: string;
+    source: {
+        tokens: number;
+    };
+    summary: {
+        tokens: number;
+    };
+    provider?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        costUsd?: number;
+    };
+}
+interface SummarizationMeasurement {
+    measurementId: string;
+    tokensSaved: number;
+    reported: boolean;
+}
+interface GatewayChatMessage {
+    role: string;
+    content: unknown;
+    [key: string]: unknown;
+}
+interface GatewayChatCompletionCreateParams {
+    model?: string;
+    models?: string[];
+    messages: GatewayChatMessage[];
+    stream?: false;
+    [key: string]: unknown;
+}
+interface GatewayChatCompletion {
+    id?: string;
+    object?: string;
+    created?: number;
+    model?: string;
+    choices: Array<{
+        index?: number;
+        message?: {
+            role?: string;
+            content?: string | null;
+            [key: string]: unknown;
+        };
+        finish_reason?: string | null;
+        [key: string]: unknown;
+    }>;
+    usage?: {
+        prompt_tokens?: number;
+        completion_tokens?: number;
+        total_tokens?: number;
+        [key: string]: unknown;
+    };
+    usagetap?: JsonRecord;
+    [key: string]: unknown;
+}
+type GatewayResponseVerbosity = "low" | "medium" | "high";
+interface GatewayPromptCacheBreakpoint {
+    mode: "explicit";
+}
+interface GatewayResponseInputText {
+    type: "input_text";
+    text: string;
+    prompt_cache_breakpoint?: GatewayPromptCacheBreakpoint;
+    [key: string]: unknown;
+}
+interface GatewayResponseInputMessage {
+    type?: "message";
+    role: "system" | "developer" | "user" | "assistant";
+    content: string | Array<GatewayResponseInputText | JsonRecord>;
+    [key: string]: unknown;
+}
+type GatewayResponseInputItem = GatewayResponseInputMessage | ({
+    type: string;
+} & JsonRecord);
+type GatewayResponseTextFormat = {
+    type: "text";
+} | {
+    type: "json_object";
+} | {
+    type: "json_schema";
+    name: string;
+    schema: JsonRecord;
+    description?: string;
+    strict?: boolean;
+};
+interface GatewayResponseTextConfig {
+    format?: GatewayResponseTextFormat;
+    verbosity?: GatewayResponseVerbosity;
+}
+interface GatewayResponsePromptCacheOptions {
+    mode?: "implicit" | "explicit";
+    ttl?: "30m";
+}
+interface GatewayResponseCreateParams {
+    model?: string;
+    models?: string[];
+    input: string | GatewayResponseInputItem[];
+    instructions?: string;
+    tools?: Array<{
+        type: string;
+        [key: string]: unknown;
+    }>;
+    tool_choice?: unknown;
+    reasoning?: {
+        effort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+        [key: string]: unknown;
+    };
+    text?: GatewayResponseTextConfig;
+    prompt_cache_key?: string;
+    prompt_cache_options?: GatewayResponsePromptCacheOptions;
+    max_output_tokens?: number;
+    stream?: false;
+    background?: false;
+    /** Ask the Gateway to compress eligible request text before provider invocation. */
+    compress?: boolean;
+    [key: string]: unknown;
+}
+interface GatewayResponse {
+    id: string;
+    object?: string;
+    status?: string;
+    model?: string;
+    output: Array<{
+        type: string;
+        [key: string]: unknown;
+    }>;
+    output_text?: string;
+    usage?: {
+        input_tokens?: number;
+        output_tokens?: number;
+        total_tokens?: number;
+        input_tokens_details?: {
+            cached_tokens?: number;
+            cache_write_tokens?: number;
+            [key: string]: unknown;
+        };
+        output_tokens_details?: {
+            reasoning_tokens?: number;
+            [key: string]: unknown;
+        };
+        [key: string]: unknown;
+    };
+    usagetap?: JsonRecord;
+    [key: string]: unknown;
+}
+interface GatewayModel {
+    id: string;
+    object?: string;
+    created?: number;
+    owned_by?: string;
+    [key: string]: unknown;
+}
+interface GatewayModelList {
+    object: string;
+    data: GatewayModel[];
+}
+type GatewayBatchStatus = "queued" | "submitting" | "in_progress" | "finalizing" | "cancelling" | "completed" | "failed" | "expired" | "cancelled";
+interface GatewayBatchRequest {
+    custom_id: string;
+    body: GatewayChatCompletionCreateParams;
+}
+interface GatewayBatchCreateParams {
+    requests: GatewayBatchRequest[];
+}
+interface GatewayBatch {
+    id: string;
+    object: "batch";
+    status: GatewayBatchStatus;
+    provider?: string;
+    created_at: string;
+    updated_at: string;
+    completed_at?: string;
+    request_counts: {
+        total: number;
+        completed: number;
+        failed: number;
+    };
+    calls: Array<{
+        custom_id: string;
+        call_id: string;
+        status: number;
+        error?: {
+            code: string;
+            message: string;
+        };
+    }>;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+interface GatewayBatchResult {
+    custom_id: string;
+    call_id: string;
+    status: number;
+    response?: GatewayChatCompletion;
+    usage?: JsonRecord;
+    compression?: {
+        applied: boolean;
+        status: "applied" | "no_savings" | "failed_open";
+        original_input_tokens?: number;
+        compressed_input_tokens?: number;
+        tokens_saved?: number;
+        reduction_percent?: number;
+    };
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+interface ResourceClientConfig {
+    apiKey: string;
+    apiBaseUrl: string;
+    gatewayBaseUrl?: string;
+    fetchImpl: typeof fetch;
+    headers?: Record<string, string>;
+    sdkVersion: string;
+    idempotencyGenerator?: () => string;
+}
+declare class SummarizationResource {
+    readonly summaries: {
+        create: (params: SummarizationCreateParams, options?: ResourceRequestOptions) => Promise<SummarizationJob>;
+        retrieve: (jobId: string, options?: ResourceRequestOptions) => Promise<SummarizationJob>;
+        wait: (job: string | SummarizationJob, options?: WaitOptions) => Promise<SummarizationJob>;
+    };
+    readonly batches: {
+        create: (params: SummarizationBatchCreateParams, options?: ResourceRequestOptions) => Promise<SummarizationBatch>;
+        retrieve: (batchId: string, options?: ResourceRequestOptions) => Promise<SummarizationBatch>;
+        wait: (batch: string | SummarizationBatch, options?: WaitOptions) => Promise<SummarizationBatch>;
+    };
+    readonly profiles: {
+        retrieve: (profile: string, options?: ResourceRequestOptions) => Promise<SummarizationProfile>;
+    };
+    readonly measurements: {
+        create: (params: SummarizationMeasurementCreateParams, options?: ResourceRequestOptions) => Promise<SummarizationMeasurement>;
+    };
+    private readonly transport;
+    constructor(config: ResourceClientConfig);
+    private waitForSummary;
+    private waitForBatch;
+}
+declare class GatewayResource {
+    readonly chat: {
+        completions: {
+            create: <T extends GatewayChatCompletion = GatewayChatCompletion>(params: GatewayChatCompletionCreateParams, options?: ResourceRequestOptions) => Promise<T>;
+        };
+    };
+    /** Buffered OpenAI Responses-compatible requests. */
+    readonly responses: {
+        create: <T extends GatewayResponse = GatewayResponse>(params: GatewayResponseCreateParams, options?: ResourceRequestOptions) => Promise<T>;
+    };
+    readonly models: {
+        list: (options?: ResourceRequestOptions) => Promise<GatewayModelList>;
+    };
+    readonly batches: {
+        create: (params: GatewayBatchCreateParams, options?: ResourceRequestOptions) => Promise<GatewayBatch>;
+        retrieve: (batchId: string, options?: ResourceRequestOptions) => Promise<GatewayBatch>;
+        wait: (batch: string | GatewayBatch, options?: WaitOptions) => Promise<GatewayBatch>;
+        cancel: (batchId: string, options?: ResourceRequestOptions) => Promise<GatewayBatch>;
+        results: (batchId: string, options?: ResourceRequestOptions) => Promise<GatewayBatchResult[]>;
+    };
+    private readonly transport;
+    private readonly idempotencyGenerator;
+    constructor(config: ResourceClientConfig);
+    private waitForBatch;
+}
+
+type UsageTapCompressOptions = Omit<PromptCompressionStandaloneOptions, "provider">;
+type UsageTapCompressResult = Omit<PromptCompressionResult<string>, "compressedInput"> & {
+    /** The compressed text, ready to pass to an LLM. */
+    output: string;
+    /** Alias retained for consistency with the lower-level compression APIs. */
+    compressedInput: string;
+};
+type MeterRequest = string | BeginCallRequest;
+declare class UsageTapClient {
+    /** OpenAI-compatible chat, model, and native batch operations. */
+    readonly gateway: GatewayResource;
+    /** Published-profile context summarization operations. */
+    readonly summarization: SummarizationResource;
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly fetchImpl;
+    private readonly defaultFeature?;
+    private readonly defaultTags?;
+    private readonly defaultHeaders;
+    private readonly retryDefaults;
+    private readonly idempotencyGenerator;
+    private readonly logFn?;
+    private readonly metricFn?;
+    private readonly authHeader;
+    private readonly autoIdempotency;
+    private readonly tokenCompanyApiKey?;
+    private readonly tokenCompanyEndpoint?;
+    private readonly model?;
+    private readonly tokenCompanyModel?;
+    private readonly aggressiveness?;
+    private readonly tokenCompanyAggressiveness?;
+    private readonly tokenCompanyAppId?;
+    private readonly usageTapCompressionApiKey?;
+    private readonly usageTapCompressionEndpoint?;
+    private readonly usageTapCompressionMessagesEndpoint?;
+    private readonly usageTapCompressionModel?;
+    private readonly usageTapCompressionAggressiveness?;
+    private readonly sampling?;
+    private readonly samplingSettingsCacheMs;
+    private readonly circuitBreaker?;
+    private readonly circuitBreakerRuns;
+    private samplingSettingsCache?;
+    constructor(options?: UsageTapClientOptions);
+    shouldSample(request: SamplingDecisionInput, policy?: SamplingOptions | undefined): boolean;
+    getSamplingSettings(options?: GetSamplingSettingsOptions): Promise<UsageTapSuccessResponse<SamplingSettings>>;
+    shouldSampleAsync(request: SamplingDecisionInput, policy?: SamplingOptions): Promise<boolean>;
+    decideSample(request: SamplingDecisionRequest, options?: SamplingDecisionOptions): Promise<UsageTapSuccessResponse<SamplingDecisionResponseBody>>;
+    captureSample(request: CaptureSampleRequest, options?: CaptureSampleOptions): Promise<UsageTapSuccessResponse<CaptureSampleResponseBody>>;
+    beginCall(request: BeginCallRequest, options?: BeginCallOptions): Promise<UsageTapSuccessResponse<BeginCallResponseBody>>;
+    /**
+     * Inspect a configured run circuit breaker without consuming another call.
+     */
+    canRunContinue(request: Pick<BeginCallRequest, "customerId" | "runId">): CircuitBreakerDecision;
+    /**
+     * Release local state after a workflow finishes. Returns true when state existed.
+     */
+    resetRun(request: Pick<BeginCallRequest, "customerId" | "runId">): boolean;
+    promptCompress(request: PromptCompressionRequest, options?: PromptCompressionOptions): Promise<PromptCompressionResult & {
+        callId: string;
+    }>;
+    compressPromptInput<TInput = unknown>(input: TInput, options?: PromptCompressionStandaloneOptions): Promise<PromptCompressionResult<TInput>>;
+    /**
+     * Compress text with UsageTap's hosted compression service.
+     *
+     * This is the short, standalone path. It does not create a metered call and
+     * fails open to the original text unless failOpen is explicitly disabled.
+     */
+    compress(text: string, options?: UsageTapCompressOptions): Promise<UsageTapCompressResult>;
+    compressPromptMessages<TInput = unknown>(input: TInput, options?: PromptCompressionMessagesOptions): Promise<PromptCompressionResult<TInput>>;
+    recordPromptCompression(request: RecordPromptCompressionRequest, options?: PromptCompressionOptions): Promise<UsageTapSuccessResponse<PromptCompressionResponseBody>>;
+    endCall(request: EndCallRequest, options?: EndCallOptions): Promise<UsageTapSuccessResponse<EndCallResponseBody>>;
+    checkUsage(request: CheckUsageRequest, options?: CheckUsageOptions): Promise<UsageTapSuccessResponse<CheckUsageResponseBody>>;
+    createCustomer(request: CreateCustomerRequest, options?: CreateCustomerOptions): Promise<UsageTapSuccessResponse<CreateCustomerResponseBody>>;
+    changePlan(request: ChangePlanRequest, options?: ChangePlanOptions): Promise<UsageTapSuccessResponse<ChangePlanResponseBody>>;
+    incrementCustomMeter(request: IncrementCustomMeterRequest, options?: IncrementCustomMeterOptions): Promise<UsageTapSuccessResponse<IncrementCustomMeterResponseBody>>;
+    withUsage<T>(beginRequest: BeginCallRequest, handler: (context: WithUsageContext) => Promise<T>, options?: WithUsageOptions): Promise<T>;
+    /**
+     * Meter one operation. Pass only a customer ID for the common path, or the
+     * existing begin-call request object when feature, tags, or entitlements are needed.
+     */
+    meter<T>(request: MeterRequest, handler: (context: WithUsageContext) => Promise<T>, options?: WithUsageOptions): Promise<T>;
+    private toPromptCompressionTelemetry;
+    private reserveRunCall;
+    private resolveRunIdentity;
+    private createCircuitBreakerDecision;
+    private expireInactiveRuns;
+    private request;
+    private requestGet;
+    private performFetch;
+    private composeHeaders;
+    private log;
+    private emitUsageMetric;
+    private mergeTags;
+    private shouldRetry;
+    private toHttpError;
+    private toApiError;
+}
+
+export { type PromptCompressionInput as $, type SummarizationBatchCreateParams as A, type BeginCallRequest as B, type SummarizationBatchJob as C, type SummarizationContext as D, type EndCallRequest as E, type SummarizationCreateParams as F, type GatewayBatch as G, type SummarizationJob as H, type SummarizationMeasurement as I, type SummarizationMeasurementCreateParams as J, type SummarizationProfile as K, type SummarizationStatus as L, type MeterRequest as M, type WaitOptions as N, compressPrompt as O, type PromptCompressionProvider as P, compressPromptMessages as Q, type ResourceRequestOptions as R, type SamplingOptions as S, compressPromptHeuristic as T, UsageTapClient as U, type VendorHints as V, type WithUsageOptions as W, compressPromptToon as X, estimatePromptTokens as Y, protect as Z, protectPromptText as _, type PromptCompressionMode as a, type SamplingDecisionRequest as a$, type PromptCompressionMessagesAggressiveness as a0, type PromptCompressionMessagesInput as a1, type PromptCompressionMessageRole as a2, type PromptCompressionResult as a3, type PromptCompressionRoleAggressiveness as a4, type BeginCallOptions as a5, type PromptCompressionRequest as a6, type PromptCompressionOptions as a7, type PromptCompressionMessagesOptions as a8, type PromptCompressionResponseBody as a9, type MeteredUsage as aA, type RateLimitsSnapshot as aB, type RemainingRatios as aC, type RollingCallsRateLimitState as aD, type RequestedEntitlements as aE, type AllowedEntitlements as aF, type ReasoningLevel as aG, type ReasoningEffort as aH, type ReasoningEffortSource as aI, type RetryOptions as aJ, type UsageTapClientOptions as aK, type UsageTapErrorResponse as aL, type UsageTapResultEnvelope as aM, type UsageTapResultStatus as aN, type UsageTapLogEntry as aO, type WithUsageContext as aP, type LimitType as aQ, type SubscriptionSnapshot as aR, type ModelHints as aS, type IdempotencyMetadata as aT, type UsageMetricEvent as aU, type SamplingDecisionInput as aV, type CaptureSampleRequest as aW, type CaptureSampleOptions as aX, type CaptureSampleResponseBody as aY, type SamplingSettings as aZ, type GetSamplingSettingsOptions as a_, type PromptCompressionStandaloneOptions as aa, type RecordPromptCompressionRequest as ab, type CreateCustomerOptions as ac, type CreateCustomerRequest as ad, type CreateCustomerResponseBody as ae, type CheckUsageOptions as af, type CheckUsageRequest as ag, type CheckUsageResponseBody as ah, type ChangePlanOptions as ai, type ChangePlanRequest as aj, type ChangePlanResponseBody as ak, type ChangePlanStrategy as al, type IncrementCustomMeterOptions as am, type IncrementCustomMeterRequest as an, type IncrementCustomMeterResponseBody as ao, type CustomMeterSlot as ap, type EndCallOptions as aq, type EndCallResponseBody as ar, type BalanceSummary as as, type SpendVelocitySnapshot as at, type SpendVelocityWindow as au, type SpendVelocityWindowKey as av, type EntitlementHints as aw, type PlanSummary as ax, type MeterSummary as ay, type MeterSnapshot as az, type PromptCompressionTelemetry as b, type SamplingDecisionResponseBody as b0, type SamplingDecisionOptions as b1, type CircuitBreakerOptions as b2, type CircuitBreakerDecision as b3, type UsageTapSuccessResponse as c, type BeginCallResponseBody as d, type UsageTapCompressOptions as e, type UsageTapCompressResult as f, type GatewayBatchCreateParams as g, type GatewayBatchRequest as h, type GatewayBatchResult as i, type GatewayBatchStatus as j, type GatewayChatCompletion as k, type GatewayChatCompletionCreateParams as l, type GatewayChatMessage as m, type GatewayPromptCacheBreakpoint as n, type GatewayResponse as o, type GatewayResponseCreateParams as p, type GatewayResponseInputItem as q, type GatewayResponseInputMessage as r, type GatewayResponseInputText as s, type GatewayResponsePromptCacheOptions as t, type GatewayResponseTextConfig as u, type GatewayResponseTextFormat as v, type GatewayResponseVerbosity as w, type GatewayModel as x, type GatewayModelList as y, type SummarizationBatch as z };