@openrouter/sdk 0.10.2 → 0.12.0

package/esm/models/operations/getgeneration.js

@@ -6,117 +6,15 @@ import * as z from "zod/v4";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
 import * as openEnums from "../../types/enums.js";
+import * as models from "../index.js";
 /**
  * Type of API used for the generation
  */
 export const ApiType = {
     Completions: "completions",
     Embeddings: "embeddings",
-};
-export const ProviderName = {
-    AnyScale: "AnyScale",
-    Atoma: "Atoma",
-    CentML: "Cent-ML",
-    CrofAI: "CrofAI",
-    Enfer: "Enfer",
-    GoPomelo: "GoPomelo",
-    HuggingFace: "HuggingFace",
-    Hyperbolic2: "Hyperbolic 2",
-    InoCloud: "InoCloud",
-    Kluster: "Kluster",
-    Lambda: "Lambda",
-    Lepton: "Lepton",
-    Lynn2: "Lynn 2",
-    Lynn: "Lynn",
-    Mancer: "Mancer",
-    Meta: "Meta",
-    Modal: "Modal",
-    Nineteen: "Nineteen",
-    OctoAI: "OctoAI",
-    Recursal: "Recursal",
-    Reflection: "Reflection",
-    Replicate: "Replicate",
-    SambaNova2: "SambaNova 2",
-    SFCompute: "SF Compute",
-    Targon: "Targon",
-    Together2: "Together 2",
-    Ubicloud: "Ubicloud",
-    OneDotAI: "01.AI",
-    AkashML: "AkashML",
-    Ai21: "AI21",
-    AionLabs: "AionLabs",
-    Alibaba: "Alibaba",
-    Ambient: "Ambient",
-    AmazonBedrock: "Amazon Bedrock",
-    AmazonNova: "Amazon Nova",
-    Anthropic: "Anthropic",
-    ArceeAI: "Arcee AI",
-    AtlasCloud: "AtlasCloud",
-    Avian: "Avian",
-    Azure: "Azure",
-    BaseTen: "BaseTen",
-    BytePlus: "BytePlus",
-    BlackForestLabs: "Black Forest Labs",
-    Cerebras: "Cerebras",
-    Chutes: "Chutes",
-    Cirrascale: "Cirrascale",
-    Clarifai: "Clarifai",
-    Cloudflare: "Cloudflare",
-    Cohere: "Cohere",
-    Crusoe: "Crusoe",
-    DeepInfra: "DeepInfra",
-    DeepSeek: "DeepSeek",
-    Featherless: "Featherless",
-    Fireworks: "Fireworks",
-    Friendli: "Friendli",
-    GMICloud: "GMICloud",
-    Google: "Google",
-    GoogleAIStudio: "Google AI Studio",
-    Groq: "Groq",
-    Hyperbolic: "Hyperbolic",
-    Inception: "Inception",
-    Inceptron: "Inceptron",
-    InferenceNet: "InferenceNet",
-    Ionstream: "Ionstream",
-    Infermatic: "Infermatic",
-    IoNet: "Io Net",
-    Inflection: "Inflection",
-    Liquid: "Liquid",
-    Mara: "Mara",
-    Mancer2: "Mancer 2",
-    Minimax: "Minimax",
-    ModelRun: "ModelRun",
-    Mistral: "Mistral",
-    Modular: "Modular",
-    MoonshotAI: "Moonshot AI",
-    Morph: "Morph",
-    NCompass: "NCompass",
-    Nebius: "Nebius",
-    NextBit: "NextBit",
-    Novita: "Novita",
-    Nvidia: "Nvidia",
-    OpenAI: "OpenAI",
-    OpenInference: "OpenInference",
-    Parasail: "Parasail",
-    Perplexity: "Perplexity",
-    Phala: "Phala",
-    Relace: "Relace",
-    SambaNova: "SambaNova",
-    Seed: "Seed",
-    SiliconFlow: "SiliconFlow",
-    Sourceful: "Sourceful",
-    StepFun: "StepFun",
-    Stealth: "Stealth",
-    StreamLake: "StreamLake",
-    Switchpoint: "Switchpoint",
-    Together: "Together",
-    Upstage: "Upstage",
-    Venice: "Venice",
-    WandB: "WandB",
-    Xiaomi: "Xiaomi",
-    XAI: "xAI",
-    ZAi: "Z.AI",
-    FakeProvider: "FakeProvider",
+    Rerank: "rerank",
+    Video: "video",
 };
 /** @internal */
 export const GetGenerationRequest$outboundSchema = z.object({
@@ -136,95 +34,77 @@ export function getGenerationRequestToJSON(getGenerationRequest) {
 export const ApiType$inboundSchema = openEnums
     .inboundSchema(ApiType);
 /** @internal */
-export const ProviderName$inboundSchema = openEnums.inboundSchema(ProviderName);
-/** @internal */
-export const ProviderResponse$inboundSchema = z.object({
-    id: z.string().optional(),
-    endpoint_id: z.string().optional(),
-    model_permaslug: z.string().optional(),
-    provider_name: ProviderName$inboundSchema.optional(),
-    status: z.nullable(z.number()),
-    latency: z.number().optional(),
-    is_byok: z.boolean().optional(),
-}).transform((v) => {
-    return remap$(v, {
-        "endpoint_id": "endpointId",
-        "model_permaslug": "modelPermaslug",
-        "provider_name": "providerName",
-        "is_byok": "isByok",
-    });
-});
-export function providerResponseFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => ProviderResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ProviderResponse' from JSON`);
-}
-/** @internal */
 export const GetGenerationData$inboundSchema = z.object({
-    id: z.string(),
-    upstream_id: z.nullable(z.string()),
-    total_cost: z.number(),
-    cache_discount: z.nullable(z.number()),
-    upstream_inference_cost: z.nullable(z.number()),
-    created_at: z.string(),
-    model: z.string(),
-    app_id: z.nullable(z.number()),
-    streamed: z.nullable(z.boolean()),
+    api_type: z.nullable(ApiType$inboundSchema),
+    app_id: z.int(),
+    cache_discount: z.number(),
     cancelled: z.nullable(z.boolean()),
-    provider_name: z.nullable(z.string()),
-    latency: z.nullable(z.number()),
-    moderation_latency: z.nullable(z.number()),
-    generation_time: z.nullable(z.number()),
+    created_at: z.string(),
+    external_user: z.nullable(z.string()),
     finish_reason: z.nullable(z.string()),
-    tokens_prompt: z.nullable(z.number()),
-    tokens_completion: z.nullable(z.number()),
-    native_tokens_prompt: z.nullable(z.number()),
-    native_tokens_completion: z.nullable(z.number()),
-    native_tokens_completion_images: z.nullable(z.number()),
-    native_tokens_reasoning: z.nullable(z.number()),
-    native_tokens_cached: z.nullable(z.number()),
-    num_media_prompt: z.nullable(z.number()),
-    num_input_audio_prompt: z.nullable(z.number()),
-    num_media_completion: z.nullable(z.number()),
-    num_search_results: z.nullable(z.number()),
-    origin: z.string(),
-    usage: z.number(),
+    generation_time: z.number(),
+    http_referer: z.nullable(z.string()),
+    id: z.string(),
     is_byok: z.boolean(),
+    latency: z.number(),
+    model: z.string(),
+    moderation_latency: z.number(),
     native_finish_reason: z.nullable(z.string()),
-    external_user: z.nullable(z.string()),
-    api_type: z.nullable(ApiType$inboundSchema),
+    native_tokens_cached: z.int(),
+    native_tokens_completion: z.int(),
+    native_tokens_completion_images: z.int(),
+    native_tokens_prompt: z.int(),
+    native_tokens_reasoning: z.int(),
+    num_input_audio_prompt: z.int(),
+    num_media_completion: z.int(),
+    num_media_prompt: z.int(),
+    num_search_results: z.int(),
+    origin: z.string(),
+    provider_name: z.nullable(z.string()),
+    provider_responses: z.nullable(z.array(models.ProviderResponse$inboundSchema)),
+    request_id: z.nullable(z.string()).optional(),
     router: z.nullable(z.string()),
-    provider_responses: z.nullable(z.array(z.lazy(() => ProviderResponse$inboundSchema))),
+    session_id: z.nullable(z.string()).optional(),
+    streamed: z.nullable(z.boolean()),
+    tokens_completion: z.int(),
+    tokens_prompt: z.int(),
+    total_cost: z.number(),
+    upstream_id: z.nullable(z.string()),
+    upstream_inference_cost: z.number(),
+    usage: z.number(),
     user_agent: z.nullable(z.string()),
-    http_referer: z.nullable(z.string()),
 }).transform((v) => {
     return remap$(v, {
-        "upstream_id": "upstreamId",
-        "total_cost": "totalCost",
+        "api_type": "apiType",
+        "app_id": "appId",
         "cache_discount": "cacheDiscount",
-        "upstream_inference_cost": "upstreamInferenceCost",
         "created_at": "createdAt",
-        "app_id": "appId",
-        "provider_name": "providerName",
-        "moderation_latency": "moderationLatency",
-        "generation_time": "generationTime",
+        "external_user": "externalUser",
         "finish_reason": "finishReason",
-        "tokens_prompt": "tokensPrompt",
-        "tokens_completion": "tokensCompletion",
-        "native_tokens_prompt": "nativeTokensPrompt",
+        "generation_time": "generationTime",
+        "http_referer": "httpReferer",
+        "is_byok": "isByok",
+        "moderation_latency": "moderationLatency",
+        "native_finish_reason": "nativeFinishReason",
+        "native_tokens_cached": "nativeTokensCached",
         "native_tokens_completion": "nativeTokensCompletion",
         "native_tokens_completion_images": "nativeTokensCompletionImages",
+        "native_tokens_prompt": "nativeTokensPrompt",
         "native_tokens_reasoning": "nativeTokensReasoning",
-        "native_tokens_cached": "nativeTokensCached",
-        "num_media_prompt": "numMediaPrompt",
         "num_input_audio_prompt": "numInputAudioPrompt",
         "num_media_completion": "numMediaCompletion",
+        "num_media_prompt": "numMediaPrompt",
         "num_search_results": "numSearchResults",
-        "is_byok": "isByok",
-        "native_finish_reason": "nativeFinishReason",
-        "external_user": "externalUser",
-        "api_type": "apiType",
+        "provider_name": "providerName",
         "provider_responses": "providerResponses",
+        "request_id": "requestId",
+        "session_id": "sessionId",
+        "tokens_completion": "tokensCompletion",
+        "tokens_prompt": "tokensPrompt",
+        "total_cost": "totalCost",
+        "upstream_id": "upstreamId",
+        "upstream_inference_cost": "upstreamInferenceCost",
         "user_agent": "userAgent",
-        "http_referer": "httpReferer",
     });
 });
 export function getGenerationDataFromJSON(jsonString) {

package/esm/models/operations/getguardrail.d.ts

@@ -1,7 +1,4 @@
 import * as z from "zod/v4";
-import { OpenEnum } from "../../types/enums.js";
-import { Result as SafeParseResult } from "../../types/fp.js";
-import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 export type GetGuardrailGlobals = {
     /**
      * The app identifier should be your app's URL and is used as the primary identifier for rankings.
@@ -48,76 +45,6 @@ export type GetGuardrailRequest = {
      */
     id: string;
 };
-/**
- * Interval at which the limit resets (daily, weekly, monthly)
- */
-export declare const GetGuardrailResetInterval: {
-    readonly Daily: "daily";
-    readonly Weekly: "weekly";
-    readonly Monthly: "monthly";
-};
-/**
- * Interval at which the limit resets (daily, weekly, monthly)
- */
-export type GetGuardrailResetInterval = OpenEnum<typeof GetGuardrailResetInterval>;
-/**
- * The guardrail
- */
-export type GetGuardrailData = {
-    /**
-     * Unique identifier for the guardrail
-     */
-    id: string;
-    /**
-     * Name of the guardrail
-     */
-    name: string;
-    /**
-     * Description of the guardrail
-     */
-    description?: string | null | undefined;
-    /**
-     * Spending limit in USD
-     */
-    limitUsd?: number | null | undefined;
-    /**
-     * Interval at which the limit resets (daily, weekly, monthly)
-     */
-    resetInterval?: GetGuardrailResetInterval | null | undefined;
-    /**
-     * List of allowed provider IDs
-     */
-    allowedProviders?: Array<string> | null | undefined;
-    /**
-     * List of provider IDs to exclude from routing
-     */
-    ignoredProviders?: Array<string> | null | undefined;
-    /**
-     * Array of model canonical_slugs (immutable identifiers)
-     */
-    allowedModels?: Array<string> | null | undefined;
-    /**
-     * Whether to enforce zero data retention
-     */
-    enforceZdr?: boolean | null | undefined;
-    /**
-     * ISO 8601 timestamp of when the guardrail was created
-     */
-    createdAt: string;
-    /**
-     * ISO 8601 timestamp of when the guardrail was last updated
-     */
-    updatedAt?: string | null | undefined;
-};
-/**
- * Guardrail details
- */
-export type GetGuardrailResponse = {
-    /**
-     * The guardrail
-     */
-    data: GetGuardrailData;
-};
 /** @internal */
 export type GetGuardrailRequest$Outbound = {
     "HTTP-Referer"?: string | undefined;
@@ -128,12 +55,4 @@ export type GetGuardrailRequest$Outbound = {
 /** @internal */
 export declare const GetGuardrailRequest$outboundSchema: z.ZodType<GetGuardrailRequest$Outbound, GetGuardrailRequest>;
 export declare function getGuardrailRequestToJSON(getGuardrailRequest: GetGuardrailRequest): string;
-/** @internal */
-export declare const GetGuardrailResetInterval$inboundSchema: z.ZodType<GetGuardrailResetInterval, unknown>;
-/** @internal */
-export declare const GetGuardrailData$inboundSchema: z.ZodType<GetGuardrailData, unknown>;
-export declare function getGuardrailDataFromJSON(jsonString: string): SafeParseResult<GetGuardrailData, SDKValidationError>;
-/** @internal */
-export declare const GetGuardrailResponse$inboundSchema: z.ZodType<GetGuardrailResponse, unknown>;
-export declare function getGuardrailResponseFromJSON(jsonString: string): SafeParseResult<GetGuardrailResponse, SDKValidationError>;
 //# sourceMappingURL=getguardrail.d.ts.map

package/esm/models/operations/getguardrail.js

@@ -4,16 +4,6 @@
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../../lib/primitives.js";
-import { safeParse } from "../../lib/schemas.js";
-import * as openEnums from "../../types/enums.js";
-/**
- * Interval at which the limit resets (daily, weekly, monthly)
- */
-export const GetGuardrailResetInterval = {
-    Daily: "daily",
-    Weekly: "weekly",
-    Monthly: "monthly",
-};
 /** @internal */
 export const GetGuardrailRequest$outboundSchema = z.object({
     httpReferer: z.string().optional(),
@@ -28,42 +18,4 @@ export const GetGuardrailRequest$outboundSchema = z.object({
 export function getGuardrailRequestToJSON(getGuardrailRequest) {
     return JSON.stringify(GetGuardrailRequest$outboundSchema.parse(getGuardrailRequest));
 }
-/** @internal */
-export const GetGuardrailResetInterval$inboundSchema = openEnums.inboundSchema(GetGuardrailResetInterval);
-/** @internal */
-export const GetGuardrailData$inboundSchema = z.object({
-    id: z.string(),
-    name: z.string(),
-    description: z.nullable(z.string()).optional(),
-    limit_usd: z.nullable(z.number()).optional(),
-    reset_interval: z.nullable(GetGuardrailResetInterval$inboundSchema)
-        .optional(),
-    allowed_providers: z.nullable(z.array(z.string())).optional(),
-    ignored_providers: z.nullable(z.array(z.string())).optional(),
-    allowed_models: z.nullable(z.array(z.string())).optional(),
-    enforce_zdr: z.nullable(z.boolean()).optional(),
-    created_at: z.string(),
-    updated_at: z.nullable(z.string()).optional(),
-}).transform((v) => {
-    return remap$(v, {
-        "limit_usd": "limitUsd",
-        "reset_interval": "resetInterval",
-        "allowed_providers": "allowedProviders",
-        "ignored_providers": "ignoredProviders",
-        "allowed_models": "allowedModels",
-        "enforce_zdr": "enforceZdr",
-        "created_at": "createdAt",
-        "updated_at": "updatedAt",
-    });
-});
-export function getGuardrailDataFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => GetGuardrailData$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'GetGuardrailData' from JSON`);
-}
-/** @internal */
-export const GetGuardrailResponse$inboundSchema = z.object({
-    data: z.lazy(() => GetGuardrailData$inboundSchema),
-});
-export function getGuardrailResponseFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => GetGuardrailResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'GetGuardrailResponse' from JSON`);
-}
 //# sourceMappingURL=getguardrail.js.map

package/esm/models/operations/getkey.d.ts

@@ -52,81 +52,85 @@ export type GetKeyRequest = {
  */
 export type GetKeyData = {
     /**
-     * Unique hash identifier for the API key
+     * Total external BYOK usage (in USD) for the API key
      */
-    hash: string;
+    byokUsage: number;
     /**
-     * Name of the API key
+     * External BYOK usage (in USD) for the current UTC day
      */
-    name: string;
+    byokUsageDaily: number;
     /**
-     * Human-readable label for the API key
+     * External BYOK usage (in USD) for current UTC month
      */
-    label: string;
+    byokUsageMonthly: number;
     /**
-     * Whether the API key is disabled
+     * External BYOK usage (in USD) for the current UTC week (Monday-Sunday)
      */
-    disabled: boolean;
+    byokUsageWeekly: number;
     /**
-     * Spending limit for the API key in USD
+     * ISO 8601 timestamp of when the API key was created
      */
-    limit: number | null;
+    createdAt: string;
     /**
-     * Remaining spending limit in USD
+     * The user ID of the key creator. For organization-owned keys, this is the member who created the key. For individual users, this is the user's own ID.
      */
-    limitRemaining: number | null;
+    creatorUserId: string | null;
     /**
-     * Type of limit reset for the API key
+     * Whether the API key is disabled
      */
-    limitReset: string | null;
+    disabled: boolean;
     /**
-     * Whether to include external BYOK usage in the credit limit
+     * ISO 8601 UTC timestamp when the API key expires, or null if no expiration
      */
-    includeByokInLimit: boolean;
+    expiresAt?: Date | null | undefined;
     /**
-     * Total OpenRouter credit usage (in USD) for the API key
+     * Unique hash identifier for the API key
      */
-    usage: number;
+    hash: string;
     /**
-     * OpenRouter credit usage (in USD) for the current UTC day
+     * Whether to include external BYOK usage in the credit limit
      */
-    usageDaily: number;
+    includeByokInLimit: boolean;
     /**
-     * OpenRouter credit usage (in USD) for the current UTC week (Monday-Sunday)
+     * Human-readable label for the API key
      */
-    usageWeekly: number;
+    label: string;
     /**
-     * OpenRouter credit usage (in USD) for the current UTC month
+     * Spending limit for the API key in USD
      */
-    usageMonthly: number;
+    limit: number;
     /**
-     * Total external BYOK usage (in USD) for the API key
+     * Remaining spending limit in USD
      */
-    byokUsage: number;
+    limitRemaining: number;
     /**
-     * External BYOK usage (in USD) for the current UTC day
+     * Type of limit reset for the API key
      */
-    byokUsageDaily: number;
+    limitReset: string | null;
     /**
-     * External BYOK usage (in USD) for the current UTC week (Monday-Sunday)
+     * Name of the API key
      */
-    byokUsageWeekly: number;
+    name: string;
     /**
-     * External BYOK usage (in USD) for current UTC month
+     * ISO 8601 timestamp of when the API key was last updated
      */
-    byokUsageMonthly: number;
+    updatedAt: string | null;
     /**
-     * ISO 8601 timestamp of when the API key was created
+     * Total OpenRouter credit usage (in USD) for the API key
      */
-    createdAt: string;
+    usage: number;
     /**
-     * ISO 8601 timestamp of when the API key was last updated
+     * OpenRouter credit usage (in USD) for the current UTC day
      */
-    updatedAt: string | null;
+    usageDaily: number;
     /**
-     * ISO 8601 UTC timestamp when the API key expires, or null if no expiration
+     * OpenRouter credit usage (in USD) for the current UTC month
      */
-    expiresAt?: Date | null | undefined;
+    usageMonthly: number;
+    /**
+     * OpenRouter credit usage (in USD) for the current UTC week (Monday-Sunday)
+     */
+    usageWeekly: number;
 };
 /**
  * API key details

package/esm/models/operations/getkey.js

@@ -22,40 +22,42 @@ export function getKeyRequestToJSON(getKeyRequest) {
 /** @internal */
 export const GetKeyData$inboundSchema = z
     .object({
+    byok_usage: z.number(),
+    byok_usage_daily: z.number(),
+    byok_usage_monthly: z.number(),
+    byok_usage_weekly: z.number(),
+    created_at: z.string(),
+    creator_user_id: z.nullable(z.string()),
+    disabled: z.boolean(),
+    expires_at: z.nullable(z.iso.datetime({ offset: true }).transform(v => new Date(v))).optional(),
     hash: z.string(),
-    name: z.string(),
+    include_byok_in_limit: z.boolean(),
     label: z.string(),
-    disabled: z.boolean(),
-    limit: z.nullable(z.number()),
-    limit_remaining: z.nullable(z.number()),
+    limit: z.number(),
+    limit_remaining: z.number(),
     limit_reset: z.nullable(z.string()),
-    include_byok_in_limit: z.boolean(),
+    name: z.string(),
+    updated_at: z.nullable(z.string()),
     usage: z.number(),
     usage_daily: z.number(),
-    usage_weekly: z.number(),
     usage_monthly: z.number(),
-    byok_usage: z.number(),
-    byok_usage_daily: z.number(),
-    byok_usage_weekly: z.number(),
-    byok_usage_monthly: z.number(),
-    created_at: z.string(),
-    updated_at: z.nullable(z.string()),
-    expires_at: z.nullable(z.iso.datetime({ offset: true }).transform(v => new Date(v))).optional(),
+    usage_weekly: z.number(),
 }).transform((v) => {
     return remap$(v, {
-        "limit_remaining": "limitRemaining",
-        "limit_reset": "limitReset",
-        "include_byok_in_limit": "includeByokInLimit",
-        "usage_daily": "usageDaily",
-        "usage_weekly": "usageWeekly",
-        "usage_monthly": "usageMonthly",
         "byok_usage": "byokUsage",
         "byok_usage_daily": "byokUsageDaily",
-        "byok_usage_weekly": "byokUsageWeekly",
         "byok_usage_monthly": "byokUsageMonthly",
+        "byok_usage_weekly": "byokUsageWeekly",
         "created_at": "createdAt",
-        "updated_at": "updatedAt",
+        "creator_user_id": "creatorUserId",
         "expires_at": "expiresAt",
+        "include_byok_in_limit": "includeByokInLimit",
+        "limit_remaining": "limitRemaining",
+        "limit_reset": "limitReset",
+        "updated_at": "updatedAt",
+        "usage_daily": "usageDaily",
+        "usage_monthly": "usageMonthly",
+        "usage_weekly": "usageWeekly",
     });
 });
 export function getKeyDataFromJSON(jsonString) {

package/esm/models/operations/getmodels.d.ts

@@ -66,6 +66,9 @@ export type GetModelsRequest = {
      * Filter models by use case category
      */
     category?: Category | undefined;
+    /**
+     * Filter models by supported parameter (comma-separated)
+     */
     supportedParameters?: string | undefined;
     /**
      * Filter models by output modality. Accepts a comma-separated list of modalities (text, image, audio, embeddings) or "all" to include all models. Defaults to "text".

package/esm/models/operations/getuseractivity.d.ts

@@ -1,7 +1,4 @@
 import * as z from "zod/v4";
-import { Result as SafeParseResult } from "../../types/fp.js";
-import { SDKValidationError } from "../errors/sdkvalidationerror.js";
-import * as models from "../index.js";
 export type GetUserActivityGlobals = {
     /**
      * The app identifier should be your app's URL and is used as the primary identifier for rankings.
@@ -47,15 +44,14 @@ export type GetUserActivityRequest = {
      * Filter by a single UTC date in the last 30 days (YYYY-MM-DD format).
      */
     date?: string | undefined;
-};
-/**
- * Returns user activity data grouped by endpoint
- */
-export type GetUserActivityResponse = {
     /**
-     * List of activity items
+     * Filter by API key hash (SHA-256 hex string, as returned by the keys API).
+     */
+    apiKeyHash?: string | undefined;
+    /**
+     * Filter by org member user ID. Only applicable for organization accounts.
      */
-    data: Array<models.ActivityItem>;
+    userId?: string | undefined;
 };
 /** @internal */
 export type GetUserActivityRequest$Outbound = {
@@ -63,11 +59,10 @@ export type GetUserActivityRequest$Outbound = {
     appTitle?: string | undefined;
     appCategories?: string | undefined;
     date?: string | undefined;
+    api_key_hash?: string | undefined;
+    user_id?: string | undefined;
 };
 /** @internal */
 export declare const GetUserActivityRequest$outboundSchema: z.ZodType<GetUserActivityRequest$Outbound, GetUserActivityRequest>;
 export declare function getUserActivityRequestToJSON(getUserActivityRequest: GetUserActivityRequest): string;
-/** @internal */
-export declare const GetUserActivityResponse$inboundSchema: z.ZodType<GetUserActivityResponse, unknown>;
-export declare function getUserActivityResponseFromJSON(jsonString: string): SafeParseResult<GetUserActivityResponse, SDKValidationError>;
 //# sourceMappingURL=getuseractivity.d.ts.map