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

package/src/models/operations/create.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";
+
+/**
+ * Type of limit reset 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 CreateLimitReset = {
+  Daily: "daily",
+  Weekly: "weekly",
+  Monthly: "monthly",
+} as const;
+/**
+ * Type of limit reset 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 CreateLimitReset = OpenEnum<typeof CreateLimitReset>;
 
 export type CreateRequest = {
   /**
@@ -18,47 +37,13 @@ export type CreateRequest = {
    */
   limit?: number | null | undefined;
   /**
-   * Whether to include BYOK usage in the limit
-   */
-  includeByokInLimit?: boolean | undefined;
-};
-
-/**
- * The created API key information
- */
-export type CreateData = {
-  /**
-   * 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
+   * Type of limit reset for the API key (daily, weekly, monthly, or null for no reset). Resets happen automatically at midnight UTC, and weeks are Monday through Sunday.
    */
-  disabled: boolean;
+  limitReset?: CreateLimitReset | null | undefined;
   /**
-   * 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
+   * Whether to include BYOK usage in the limit
    */
-  updatedAt: string | null;
+  includeByokInLimit?: boolean | undefined;
 };
 
 /**
@@ -68,13 +53,45 @@ export type CreateResponse = {
   /**
    * The created API key information
    */
-  data: CreateData;
+  data: models.CreateAPIKeyData;
   /**
    * The actual API key string (only shown once)
    */
   key: string;
 };
 
+/** @internal */
+export const CreateLimitReset$inboundSchema: z.ZodType<
+  CreateLimitReset,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(CreateLimitReset),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
+
+/** @internal */
+export const CreateLimitReset$outboundSchema: z.ZodType<
+  CreateLimitReset,
+  z.ZodTypeDef,
+  CreateLimitReset
+> = z.union([
+  z.nativeEnum(CreateLimitReset),
+  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 CreateLimitReset$ {
+  /** @deprecated use `CreateLimitReset$inboundSchema` instead. */
+  export const inboundSchema = CreateLimitReset$inboundSchema;
+  /** @deprecated use `CreateLimitReset$outboundSchema` instead. */
+  export const outboundSchema = CreateLimitReset$outboundSchema;
+}
+
 /** @internal */
 export const CreateRequest$inboundSchema: z.ZodType<
   CreateRequest,
@@ -83,9 +100,11 @@ export const CreateRequest$inboundSchema: z.ZodType<
 > = z.object({
   name: z.string(),
   limit: z.nullable(z.number()).optional(),
+  limit_reset: z.nullable(CreateLimitReset$inboundSchema).optional(),
   include_byok_in_limit: z.boolean().optional(),
 }).transform((v) => {
   return remap$(v, {
+    "limit_reset": "limitReset",
     "include_byok_in_limit": "includeByokInLimit",
   });
 });
@@ -94,6 +113,7 @@ export const CreateRequest$inboundSchema: z.ZodType<
 export type CreateRequest$Outbound = {
   name: string;
   limit?: number | null | undefined;
+  limit_reset?: string | null | undefined;
   include_byok_in_limit?: boolean | undefined;
 };
 
@@ -105,9 +125,11 @@ export const CreateRequest$outboundSchema: z.ZodType<
 > = z.object({
   name: z.string(),
   limit: z.nullable(z.number()).optional(),
+  limitReset: z.nullable(CreateLimitReset$outboundSchema).optional(),
   includeByokInLimit: z.boolean().optional(),
 }).transform((v) => {
   return remap$(v, {
+    limitReset: "limit_reset",
     includeByokInLimit: "include_byok_in_limit",
   });
 });
@@ -139,100 +161,19 @@ export function createRequestFromJSON(
   );
 }
 
-/** @internal */
-export const CreateData$inboundSchema: z.ZodType<
-  CreateData,
-  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 CreateData$Outbound = {
-  hash: string;
-  name: string;
-  label: string;
-  disabled: boolean;
-  limit: number | null;
-  usage: number;
-  created_at: string;
-  updated_at: string | null;
-};
-
-/** @internal */
-export const CreateData$outboundSchema: z.ZodType<
-  CreateData$Outbound,
-  z.ZodTypeDef,
-  CreateData
-> = 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 CreateData$ {
-  /** @deprecated use `CreateData$inboundSchema` instead. */
-  export const inboundSchema = CreateData$inboundSchema;
-  /** @deprecated use `CreateData$outboundSchema` instead. */
-  export const outboundSchema = CreateData$outboundSchema;
-  /** @deprecated use `CreateData$Outbound` instead. */
-  export type Outbound = CreateData$Outbound;
-}
-
-export function createDataToJSON(createData: CreateData): string {
-  return JSON.stringify(CreateData$outboundSchema.parse(createData));
-}
-
-export function createDataFromJSON(
-  jsonString: string,
-): SafeParseResult<CreateData, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => CreateData$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'CreateData' from JSON`,
-  );
-}
-
 /** @internal */
 export const CreateResponse$inboundSchema: z.ZodType<
   CreateResponse,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  data: z.lazy(() => CreateData$inboundSchema),
+  data: models.CreateAPIKeyData$inboundSchema,
   key: z.string(),
 });
 
 /** @internal */
 export type CreateResponse$Outbound = {
-  data: CreateData$Outbound;
+  data: models.CreateAPIKeyData$Outbound;
   key: string;
 };
 
@@ -242,7 +183,7 @@ export const CreateResponse$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   CreateResponse
 > = z.object({
-  data: z.lazy(() => CreateData$outboundSchema),
+  data: models.CreateAPIKeyData$outboundSchema,
   key: z.string(),
 });
 

package/src/models/operations/createauthorizationcode.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";
 
@@ -19,7 +23,7 @@ export const CreateAuthorizationCodeCodeChallengeMethod = {
 /**
  * The method used to generate the code challenge
  */
-export type CreateAuthorizationCodeCodeChallengeMethod = ClosedEnum<
+export type CreateAuthorizationCodeCodeChallengeMethod = OpenEnum<
   typeof CreateAuthorizationCodeCodeChallengeMethod
 >;
 
@@ -72,13 +76,23 @@ export type CreateAuthorizationCodeResponse = {
 
 /** @internal */
 export const CreateAuthorizationCodeCodeChallengeMethod$inboundSchema:
-  z.ZodNativeEnum<typeof CreateAuthorizationCodeCodeChallengeMethod> = z
-    .nativeEnum(CreateAuthorizationCodeCodeChallengeMethod);
+  z.ZodType<CreateAuthorizationCodeCodeChallengeMethod, z.ZodTypeDef, unknown> =
+    z
+      .union([
+        z.nativeEnum(CreateAuthorizationCodeCodeChallengeMethod),
+        z.string().transform(catchUnrecognizedEnum),
+      ]);
 
 /** @internal */
 export const CreateAuthorizationCodeCodeChallengeMethod$outboundSchema:
-  z.ZodNativeEnum<typeof CreateAuthorizationCodeCodeChallengeMethod> =
-    CreateAuthorizationCodeCodeChallengeMethod$inboundSchema;
+  z.ZodType<
+    CreateAuthorizationCodeCodeChallengeMethod,
+    z.ZodTypeDef,
+    CreateAuthorizationCodeCodeChallengeMethod
+  > = z.union([
+    z.nativeEnum(CreateAuthorizationCodeCodeChallengeMethod),
+    z.string().and(z.custom<Unrecognized<string>>()),
+  ]);
 
 /**
  * @internal

package/src/models/operations/exchangeauthorizationcode.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";
 
@@ -19,7 +23,7 @@ export const ExchangeAuthorizationCodeCodeChallengeMethod = {
 /**
  * The method used to generate the code challenge
  */
-export type ExchangeAuthorizationCodeCodeChallengeMethod = ClosedEnum<
+export type ExchangeAuthorizationCodeCodeChallengeMethod = OpenEnum<
   typeof ExchangeAuthorizationCodeCodeChallengeMethod
 >;
 
@@ -56,13 +60,26 @@ export type ExchangeAuthorizationCodeResponse = {
 
 /** @internal */
 export const ExchangeAuthorizationCodeCodeChallengeMethod$inboundSchema:
-  z.ZodNativeEnum<typeof ExchangeAuthorizationCodeCodeChallengeMethod> = z
-    .nativeEnum(ExchangeAuthorizationCodeCodeChallengeMethod);
+  z.ZodType<
+    ExchangeAuthorizationCodeCodeChallengeMethod,
+    z.ZodTypeDef,
+    unknown
+  > = z
+    .union([
+      z.nativeEnum(ExchangeAuthorizationCodeCodeChallengeMethod),
+      z.string().transform(catchUnrecognizedEnum),
+    ]);
 
 /** @internal */
 export const ExchangeAuthorizationCodeCodeChallengeMethod$outboundSchema:
-  z.ZodNativeEnum<typeof ExchangeAuthorizationCodeCodeChallengeMethod> =
-    ExchangeAuthorizationCodeCodeChallengeMethod$inboundSchema;
+  z.ZodType<
+    ExchangeAuthorizationCodeCodeChallengeMethod,
+    z.ZodTypeDef,
+    ExchangeAuthorizationCodeCodeChallengeMethod
+  > = z.union([
+    z.nativeEnum(ExchangeAuthorizationCodeCodeChallengeMethod),
+    z.string().and(z.custom<Unrecognized<string>>()),
+  ]);
 
 /**
  * @internal

package/src/models/operations/generate.ts

@@ -5,7 +5,12 @@
 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,
+  ClosedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
@@ -33,7 +38,7 @@ export const GenerateDataCollection = {
  * - allow: (default) allow providers which store user data non-transiently and may train on it
  * - deny: use only providers which do not collect user data.
  */
-export type GenerateDataCollection = ClosedEnum<typeof GenerateDataCollection>;
+export type GenerateDataCollection = OpenEnum<typeof GenerateDataCollection>;
 
 export const GenerateOrderEnum = {
   AnyScale: "AnyScale",
@@ -119,7 +124,7 @@ export const GenerateOrderEnum = {
   ZAi: "Z.AI",
   FakeProvider: "FakeProvider",
 } as const;
-export type GenerateOrderEnum = ClosedEnum<typeof GenerateOrderEnum>;
+export type GenerateOrderEnum = OpenEnum<typeof GenerateOrderEnum>;
 
 export type GenerateOrderUnion = GenerateOrderEnum | string;
 
@@ -207,7 +212,7 @@ export const GenerateOnlyEnum = {
   ZAi: "Z.AI",
   FakeProvider: "FakeProvider",
 } as const;
-export type GenerateOnlyEnum = ClosedEnum<typeof GenerateOnlyEnum>;
+export type GenerateOnlyEnum = OpenEnum<typeof GenerateOnlyEnum>;
 
 export type GenerateOnlyUnion = GenerateOnlyEnum | string;
 
@@ -295,7 +300,7 @@ export const GenerateIgnoreEnum = {
   ZAi: "Z.AI",
   FakeProvider: "FakeProvider",
 } as const;
-export type GenerateIgnoreEnum = ClosedEnum<typeof GenerateIgnoreEnum>;
+export type GenerateIgnoreEnum = OpenEnum<typeof GenerateIgnoreEnum>;
 
 export type GenerateIgnoreUnion = GenerateIgnoreEnum | string;
 
@@ -310,7 +315,7 @@ export const GenerateQuantization = {
   Fp32: "fp32",
   Unknown: "unknown",
 } as const;
-export type GenerateQuantization = ClosedEnum<typeof GenerateQuantization>;
+export type GenerateQuantization = OpenEnum<typeof GenerateQuantization>;
 
 /**
  * The sorting strategy to use for this request, if "order" is not specified. When set, no load balancing is performed.
@@ -323,7 +328,7 @@ export const GenerateSort = {
 /**
  * The sorting strategy to use for this request, if "order" is not specified. When set, no load balancing is performed.
  */
-export type GenerateSort = ClosedEnum<typeof GenerateSort>;
+export type GenerateSort = OpenEnum<typeof GenerateSort>;
 
 export type GeneratePrompt = number | string | any;
 
@@ -509,14 +514,25 @@ export function inputFromJSON(
 }
 
 /** @internal */
-export const GenerateDataCollection$inboundSchema: z.ZodNativeEnum<
-  typeof GenerateDataCollection
-> = z.nativeEnum(GenerateDataCollection);
+export const GenerateDataCollection$inboundSchema: z.ZodType<
+  GenerateDataCollection,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(GenerateDataCollection),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const GenerateDataCollection$outboundSchema: z.ZodNativeEnum<
-  typeof GenerateDataCollection
-> = GenerateDataCollection$inboundSchema;
+export const GenerateDataCollection$outboundSchema: z.ZodType<
+  GenerateDataCollection,
+  z.ZodTypeDef,
+  GenerateDataCollection
+> = z.union([
+  z.nativeEnum(GenerateDataCollection),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal
@@ -530,14 +546,25 @@ export namespace GenerateDataCollection$ {
 }
 
 /** @internal */
-export const GenerateOrderEnum$inboundSchema: z.ZodNativeEnum<
-  typeof GenerateOrderEnum
-> = z.nativeEnum(GenerateOrderEnum);
+export const GenerateOrderEnum$inboundSchema: z.ZodType<
+  GenerateOrderEnum,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(GenerateOrderEnum),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const GenerateOrderEnum$outboundSchema: z.ZodNativeEnum<
-  typeof GenerateOrderEnum
-> = GenerateOrderEnum$inboundSchema;
+export const GenerateOrderEnum$outboundSchema: z.ZodType<
+  GenerateOrderEnum,
+  z.ZodTypeDef,
+  GenerateOrderEnum
+> = z.union([
+  z.nativeEnum(GenerateOrderEnum),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal
@@ -599,14 +626,25 @@ export function generateOrderUnionFromJSON(
 }
 
 /** @internal */
-export const GenerateOnlyEnum$inboundSchema: z.ZodNativeEnum<
-  typeof GenerateOnlyEnum
-> = z.nativeEnum(GenerateOnlyEnum);
+export const GenerateOnlyEnum$inboundSchema: z.ZodType<
+  GenerateOnlyEnum,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(GenerateOnlyEnum),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const GenerateOnlyEnum$outboundSchema: z.ZodNativeEnum<
-  typeof GenerateOnlyEnum
-> = GenerateOnlyEnum$inboundSchema;
+export const GenerateOnlyEnum$outboundSchema: z.ZodType<
+  GenerateOnlyEnum,
+  z.ZodTypeDef,
+  GenerateOnlyEnum
+> = z.union([
+  z.nativeEnum(GenerateOnlyEnum),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal
@@ -668,14 +706,25 @@ export function generateOnlyUnionFromJSON(
 }
 
 /** @internal */
-export const GenerateIgnoreEnum$inboundSchema: z.ZodNativeEnum<
-  typeof GenerateIgnoreEnum
-> = z.nativeEnum(GenerateIgnoreEnum);
+export const GenerateIgnoreEnum$inboundSchema: z.ZodType<
+  GenerateIgnoreEnum,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(GenerateIgnoreEnum),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const GenerateIgnoreEnum$outboundSchema: z.ZodNativeEnum<
-  typeof GenerateIgnoreEnum
-> = GenerateIgnoreEnum$inboundSchema;
+export const GenerateIgnoreEnum$outboundSchema: z.ZodType<
+  GenerateIgnoreEnum,
+  z.ZodTypeDef,
+  GenerateIgnoreEnum
+> = z.union([
+  z.nativeEnum(GenerateIgnoreEnum),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal
@@ -737,14 +786,25 @@ export function generateIgnoreUnionFromJSON(
 }
 
 /** @internal */
-export const GenerateQuantization$inboundSchema: z.ZodNativeEnum<
-  typeof GenerateQuantization
-> = z.nativeEnum(GenerateQuantization);
+export const GenerateQuantization$inboundSchema: z.ZodType<
+  GenerateQuantization,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(GenerateQuantization),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const GenerateQuantization$outboundSchema: z.ZodNativeEnum<
-  typeof GenerateQuantization
-> = GenerateQuantization$inboundSchema;
+export const GenerateQuantization$outboundSchema: z.ZodType<
+  GenerateQuantization,
+  z.ZodTypeDef,
+  GenerateQuantization
+> = z.union([
+  z.nativeEnum(GenerateQuantization),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal
@@ -758,12 +818,25 @@ export namespace GenerateQuantization$ {
 }
 
 /** @internal */
-export const GenerateSort$inboundSchema: z.ZodNativeEnum<typeof GenerateSort> =
-  z.nativeEnum(GenerateSort);
+export const GenerateSort$inboundSchema: z.ZodType<
+  GenerateSort,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(GenerateSort),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
 
 /** @internal */
-export const GenerateSort$outboundSchema: z.ZodNativeEnum<typeof GenerateSort> =
-  GenerateSort$inboundSchema;
+export const GenerateSort$outboundSchema: z.ZodType<
+  GenerateSort,
+  z.ZodTypeDef,
+  GenerateSort
+> = z.union([
+  z.nativeEnum(GenerateSort),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
 
 /**
  * @internal