@openrouter/sdk 0.0.0-beta.37 → 0.0.0-beta.39

package/src/models/operations/update.ts

@@ -5,8 +5,27 @@
 import * as z from "zod";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
+import {
+  catchUnrecognizedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import * as models from "../index.js";
+
+/**
+ * New limit reset type for the API key (daily, weekly, monthly, or null for no reset). Resets happen automatically at midnight UTC, and weeks are Monday through Sunday.
+ */
+export const UpdateLimitReset = {
+  Daily: "daily",
+  Weekly: "weekly",
+  Monthly: "monthly",
+} as const;
+/**
+ * New limit reset type for the API key (daily, weekly, monthly, or null for no reset). Resets happen automatically at midnight UTC, and weeks are Monday through Sunday.
+ */
+export type UpdateLimitReset = OpenEnum<typeof UpdateLimitReset>;
 
 export type UpdateRequestBody = {
   /**
@@ -21,6 +40,10 @@ export type UpdateRequestBody = {
    * New spending limit for the API key in USD
    */
   limit?: number | null | undefined;
+  /**
+   * New limit reset type for the API key (daily, weekly, monthly, or null for no reset). Resets happen automatically at midnight UTC, and weeks are Monday through Sunday.
+   */
+  limitReset?: UpdateLimitReset | null | undefined;
   /**
    * Whether to include BYOK usage in the limit
    */
@@ -32,44 +55,6 @@ export type UpdateRequest = {
   requestBody: UpdateRequestBody;
 };
 
-/**
- * The updated API key information
- */
-export type UpdateData = {
-  /**
-   * Unique hash identifier for the API key
-   */
-  hash: string;
-  /**
-   * Name of the API key
-   */
-  name: string;
-  /**
-   * Human-readable label for the API key
-   */
-  label: string;
-  /**
-   * Whether the API key is disabled
-   */
-  disabled: boolean;
-  /**
-   * Spending limit for the API key in USD
-   */
-  limit: number | null;
-  /**
-   * Current usage of the API key in USD
-   */
-  usage: number;
-  /**
-   * ISO 8601 timestamp of when the API key was created
-   */
-  createdAt: string;
-  /**
-   * ISO 8601 timestamp of when the API key was last updated
-   */
-  updatedAt: string | null;
-};
-
 /**
  * API key updated successfully
  */
@@ -77,9 +62,41 @@ export type UpdateResponse = {
   /**
    * The updated API key information
    */
-  data: UpdateData;
+  data: models.UpdateAPIKeyData;
 };
 
+/** @internal */
+export const UpdateLimitReset$inboundSchema: z.ZodType<
+  UpdateLimitReset,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(UpdateLimitReset),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
+
+/** @internal */
+export const UpdateLimitReset$outboundSchema: z.ZodType<
+  UpdateLimitReset,
+  z.ZodTypeDef,
+  UpdateLimitReset
+> = z.union([
+  z.nativeEnum(UpdateLimitReset),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace UpdateLimitReset$ {
+  /** @deprecated use `UpdateLimitReset$inboundSchema` instead. */
+  export const inboundSchema = UpdateLimitReset$inboundSchema;
+  /** @deprecated use `UpdateLimitReset$outboundSchema` instead. */
+  export const outboundSchema = UpdateLimitReset$outboundSchema;
+}
+
 /** @internal */
 export const UpdateRequestBody$inboundSchema: z.ZodType<
   UpdateRequestBody,
@@ -89,9 +106,11 @@ export const UpdateRequestBody$inboundSchema: z.ZodType<
   name: z.string().optional(),
   disabled: z.boolean().optional(),
   limit: z.nullable(z.number()).optional(),
+  limit_reset: z.nullable(UpdateLimitReset$inboundSchema).optional(),
   include_byok_in_limit: z.boolean().optional(),
 }).transform((v) => {
   return remap$(v, {
+    "limit_reset": "limitReset",
     "include_byok_in_limit": "includeByokInLimit",
   });
 });
@@ -101,6 +120,7 @@ export type UpdateRequestBody$Outbound = {
   name?: string | undefined;
   disabled?: boolean | undefined;
   limit?: number | null | undefined;
+  limit_reset?: string | null | undefined;
   include_byok_in_limit?: boolean | undefined;
 };
 
@@ -113,9 +133,11 @@ export const UpdateRequestBody$outboundSchema: z.ZodType<
   name: z.string().optional(),
   disabled: z.boolean().optional(),
   limit: z.nullable(z.number()).optional(),
+  limitReset: z.nullable(UpdateLimitReset$outboundSchema).optional(),
   includeByokInLimit: z.boolean().optional(),
 }).transform((v) => {
   return remap$(v, {
+    limitReset: "limit_reset",
     includeByokInLimit: "include_byok_in_limit",
   });
 });
@@ -212,99 +234,18 @@ export function updateRequestFromJSON(
   );
 }
 
-/** @internal */
-export const UpdateData$inboundSchema: z.ZodType<
-  UpdateData,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  hash: z.string(),
-  name: z.string(),
-  label: z.string(),
-  disabled: z.boolean(),
-  limit: z.nullable(z.number()),
-  usage: z.number(),
-  created_at: z.string(),
-  updated_at: z.nullable(z.string()),
-}).transform((v) => {
-  return remap$(v, {
-    "created_at": "createdAt",
-    "updated_at": "updatedAt",
-  });
-});
-
-/** @internal */
-export type UpdateData$Outbound = {
-  hash: string;
-  name: string;
-  label: string;
-  disabled: boolean;
-  limit: number | null;
-  usage: number;
-  created_at: string;
-  updated_at: string | null;
-};
-
-/** @internal */
-export const UpdateData$outboundSchema: z.ZodType<
-  UpdateData$Outbound,
-  z.ZodTypeDef,
-  UpdateData
-> = z.object({
-  hash: z.string(),
-  name: z.string(),
-  label: z.string(),
-  disabled: z.boolean(),
-  limit: z.nullable(z.number()),
-  usage: z.number(),
-  createdAt: z.string(),
-  updatedAt: z.nullable(z.string()),
-}).transform((v) => {
-  return remap$(v, {
-    createdAt: "created_at",
-    updatedAt: "updated_at",
-  });
-});
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace UpdateData$ {
-  /** @deprecated use `UpdateData$inboundSchema` instead. */
-  export const inboundSchema = UpdateData$inboundSchema;
-  /** @deprecated use `UpdateData$outboundSchema` instead. */
-  export const outboundSchema = UpdateData$outboundSchema;
-  /** @deprecated use `UpdateData$Outbound` instead. */
-  export type Outbound = UpdateData$Outbound;
-}
-
-export function updateDataToJSON(updateData: UpdateData): string {
-  return JSON.stringify(UpdateData$outboundSchema.parse(updateData));
-}
-
-export function updateDataFromJSON(
-  jsonString: string,
-): SafeParseResult<UpdateData, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => UpdateData$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'UpdateData' from JSON`,
-  );
-}
-
 /** @internal */
 export const UpdateResponse$inboundSchema: z.ZodType<
   UpdateResponse,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  data: z.lazy(() => UpdateData$inboundSchema),
+  data: models.UpdateAPIKeyData$inboundSchema,
 });
 
 /** @internal */
 export type UpdateResponse$Outbound = {
-  data: UpdateData$Outbound;
+  data: models.UpdateAPIKeyData$Outbound;
 };
 
 /** @internal */
@@ -313,7 +254,7 @@ export const UpdateResponse$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   UpdateResponse
 > = z.object({
-  data: z.lazy(() => UpdateData$outboundSchema),
+  data: models.UpdateAPIKeyData$outboundSchema,
 });
 
 /**

package/src/models/responsefunctioncallstatus.ts

@@ -3,26 +3,41 @@
  */
 
 import * as z from "zod";
-import { ClosedEnum } from "../types/enums.js";
+import {
+  catchUnrecognizedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../types/enums.js";
 
 export const ResponseFunctionCallStatus = {
   InProgress: "in_progress",
   Completed: "completed",
   Incomplete: "incomplete",
 } as const;
-export type ResponseFunctionCallStatus = ClosedEnum<
+export type ResponseFunctionCallStatus = OpenEnum<
   typeof ResponseFunctionCallStatus
 >;
 
 /** @internal */
-export const ResponseFunctionCallStatus$inboundSchema: z.ZodNativeEnum<
-  typeof ResponseFunctionCallStatus
-> = z.nativeEnum(ResponseFunctionCallStatus);
+export const ResponseFunctionCallStatus$inboundSchema: z.ZodType<
+  ResponseFunctionCallStatus,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ResponseFunctionCallStatus),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ResponseFunctionCallStatus$outboundSchema: z.ZodNativeEnum<
-  typeof ResponseFunctionCallStatus
-> = ResponseFunctionCallStatus$inboundSchema;
+export const ResponseFunctionCallStatus$outboundSchema: z.ZodType<
+  ResponseFunctionCallStatus,
+  z.ZodTypeDef,
+  ResponseFunctionCallStatus
+> = z.union([
+  z.nativeEnum(ResponseFunctionCallStatus),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/models/responseimagegenerationcallstatus.ts

@@ -3,7 +3,11 @@
  */
 
 import * as z from "zod";
-import { ClosedEnum } from "../types/enums.js";
+import {
+  catchUnrecognizedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../types/enums.js";
 
 export const ResponseImageGenerationCallStatus = {
   InProgress: "in_progress",
@@ -11,19 +15,30 @@ export const ResponseImageGenerationCallStatus = {
   Generating: "generating",
   Failed: "failed",
 } as const;
-export type ResponseImageGenerationCallStatus = ClosedEnum<
+export type ResponseImageGenerationCallStatus = OpenEnum<
   typeof ResponseImageGenerationCallStatus
 >;
 
 /** @internal */
-export const ResponseImageGenerationCallStatus$inboundSchema: z.ZodNativeEnum<
-  typeof ResponseImageGenerationCallStatus
-> = z.nativeEnum(ResponseImageGenerationCallStatus);
+export const ResponseImageGenerationCallStatus$inboundSchema: z.ZodType<
+  ResponseImageGenerationCallStatus,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ResponseImageGenerationCallStatus),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ResponseImageGenerationCallStatus$outboundSchema: z.ZodNativeEnum<
-  typeof ResponseImageGenerationCallStatus
-> = ResponseImageGenerationCallStatus$inboundSchema;
+export const ResponseImageGenerationCallStatus$outboundSchema: z.ZodType<
+  ResponseImageGenerationCallStatus,
+  z.ZodTypeDef,
+  ResponseImageGenerationCallStatus
+> = z.union([
+  z.nativeEnum(ResponseImageGenerationCallStatus),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/models/responseincludable.ts

@@ -3,7 +3,11 @@
  */
 
 import * as z from "zod";
-import { ClosedEnum } from "../types/enums.js";
+import {
+  catchUnrecognizedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../types/enums.js";
 
 /**
  * Includable fields for response
@@ -18,17 +22,28 @@ export const ResponseIncludable = {
 /**
  * Includable fields for response
  */
-export type ResponseIncludable = ClosedEnum<typeof ResponseIncludable>;
+export type ResponseIncludable = OpenEnum<typeof ResponseIncludable>;
 
 /** @internal */
-export const ResponseIncludable$inboundSchema: z.ZodNativeEnum<
-  typeof ResponseIncludable
-> = z.nativeEnum(ResponseIncludable);
+export const ResponseIncludable$inboundSchema: z.ZodType<
+  ResponseIncludable,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ResponseIncludable),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ResponseIncludable$outboundSchema: z.ZodNativeEnum<
-  typeof ResponseIncludable
-> = ResponseIncludable$inboundSchema;
+export const ResponseIncludable$outboundSchema: z.ZodType<
+  ResponseIncludable,
+  z.ZodTypeDef,
+  ResponseIncludable
+> = z.union([
+  z.nativeEnum(ResponseIncludable),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/models/responseinputimagedetail.ts

@@ -3,26 +3,41 @@
  */
 
 import * as z from "zod";
-import { ClosedEnum } from "../types/enums.js";
+import {
+  catchUnrecognizedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../types/enums.js";
 
 export const ResponseInputImageDetail = {
   Auto: "auto",
   High: "high",
   Low: "low",
 } as const;
-export type ResponseInputImageDetail = ClosedEnum<
+export type ResponseInputImageDetail = OpenEnum<
   typeof ResponseInputImageDetail
 >;
 
 /** @internal */
-export const ResponseInputImageDetail$inboundSchema: z.ZodNativeEnum<
-  typeof ResponseInputImageDetail
-> = z.nativeEnum(ResponseInputImageDetail);
+export const ResponseInputImageDetail$inboundSchema: z.ZodType<
+  ResponseInputImageDetail,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ResponseInputImageDetail),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ResponseInputImageDetail$outboundSchema: z.ZodNativeEnum<
-  typeof ResponseInputImageDetail
-> = ResponseInputImageDetail$inboundSchema;
+export const ResponseInputImageDetail$outboundSchema: z.ZodType<
+  ResponseInputImageDetail,
+  z.ZodTypeDef,
+  ResponseInputImageDetail
+> = z.union([
+  z.nativeEnum(ResponseInputImageDetail),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/models/responsereasoningconfig.ts

@@ -5,7 +5,11 @@
 import * as z from "zod";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-import { ClosedEnum } from "../types/enums.js";
+import {
+  catchUnrecognizedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import {
@@ -20,7 +24,7 @@ export const ResponseReasoningConfigEffort = {
   Low: "low",
   Minimal: "minimal",
 } as const;
-export type ResponseReasoningConfigEffort = ClosedEnum<
+export type ResponseReasoningConfigEffort = OpenEnum<
   typeof ResponseReasoningConfigEffort
 >;
 
@@ -35,14 +39,25 @@ export type ResponseReasoningConfig = {
 };
 
 /** @internal */
-export const ResponseReasoningConfigEffort$inboundSchema: z.ZodNativeEnum<
-  typeof ResponseReasoningConfigEffort
-> = z.nativeEnum(ResponseReasoningConfigEffort);
+export const ResponseReasoningConfigEffort$inboundSchema: z.ZodType<
+  ResponseReasoningConfigEffort,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ResponseReasoningConfigEffort),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ResponseReasoningConfigEffort$outboundSchema: z.ZodNativeEnum<
-  typeof ResponseReasoningConfigEffort
-> = ResponseReasoningConfigEffort$inboundSchema;
+export const ResponseReasoningConfigEffort$outboundSchema: z.ZodType<
+  ResponseReasoningConfigEffort,
+  z.ZodTypeDef,
+  ResponseReasoningConfigEffort
+> = z.union([
+  z.nativeEnum(ResponseReasoningConfigEffort),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/models/responsereasoningsummarymode.ts

@@ -3,26 +3,41 @@
  */
 
 import * as z from "zod";
-import { ClosedEnum } from "../types/enums.js";
+import {
+  catchUnrecognizedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../types/enums.js";
 
 export const ResponseReasoningSummaryMode = {
   Auto: "auto",
   Concise: "concise",
   Detailed: "detailed",
 } as const;
-export type ResponseReasoningSummaryMode = ClosedEnum<
+export type ResponseReasoningSummaryMode = OpenEnum<
   typeof ResponseReasoningSummaryMode
 >;
 
 /** @internal */
-export const ResponseReasoningSummaryMode$inboundSchema: z.ZodNativeEnum<
-  typeof ResponseReasoningSummaryMode
-> = z.nativeEnum(ResponseReasoningSummaryMode);
+export const ResponseReasoningSummaryMode$inboundSchema: z.ZodType<
+  ResponseReasoningSummaryMode,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ResponseReasoningSummaryMode),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ResponseReasoningSummaryMode$outboundSchema: z.ZodNativeEnum<
-  typeof ResponseReasoningSummaryMode
-> = ResponseReasoningSummaryMode$inboundSchema;
+export const ResponseReasoningSummaryMode$outboundSchema: z.ZodType<
+  ResponseReasoningSummaryMode,
+  z.ZodTypeDef,
+  ResponseReasoningSummaryMode
+> = z.union([
+  z.nativeEnum(ResponseReasoningSummaryMode),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal

package/src/models/responsesincompletedetails.ts

@@ -4,7 +4,11 @@
 
 import * as z from "zod";
 import { safeParse } from "../lib/schemas.js";
-import { ClosedEnum } from "../types/enums.js";
+import {
+  catchUnrecognizedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
@@ -12,7 +16,7 @@ export const ResponsesIncompleteDetailsReason = {
   MaxOutputTokens: "max_output_tokens",
   ContentFilter: "content_filter",
 } as const;
-export type ResponsesIncompleteDetailsReason = ClosedEnum<
+export type ResponsesIncompleteDetailsReason = OpenEnum<
   typeof ResponsesIncompleteDetailsReason
 >;
 
@@ -24,14 +28,25 @@ export type ResponsesIncompleteDetails = {
 };
 
 /** @internal */
-export const ResponsesIncompleteDetailsReason$inboundSchema: z.ZodNativeEnum<
-  typeof ResponsesIncompleteDetailsReason
-> = z.nativeEnum(ResponsesIncompleteDetailsReason);
+export const ResponsesIncompleteDetailsReason$inboundSchema: z.ZodType<
+  ResponsesIncompleteDetailsReason,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(ResponsesIncompleteDetailsReason),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const ResponsesIncompleteDetailsReason$outboundSchema: z.ZodNativeEnum<
-  typeof ResponsesIncompleteDetailsReason
-> = ResponsesIncompleteDetailsReason$inboundSchema;
+export const ResponsesIncompleteDetailsReason$outboundSchema: z.ZodType<
+  ResponsesIncompleteDetailsReason,
+  z.ZodTypeDef,
+  ResponsesIncompleteDetailsReason
+> = z.union([
+  z.nativeEnum(ResponsesIncompleteDetailsReason),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal