@openrouter/sdk 0.11.2 → 0.12.0

package/esm/models/operations/bulkunassignmembersfromguardrail.js

@@ -4,43 +4,21 @@
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../../lib/primitives.js";
-import { safeParse } from "../../lib/schemas.js";
-/** @internal */
-export const BulkUnassignMembersFromGuardrailRequestBody$outboundSchema = z.object({
-    memberUserIds: z.array(z.string()),
-}).transform((v) => {
-    return remap$(v, {
-        memberUserIds: "member_user_ids",
-    });
-});
-export function bulkUnassignMembersFromGuardrailRequestBodyToJSON(bulkUnassignMembersFromGuardrailRequestBody) {
-    return JSON.stringify(BulkUnassignMembersFromGuardrailRequestBody$outboundSchema.parse(bulkUnassignMembersFromGuardrailRequestBody));
-}
+import * as models from "../index.js";
 /** @internal */
 export const BulkUnassignMembersFromGuardrailRequest$outboundSchema = z.object({
     httpReferer: z.string().optional(),
     appTitle: z.string().optional(),
     appCategories: z.string().optional(),
     id: z.string(),
-    requestBody: z.lazy(() => BulkUnassignMembersFromGuardrailRequestBody$outboundSchema),
+    bulkUnassignMembersRequest: models.BulkUnassignMembersRequest$outboundSchema,
 }).transform((v) => {
     return remap$(v, {
         httpReferer: "HTTP-Referer",
-        requestBody: "RequestBody",
+        bulkUnassignMembersRequest: "BulkUnassignMembersRequest",
     });
 });
 export function bulkUnassignMembersFromGuardrailRequestToJSON(bulkUnassignMembersFromGuardrailRequest) {
     return JSON.stringify(BulkUnassignMembersFromGuardrailRequest$outboundSchema.parse(bulkUnassignMembersFromGuardrailRequest));
 }
-/** @internal */
-export const BulkUnassignMembersFromGuardrailResponse$inboundSchema = z.object({
-    unassigned_count: z.number(),
-}).transform((v) => {
-    return remap$(v, {
-        "unassigned_count": "unassignedCount",
-    });
-});
-export function bulkUnassignMembersFromGuardrailResponseFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => BulkUnassignMembersFromGuardrailResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'BulkUnassignMembersFromGuardrailResponse' from JSON`);
-}
 //# sourceMappingURL=bulkunassignmembersfromguardrail.js.map

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

@@ -59,10 +59,6 @@ export type CreateAuthKeysCodeRequestBody = {
      * The method used to generate the code challenge
      */
     codeChallengeMethod?: CreateAuthKeysCodeCodeChallengeMethod | undefined;
-    /**
-     * Credit limit for the API key to be created
-     */
-    limit?: number | undefined;
     /**
      * Optional expiration time for the API key to be created
      */
@@ -71,6 +67,10 @@ export type CreateAuthKeysCodeRequestBody = {
      * Optional custom label for the API key. Defaults to the app name if not provided.
      */
     keyLabel?: string | undefined;
+    /**
+     * Credit limit for the API key to be created
+     */
+    limit?: number | undefined;
     /**
      * Optional credit limit reset interval. When set, the credit limit resets on this interval.
      */
@@ -102,10 +102,6 @@ export type CreateAuthKeysCodeRequest = {
  * Auth code data
  */
 export type CreateAuthKeysCodeData = {
-    /**
-     * The authorization code ID to use in the exchange request
-     */
-    id: string;
     /**
      * The application ID associated with this auth code
      */
@@ -114,6 +110,10 @@ export type CreateAuthKeysCodeData = {
      * ISO 8601 timestamp of when the auth code was created
      */
     createdAt: string;
+    /**
+     * The authorization code ID to use in the exchange request
+     */
+    id: string;
 };
 /**
  * Successfully created authorization code
@@ -133,9 +133,9 @@ export type CreateAuthKeysCodeRequestBody$Outbound = {
     callback_url: string;
     code_challenge?: string | undefined;
     code_challenge_method?: string | undefined;
-    limit?: number | undefined;
     expires_at?: string | null | undefined;
     key_label?: string | undefined;
+    limit?: number | undefined;
     usage_limit_type?: string | undefined;
 };
 /** @internal */

package/esm/models/operations/createauthkeyscode.js

@@ -31,9 +31,9 @@ export const CreateAuthKeysCodeRequestBody$outboundSchema = z.object({
     codeChallenge: z.string().optional(),
     codeChallengeMethod: CreateAuthKeysCodeCodeChallengeMethod$outboundSchema
         .optional(),
-    limit: z.number().optional(),
     expiresAt: z.nullable(z.date().transform(v => v.toISOString())).optional(),
     keyLabel: z.string().optional(),
+    limit: z.number().optional(),
     usageLimitType: UsageLimitType$outboundSchema.optional(),
 }).transform((v) => {
     return remap$(v, {
@@ -65,9 +65,9 @@ export function createAuthKeysCodeRequestToJSON(createAuthKeysCodeRequest) {
 }
 /** @internal */
 export const CreateAuthKeysCodeData$inboundSchema = z.object({
-    id: z.string(),
-    app_id: z.number(),
+    app_id: z.int(),
     created_at: z.string(),
+    id: z.string(),
 }).transform((v) => {
     return remap$(v, {
         "app_id": "appId",

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

@@ -24,38 +24,65 @@ export type CreateEmbeddingsGlobals = {
      */
     appCategories?: string | undefined;
 };
+/**
+ * The format of the output embeddings
+ */
+export declare const EncodingFormat: {
+    readonly Float: "float";
+    readonly Base64: "base64";
+};
+/**
+ * The format of the output embeddings
+ */
+export type EncodingFormat = OpenEnum<typeof EncodingFormat>;
 export type ImageUrl = {
     url: string;
 };
 export type ContentImageURL = {
-    type: "image_url";
     imageUrl: ImageUrl;
+    type: "image_url";
 };
 export type ContentText = {
-    type: "text";
     text: string;
+    type: "text";
 };
 export type Content = ContentText | ContentImageURL;
 export type Input = {
     content: Array<ContentText | ContentImageURL>;
 };
+/**
+ * Text, token, or multimodal input(s) to embed
+ */
 export type InputUnion = string | Array<string> | Array<number> | Array<Array<number>> | Array<Input>;
-export declare const EncodingFormat: {
-    readonly Float: "float";
-    readonly Base64: "base64";
-};
-export type EncodingFormat = OpenEnum<typeof EncodingFormat>;
+/**
+ * Embeddings request input
+ */
 export type CreateEmbeddingsRequestBody = {
-    input: string | Array<string> | Array<number> | Array<Array<number>> | Array<Input>;
-    model: string;
-    encodingFormat?: EncodingFormat | undefined;
+    /**
+     * The number of dimensions for the output embeddings
+     */
     dimensions?: number | undefined;
-    user?: string | undefined;
     /**
-     * Provider routing preferences for the request.
+     * The format of the output embeddings
+     */
+    encodingFormat?: EncodingFormat | undefined;
+    /**
+     * Text, token, or multimodal input(s) to embed
+     */
+    input: string | Array<string> | Array<number> | Array<Array<number>> | Array<Input>;
+    /**
+     * The type of input (e.g. search_query, search_document)
      */
-    provider?: models.ProviderPreferences | undefined;
     inputType?: string | undefined;
+    /**
+     * The model to use for embeddings
+     */
+    model: string;
+    provider?: models.ProviderPreferences | null | undefined;
+    /**
+     * A unique identifier for the end-user
+     */
+    user?: string | undefined;
 };
 export type CreateEmbeddingsRequest = {
     /**
@@ -79,37 +106,75 @@ export type CreateEmbeddingsRequest = {
     appCategories?: string | undefined;
     requestBody: CreateEmbeddingsRequestBody;
 };
-export declare const ObjectT: {
-    readonly List: "list";
-};
-export type ObjectT = ClosedEnum<typeof ObjectT>;
+/**
+ * Embedding vector as an array of floats or a base64 string
+ */
+export type Embedding = Array<number> | string;
 export declare const ObjectEmbedding: {
     readonly Embedding: "embedding";
 };
 export type ObjectEmbedding = ClosedEnum<typeof ObjectEmbedding>;
-export type Embedding = Array<number> | string;
+/**
+ * A single embedding object
+ */
 export type CreateEmbeddingsData = {
-    object: ObjectEmbedding;
+    /**
+     * Embedding vector as an array of floats or a base64 string
+     */
     embedding: Array<number> | string;
+    /**
+     * Index of the embedding in the input list
+     */
     index?: number | undefined;
+    object: ObjectEmbedding;
+};
+export declare const ObjectT: {
+    readonly List: "list";
 };
-export type Usage = {
+export type ObjectT = ClosedEnum<typeof ObjectT>;
+/**
+ * Token usage statistics
+ */
+export type CreateEmbeddingsUsage = {
+    /**
+     * Cost of the request in credits
+     */
+    cost?: number | undefined;
+    /**
+     * Number of tokens in the input
+     */
     promptTokens: number;
+    /**
+     * Total number of tokens used
+     */
     totalTokens: number;
-    cost?: number | undefined;
 };
 /**
- * Embedding response
+ * Embeddings response containing embedding vectors
  */
 export type CreateEmbeddingsResponseBody = {
-    id?: string | undefined;
-    object: ObjectT;
+    /**
+     * List of embedding objects
+     */
     data: Array<CreateEmbeddingsData>;
+    /**
+     * Unique identifier for the embeddings response
+     */
+    id?: string | undefined;
+    /**
+     * The model used for embeddings
+     */
     model: string;
-    usage?: Usage | undefined;
+    object: ObjectT;
+    /**
+     * Token usage statistics
+     */
+    usage?: CreateEmbeddingsUsage | undefined;
 };
 export type CreateEmbeddingsResponse = CreateEmbeddingsResponseBody | string;
 /** @internal */
+export declare const EncodingFormat$outboundSchema: z.ZodType<string, EncodingFormat>;
+/** @internal */
 export type ImageUrl$Outbound = {
     url: string;
 };
@@ -118,16 +183,16 @@ export declare const ImageUrl$outboundSchema: z.ZodType<ImageUrl$Outbound, Image
 export declare function imageUrlToJSON(imageUrl: ImageUrl): string;
 /** @internal */
 export type ContentImageURL$Outbound = {
-    type: "image_url";
     image_url: ImageUrl$Outbound;
+    type: "image_url";
 };
 /** @internal */
 export declare const ContentImageURL$outboundSchema: z.ZodType<ContentImageURL$Outbound, ContentImageURL>;
 export declare function contentImageURLToJSON(contentImageURL: ContentImageURL): string;
 /** @internal */
 export type ContentText$Outbound = {
-    type: "text";
     text: string;
+    type: "text";
 };
 /** @internal */
 export declare const ContentText$outboundSchema: z.ZodType<ContentText$Outbound, ContentText>;
@@ -150,16 +215,14 @@ export type InputUnion$Outbound = string | Array<string> | Array<number> | Array
 export declare const InputUnion$outboundSchema: z.ZodType<InputUnion$Outbound, InputUnion>;
 export declare function inputUnionToJSON(inputUnion: InputUnion): string;
 /** @internal */
-export declare const EncodingFormat$outboundSchema: z.ZodType<string, EncodingFormat>;
-/** @internal */
 export type CreateEmbeddingsRequestBody$Outbound = {
+    dimensions?: number | undefined;
+    encoding_format?: string | undefined;
     input: string | Array<string> | Array<number> | Array<Array<number>> | Array<Input$Outbound>;
+    input_type?: string | undefined;
     model: string;
-    encoding_format?: string | undefined;
-    dimensions?: number | undefined;
+    provider?: models.ProviderPreferences$Outbound | null | undefined;
     user?: string | undefined;
-    provider?: models.ProviderPreferences$Outbound | undefined;
-    input_type?: string | undefined;
 };
 /** @internal */
 export declare const CreateEmbeddingsRequestBody$outboundSchema: z.ZodType<CreateEmbeddingsRequestBody$Outbound, CreateEmbeddingsRequestBody>;
@@ -175,18 +238,18 @@ export type CreateEmbeddingsRequest$Outbound = {
 export declare const CreateEmbeddingsRequest$outboundSchema: z.ZodType<CreateEmbeddingsRequest$Outbound, CreateEmbeddingsRequest>;
 export declare function createEmbeddingsRequestToJSON(createEmbeddingsRequest: CreateEmbeddingsRequest): string;
 /** @internal */
-export declare const ObjectT$inboundSchema: z.ZodEnum<typeof ObjectT>;
-/** @internal */
-export declare const ObjectEmbedding$inboundSchema: z.ZodEnum<typeof ObjectEmbedding>;
-/** @internal */
 export declare const Embedding$inboundSchema: z.ZodType<Embedding, unknown>;
 export declare function embeddingFromJSON(jsonString: string): SafeParseResult<Embedding, SDKValidationError>;
 /** @internal */
+export declare const ObjectEmbedding$inboundSchema: z.ZodEnum<typeof ObjectEmbedding>;
+/** @internal */
 export declare const CreateEmbeddingsData$inboundSchema: z.ZodType<CreateEmbeddingsData, unknown>;
 export declare function createEmbeddingsDataFromJSON(jsonString: string): SafeParseResult<CreateEmbeddingsData, SDKValidationError>;
 /** @internal */
-export declare const Usage$inboundSchema: z.ZodType<Usage, unknown>;
-export declare function usageFromJSON(jsonString: string): SafeParseResult<Usage, SDKValidationError>;
+export declare const ObjectT$inboundSchema: z.ZodEnum<typeof ObjectT>;
+/** @internal */
+export declare const CreateEmbeddingsUsage$inboundSchema: z.ZodType<CreateEmbeddingsUsage, unknown>;
+export declare function createEmbeddingsUsageFromJSON(jsonString: string): SafeParseResult<CreateEmbeddingsUsage, SDKValidationError>;
 /** @internal */
 export declare const CreateEmbeddingsResponseBody$inboundSchema: z.ZodType<CreateEmbeddingsResponseBody, unknown>;
 export declare function createEmbeddingsResponseBodyFromJSON(jsonString: string): SafeParseResult<CreateEmbeddingsResponseBody, SDKValidationError>;

package/esm/models/operations/createembeddings.js

@@ -7,16 +7,21 @@ 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";
+/**
+ * The format of the output embeddings
+ */
 export const EncodingFormat = {
     Float: "float",
     Base64: "base64",
 };
-export const ObjectT = {
-    List: "list",
-};
 export const ObjectEmbedding = {
     Embedding: "embedding",
 };
+export const ObjectT = {
+    List: "list",
+};
+/** @internal */
+export const EncodingFormat$outboundSchema = openEnums.outboundSchema(EncodingFormat);
 /** @internal */
 export const ImageUrl$outboundSchema = z
     .object({
@@ -27,8 +32,8 @@ export function imageUrlToJSON(imageUrl) {
 }
 /** @internal */
 export const ContentImageURL$outboundSchema = z.object({
-    type: z.literal("image_url"),
     imageUrl: z.lazy(() => ImageUrl$outboundSchema),
+    type: z.literal("image_url"),
 }).transform((v) => {
     return remap$(v, {
         imageUrl: "image_url",
@@ -39,8 +44,8 @@ export function contentImageURLToJSON(contentImageURL) {
 }
 /** @internal */
 export const ContentText$outboundSchema = z.object({
-    type: z.literal("text"),
     text: z.string(),
+    type: z.literal("text"),
 });
 export function contentTextToJSON(contentText) {
     return JSON.stringify(ContentText$outboundSchema.parse(contentText));
@@ -76,9 +81,9 @@ export function inputUnionToJSON(inputUnion) {
     return JSON.stringify(InputUnion$outboundSchema.parse(inputUnion));
 }
 /** @internal */
-export const EncodingFormat$outboundSchema = openEnums.outboundSchema(EncodingFormat);
-/** @internal */
 export const CreateEmbeddingsRequestBody$outboundSchema = z.object({
+    dimensions: z.int().optional(),
+    encodingFormat: EncodingFormat$outboundSchema.optional(),
     input: z.union([
         z.string(),
         z.array(z.string()),
@@ -86,12 +91,10 @@ export const CreateEmbeddingsRequestBody$outboundSchema = z.object({
         z.array(z.array(z.number())),
         z.array(z.lazy(() => Input$outboundSchema)),
     ]),
+    inputType: z.string().optional(),
     model: z.string(),
-    encodingFormat: EncodingFormat$outboundSchema.optional(),
-    dimensions: z.int().optional(),
+    provider: z.nullable(models.ProviderPreferences$outboundSchema).optional(),
     user: z.string().optional(),
-    provider: models.ProviderPreferences$outboundSchema.optional(),
-    inputType: z.string().optional(),
 }).transform((v) => {
     return remap$(v, {
         encodingFormat: "encoding_format",
@@ -117,10 +120,6 @@ export function createEmbeddingsRequestToJSON(createEmbeddingsRequest) {
     return JSON.stringify(CreateEmbeddingsRequest$outboundSchema.parse(createEmbeddingsRequest));
 }
 /** @internal */
-export const ObjectT$inboundSchema = z.enum(ObjectT);
-/** @internal */
-export const ObjectEmbedding$inboundSchema = z.enum(ObjectEmbedding);
-/** @internal */
 export const Embedding$inboundSchema = z.union([
     z.array(z.number()),
     z.string(),
@@ -129,35 +128,39 @@ export function embeddingFromJSON(jsonString) {
     return safeParse(jsonString, (x) => Embedding$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Embedding' from JSON`);
 }
 /** @internal */
+export const ObjectEmbedding$inboundSchema = z.enum(ObjectEmbedding);
+/** @internal */
 export const CreateEmbeddingsData$inboundSchema = z.object({
-    object: ObjectEmbedding$inboundSchema,
     embedding: z.union([z.array(z.number()), z.string()]),
-    index: z.number().optional(),
+    index: z.int().optional(),
+    object: ObjectEmbedding$inboundSchema,
 });
 export function createEmbeddingsDataFromJSON(jsonString) {
     return safeParse(jsonString, (x) => CreateEmbeddingsData$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateEmbeddingsData' from JSON`);
 }
 /** @internal */
-export const Usage$inboundSchema = z.object({
-    prompt_tokens: z.number(),
-    total_tokens: z.number(),
+export const ObjectT$inboundSchema = z.enum(ObjectT);
+/** @internal */
+export const CreateEmbeddingsUsage$inboundSchema = z.object({
     cost: z.number().optional(),
+    prompt_tokens: z.int(),
+    total_tokens: z.int(),
 }).transform((v) => {
     return remap$(v, {
         "prompt_tokens": "promptTokens",
         "total_tokens": "totalTokens",
     });
 });
-export function usageFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => Usage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Usage' from JSON`);
+export function createEmbeddingsUsageFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CreateEmbeddingsUsage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateEmbeddingsUsage' from JSON`);
 }
 /** @internal */
 export const CreateEmbeddingsResponseBody$inboundSchema = z.object({
-    id: z.string().optional(),
-    object: ObjectT$inboundSchema,
     data: z.array(z.lazy(() => CreateEmbeddingsData$inboundSchema)),
+    id: z.string().optional(),
     model: z.string(),
-    usage: z.lazy(() => Usage$inboundSchema).optional(),
+    object: ObjectT$inboundSchema,
+    usage: z.lazy(() => CreateEmbeddingsUsage$inboundSchema).optional(),
 });
 export function createEmbeddingsResponseBodyFromJSON(jsonString) {
     return safeParse(jsonString, (x) => CreateEmbeddingsResponseBody$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateEmbeddingsResponseBody' from JSON`);

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

@@ -1,7 +1,5 @@
 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";
+import * as models from "../index.js";
 export type CreateGuardrailGlobals = {
     /**
      * The app identifier should be your app's URL and is used as the primary identifier for rankings.
@@ -23,52 +21,6 @@ export type CreateGuardrailGlobals = {
      */
     appCategories?: string | undefined;
 };
-/**
- * Interval at which the limit resets (daily, weekly, monthly)
- */
-export declare const CreateGuardrailResetIntervalRequest: {
-    readonly Daily: "daily";
-    readonly Weekly: "weekly";
-    readonly Monthly: "monthly";
-};
-/**
- * Interval at which the limit resets (daily, weekly, monthly)
- */
-export type CreateGuardrailResetIntervalRequest = OpenEnum<typeof CreateGuardrailResetIntervalRequest>;
-export type CreateGuardrailRequestBody = {
-    /**
-     * Name for the new 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?: CreateGuardrailResetIntervalRequest | 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 identifiers (slug or canonical_slug accepted)
-     */
-    allowedModels?: Array<string> | null | undefined;
-    /**
-     * Whether to enforce zero data retention
-     */
-    enforceZdr?: boolean | null | undefined;
-};
 export type CreateGuardrailRequest = {
     /**
      * The app identifier should be your app's URL and is used as the primary identifier for rankings.
@@ -89,110 +41,16 @@ export type CreateGuardrailRequest = {
      * @remarks
      */
     appCategories?: string | undefined;
-    requestBody: CreateGuardrailRequestBody;
-};
-/**
- * Interval at which the limit resets (daily, weekly, monthly)
- */
-export declare const CreateGuardrailResetIntervalResponse: {
-    readonly Daily: "daily";
-    readonly Weekly: "weekly";
-    readonly Monthly: "monthly";
-};
-/**
- * Interval at which the limit resets (daily, weekly, monthly)
- */
-export type CreateGuardrailResetIntervalResponse = OpenEnum<typeof CreateGuardrailResetIntervalResponse>;
-/**
- * The created guardrail
- */
-export type CreateGuardrailData = {
-    /**
-     * 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?: CreateGuardrailResetIntervalResponse | 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;
+    createGuardrailRequest: models.CreateGuardrailRequest;
 };
-/**
- * Guardrail created successfully
- */
-export type CreateGuardrailResponse = {
-    /**
-     * The created guardrail
-     */
-    data: CreateGuardrailData;
-};
-/** @internal */
-export declare const CreateGuardrailResetIntervalRequest$outboundSchema: z.ZodType<string, CreateGuardrailResetIntervalRequest>;
-/** @internal */
-export type CreateGuardrailRequestBody$Outbound = {
-    name: string;
-    description?: string | null | undefined;
-    limit_usd?: number | null | undefined;
-    reset_interval?: string | null | undefined;
-    allowed_providers?: Array<string> | null | undefined;
-    ignored_providers?: Array<string> | null | undefined;
-    allowed_models?: Array<string> | null | undefined;
-    enforce_zdr?: boolean | null | undefined;
-};
-/** @internal */
-export declare const CreateGuardrailRequestBody$outboundSchema: z.ZodType<CreateGuardrailRequestBody$Outbound, CreateGuardrailRequestBody>;
-export declare function createGuardrailRequestBodyToJSON(createGuardrailRequestBody: CreateGuardrailRequestBody): string;
 /** @internal */
 export type CreateGuardrailRequest$Outbound = {
     "HTTP-Referer"?: string | undefined;
     appTitle?: string | undefined;
     appCategories?: string | undefined;
-    RequestBody: CreateGuardrailRequestBody$Outbound;
+    CreateGuardrailRequest: models.CreateGuardrailRequest$Outbound;
 };
 /** @internal */
 export declare const CreateGuardrailRequest$outboundSchema: z.ZodType<CreateGuardrailRequest$Outbound, CreateGuardrailRequest>;
 export declare function createGuardrailRequestToJSON(createGuardrailRequest: CreateGuardrailRequest): string;
-/** @internal */
-export declare const CreateGuardrailResetIntervalResponse$inboundSchema: z.ZodType<CreateGuardrailResetIntervalResponse, unknown>;
-/** @internal */
-export declare const CreateGuardrailData$inboundSchema: z.ZodType<CreateGuardrailData, unknown>;
-export declare function createGuardrailDataFromJSON(jsonString: string): SafeParseResult<CreateGuardrailData, SDKValidationError>;
-/** @internal */
-export declare const CreateGuardrailResponse$inboundSchema: z.ZodType<CreateGuardrailResponse, unknown>;
-export declare function createGuardrailResponseFromJSON(jsonString: string): SafeParseResult<CreateGuardrailResponse, SDKValidationError>;
 //# sourceMappingURL=createguardrail.d.ts.map