@openrouter/sdk 0.3.12 → 0.3.15

package/esm/models/openresponsesrequest.js

@@ -17,10 +17,13 @@ import { OpenResponsesWebSearchPreview20250311Tool$outboundSchema, } from "./ope
 import { OpenResponsesWebSearchPreviewTool$outboundSchema, } from "./openresponseswebsearchpreviewtool.js";
 import { OpenResponsesWebSearchTool$outboundSchema, } from "./openresponseswebsearchtool.js";
 import { PDFParserOptions$outboundSchema, } from "./pdfparseroptions.js";
+import { PreferredMaxLatency$outboundSchema, } from "./preferredmaxlatency.js";
+import { PreferredMinThroughput$outboundSchema, } from "./preferredminthroughput.js";
 import { ProviderName$outboundSchema } from "./providername.js";
 import { ProviderSort$outboundSchema } from "./providersort.js";
 import { ProviderSortConfig$outboundSchema, } from "./providersortconfig.js";
 import { Quantization$outboundSchema } from "./quantization.js";
+import { ResponsesOutputModality$outboundSchema, } from "./responsesoutputmodality.js";
 import { WebSearchEngine$outboundSchema, } from "./websearchengine.js";
 export const ServiceTier = {
     Auto: "auto",
@@ -52,6 +55,11 @@ export function openResponsesRequestToolUnionToJSON(openResponsesRequestToolUnio
     return JSON.stringify(OpenResponsesRequestToolUnion$outboundSchema.parse(openResponsesRequestToolUnion));
 }
 /** @internal */
+export const OpenResponsesRequestImageConfig$outboundSchema = z.union([z.string(), z.number()]);
+export function openResponsesRequestImageConfigToJSON(openResponsesRequestImageConfig) {
+    return JSON.stringify(OpenResponsesRequestImageConfig$outboundSchema.parse(openResponsesRequestImageConfig));
+}
+/** @internal */
 export const ServiceTier$outboundSchema = z.enum(ServiceTier);
 /** @internal */
 export const Truncation$outboundSchema = openEnums.outboundSchema(Truncation);
@@ -110,10 +118,10 @@ export const OpenResponsesRequestProvider$outboundSchema = z.object({
     ])).optional(),
     maxPrice: z.lazy(() => OpenResponsesRequestMaxPrice$outboundSchema)
         .optional(),
-    preferredMinThroughput: z.nullable(z.number()).optional(),
-    preferredMaxLatency: z.nullable(z.number()).optional(),
-    minThroughput: z.nullable(z.number()).optional(),
-    maxLatency: z.nullable(z.number()).optional(),
+    preferredMinThroughput: z.nullable(PreferredMinThroughput$outboundSchema)
+        .optional(),
+    preferredMaxLatency: z.nullable(PreferredMaxLatency$outboundSchema)
+        .optional(),
 }).transform((v) => {
     return remap$(v, {
         allowFallbacks: "allow_fallbacks",
@@ -123,8 +131,6 @@ export const OpenResponsesRequestProvider$outboundSchema = z.object({
         maxPrice: "max_price",
         preferredMinThroughput: "preferred_min_throughput",
         preferredMaxLatency: "preferred_max_latency",
-        minThroughput: "min_throughput",
-        maxLatency: "max_latency",
     });
 });
 export function openResponsesRequestProviderToJSON(openResponsesRequestProvider) {
@@ -171,7 +177,21 @@ export function openResponsesRequestPluginModerationToJSON(openResponsesRequestP
     return JSON.stringify(OpenResponsesRequestPluginModeration$outboundSchema.parse(openResponsesRequestPluginModeration));
 }
 /** @internal */
+export const OpenResponsesRequestPluginAutoRouter$outboundSchema = z.object({
+    id: z.literal("auto-router"),
+    enabled: z.boolean().optional(),
+    allowedModels: z.array(z.string()).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        allowedModels: "allowed_models",
+    });
+});
+export function openResponsesRequestPluginAutoRouterToJSON(openResponsesRequestPluginAutoRouter) {
+    return JSON.stringify(OpenResponsesRequestPluginAutoRouter$outboundSchema.parse(openResponsesRequestPluginAutoRouter));
+}
+/** @internal */
 export const OpenResponsesRequestPluginUnion$outboundSchema = z.union([
+    z.lazy(() => OpenResponsesRequestPluginAutoRouter$outboundSchema),
     z.lazy(() => OpenResponsesRequestPluginModeration$outboundSchema),
     z.lazy(() => OpenResponsesRequestPluginWeb$outboundSchema),
     z.lazy(() => OpenResponsesRequestPluginFileParser$outboundSchema),
@@ -201,7 +221,14 @@ export const OpenResponsesRequest$outboundSchema = z.object({
     maxOutputTokens: z.nullable(z.number()).optional(),
     temperature: z.nullable(z.number()).optional(),
     topP: z.nullable(z.number()).optional(),
+    topLogprobs: z.nullable(z.int()).optional(),
+    maxToolCalls: z.nullable(z.int()).optional(),
+    presencePenalty: z.nullable(z.number()).optional(),
+    frequencyPenalty: z.nullable(z.number()).optional(),
     topK: z.number().optional(),
+    imageConfig: z.record(z.string(), z.union([z.string(), z.number()]))
+        .optional(),
+    modalities: z.array(ResponsesOutputModality$outboundSchema).optional(),
     promptCacheKey: z.nullable(z.string()).optional(),
     previousResponseId: z.nullable(z.string()).optional(),
     prompt: z.nullable(OpenAIResponsesPrompt$outboundSchema).optional(),
@@ -215,6 +242,7 @@ export const OpenResponsesRequest$outboundSchema = z.object({
     stream: z.boolean().default(false),
     provider: z.nullable(z.lazy(() => OpenResponsesRequestProvider$outboundSchema)).optional(),
     plugins: z.array(z.union([
+        z.lazy(() => OpenResponsesRequestPluginAutoRouter$outboundSchema),
         z.lazy(() => OpenResponsesRequestPluginModeration$outboundSchema),
         z.lazy(() => OpenResponsesRequestPluginWeb$outboundSchema),
         z.lazy(() => OpenResponsesRequestPluginFileParser$outboundSchema),
@@ -228,7 +256,12 @@ export const OpenResponsesRequest$outboundSchema = z.object({
         parallelToolCalls: "parallel_tool_calls",
         maxOutputTokens: "max_output_tokens",
         topP: "top_p",
+        topLogprobs: "top_logprobs",
+        maxToolCalls: "max_tool_calls",
+        presencePenalty: "presence_penalty",
+        frequencyPenalty: "frequency_penalty",
         topK: "top_k",
+        imageConfig: "image_config",
         promptCacheKey: "prompt_cache_key",
         previousResponseId: "previous_response_id",
         safetyIdentifier: "safety_identifier",

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

@@ -0,0 +1,44 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+export type BulkAssignKeysToGuardrailRequestBody = {
+    /**
+     * Array of API key hashes to assign to the guardrail
+     */
+    keyHashes: Array<string>;
+};
+export type BulkAssignKeysToGuardrailRequest = {
+    /**
+     * The unique identifier of the guardrail
+     */
+    id: string;
+    requestBody: BulkAssignKeysToGuardrailRequestBody;
+};
+/**
+ * Assignment result
+ */
+export type BulkAssignKeysToGuardrailResponse = {
+    /**
+     * Number of keys successfully assigned
+     */
+    assignedCount: number;
+};
+/** @internal */
+export type BulkAssignKeysToGuardrailRequestBody$Outbound = {
+    key_hashes: Array<string>;
+};
+/** @internal */
+export declare const BulkAssignKeysToGuardrailRequestBody$outboundSchema: z.ZodType<BulkAssignKeysToGuardrailRequestBody$Outbound, BulkAssignKeysToGuardrailRequestBody>;
+export declare function bulkAssignKeysToGuardrailRequestBodyToJSON(bulkAssignKeysToGuardrailRequestBody: BulkAssignKeysToGuardrailRequestBody): string;
+/** @internal */
+export type BulkAssignKeysToGuardrailRequest$Outbound = {
+    id: string;
+    RequestBody: BulkAssignKeysToGuardrailRequestBody$Outbound;
+};
+/** @internal */
+export declare const BulkAssignKeysToGuardrailRequest$outboundSchema: z.ZodType<BulkAssignKeysToGuardrailRequest$Outbound, BulkAssignKeysToGuardrailRequest>;
+export declare function bulkAssignKeysToGuardrailRequestToJSON(bulkAssignKeysToGuardrailRequest: BulkAssignKeysToGuardrailRequest): string;
+/** @internal */
+export declare const BulkAssignKeysToGuardrailResponse$inboundSchema: z.ZodType<BulkAssignKeysToGuardrailResponse, unknown>;
+export declare function bulkAssignKeysToGuardrailResponseFromJSON(jsonString: string): SafeParseResult<BulkAssignKeysToGuardrailResponse, SDKValidationError>;
+//# sourceMappingURL=bulkassignkeystoguardrail.d.ts.map

package/esm/models/operations/bulkassignkeystoguardrail.js

@@ -0,0 +1,42 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 4f855e3ea589
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+/** @internal */
+export const BulkAssignKeysToGuardrailRequestBody$outboundSchema = z.object({
+    keyHashes: z.array(z.string()),
+}).transform((v) => {
+    return remap$(v, {
+        keyHashes: "key_hashes",
+    });
+});
+export function bulkAssignKeysToGuardrailRequestBodyToJSON(bulkAssignKeysToGuardrailRequestBody) {
+    return JSON.stringify(BulkAssignKeysToGuardrailRequestBody$outboundSchema.parse(bulkAssignKeysToGuardrailRequestBody));
+}
+/** @internal */
+export const BulkAssignKeysToGuardrailRequest$outboundSchema = z.object({
+    id: z.string(),
+    requestBody: z.lazy(() => BulkAssignKeysToGuardrailRequestBody$outboundSchema),
+}).transform((v) => {
+    return remap$(v, {
+        requestBody: "RequestBody",
+    });
+});
+export function bulkAssignKeysToGuardrailRequestToJSON(bulkAssignKeysToGuardrailRequest) {
+    return JSON.stringify(BulkAssignKeysToGuardrailRequest$outboundSchema.parse(bulkAssignKeysToGuardrailRequest));
+}
+/** @internal */
+export const BulkAssignKeysToGuardrailResponse$inboundSchema = z.object({
+    assigned_count: z.number(),
+}).transform((v) => {
+    return remap$(v, {
+        "assigned_count": "assignedCount",
+    });
+});
+export function bulkAssignKeysToGuardrailResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => BulkAssignKeysToGuardrailResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'BulkAssignKeysToGuardrailResponse' from JSON`);
+}
+//# sourceMappingURL=bulkassignkeystoguardrail.js.map

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

@@ -0,0 +1,44 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+export type BulkAssignMembersToGuardrailRequestBody = {
+    /**
+     * Array of member user IDs to assign to the guardrail
+     */
+    memberUserIds: Array<string>;
+};
+export type BulkAssignMembersToGuardrailRequest = {
+    /**
+     * The unique identifier of the guardrail
+     */
+    id: string;
+    requestBody: BulkAssignMembersToGuardrailRequestBody;
+};
+/**
+ * Assignment result
+ */
+export type BulkAssignMembersToGuardrailResponse = {
+    /**
+     * Number of members successfully assigned
+     */
+    assignedCount: number;
+};
+/** @internal */
+export type BulkAssignMembersToGuardrailRequestBody$Outbound = {
+    member_user_ids: Array<string>;
+};
+/** @internal */
+export declare const BulkAssignMembersToGuardrailRequestBody$outboundSchema: z.ZodType<BulkAssignMembersToGuardrailRequestBody$Outbound, BulkAssignMembersToGuardrailRequestBody>;
+export declare function bulkAssignMembersToGuardrailRequestBodyToJSON(bulkAssignMembersToGuardrailRequestBody: BulkAssignMembersToGuardrailRequestBody): string;
+/** @internal */
+export type BulkAssignMembersToGuardrailRequest$Outbound = {
+    id: string;
+    RequestBody: BulkAssignMembersToGuardrailRequestBody$Outbound;
+};
+/** @internal */
+export declare const BulkAssignMembersToGuardrailRequest$outboundSchema: z.ZodType<BulkAssignMembersToGuardrailRequest$Outbound, BulkAssignMembersToGuardrailRequest>;
+export declare function bulkAssignMembersToGuardrailRequestToJSON(bulkAssignMembersToGuardrailRequest: BulkAssignMembersToGuardrailRequest): string;
+/** @internal */
+export declare const BulkAssignMembersToGuardrailResponse$inboundSchema: z.ZodType<BulkAssignMembersToGuardrailResponse, unknown>;
+export declare function bulkAssignMembersToGuardrailResponseFromJSON(jsonString: string): SafeParseResult<BulkAssignMembersToGuardrailResponse, SDKValidationError>;
+//# sourceMappingURL=bulkassignmemberstoguardrail.d.ts.map

package/esm/models/operations/bulkassignmemberstoguardrail.js

@@ -0,0 +1,42 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 09a0f06fd33d
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+/** @internal */
+export const BulkAssignMembersToGuardrailRequestBody$outboundSchema = z.object({
+    memberUserIds: z.array(z.string()),
+}).transform((v) => {
+    return remap$(v, {
+        memberUserIds: "member_user_ids",
+    });
+});
+export function bulkAssignMembersToGuardrailRequestBodyToJSON(bulkAssignMembersToGuardrailRequestBody) {
+    return JSON.stringify(BulkAssignMembersToGuardrailRequestBody$outboundSchema.parse(bulkAssignMembersToGuardrailRequestBody));
+}
+/** @internal */
+export const BulkAssignMembersToGuardrailRequest$outboundSchema = z.object({
+    id: z.string(),
+    requestBody: z.lazy(() => BulkAssignMembersToGuardrailRequestBody$outboundSchema),
+}).transform((v) => {
+    return remap$(v, {
+        requestBody: "RequestBody",
+    });
+});
+export function bulkAssignMembersToGuardrailRequestToJSON(bulkAssignMembersToGuardrailRequest) {
+    return JSON.stringify(BulkAssignMembersToGuardrailRequest$outboundSchema.parse(bulkAssignMembersToGuardrailRequest));
+}
+/** @internal */
+export const BulkAssignMembersToGuardrailResponse$inboundSchema = z.object({
+    assigned_count: z.number(),
+}).transform((v) => {
+    return remap$(v, {
+        "assigned_count": "assignedCount",
+    });
+});
+export function bulkAssignMembersToGuardrailResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => BulkAssignMembersToGuardrailResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'BulkAssignMembersToGuardrailResponse' from JSON`);
+}
+//# sourceMappingURL=bulkassignmemberstoguardrail.js.map

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

@@ -0,0 +1,44 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+export type BulkUnassignKeysFromGuardrailRequestBody = {
+    /**
+     * Array of API key hashes to unassign from the guardrail
+     */
+    keyHashes: Array<string>;
+};
+export type BulkUnassignKeysFromGuardrailRequest = {
+    /**
+     * The unique identifier of the guardrail
+     */
+    id: string;
+    requestBody: BulkUnassignKeysFromGuardrailRequestBody;
+};
+/**
+ * Unassignment result
+ */
+export type BulkUnassignKeysFromGuardrailResponse = {
+    /**
+     * Number of keys successfully unassigned
+     */
+    unassignedCount: number;
+};
+/** @internal */
+export type BulkUnassignKeysFromGuardrailRequestBody$Outbound = {
+    key_hashes: Array<string>;
+};
+/** @internal */
+export declare const BulkUnassignKeysFromGuardrailRequestBody$outboundSchema: z.ZodType<BulkUnassignKeysFromGuardrailRequestBody$Outbound, BulkUnassignKeysFromGuardrailRequestBody>;
+export declare function bulkUnassignKeysFromGuardrailRequestBodyToJSON(bulkUnassignKeysFromGuardrailRequestBody: BulkUnassignKeysFromGuardrailRequestBody): string;
+/** @internal */
+export type BulkUnassignKeysFromGuardrailRequest$Outbound = {
+    id: string;
+    RequestBody: BulkUnassignKeysFromGuardrailRequestBody$Outbound;
+};
+/** @internal */
+export declare const BulkUnassignKeysFromGuardrailRequest$outboundSchema: z.ZodType<BulkUnassignKeysFromGuardrailRequest$Outbound, BulkUnassignKeysFromGuardrailRequest>;
+export declare function bulkUnassignKeysFromGuardrailRequestToJSON(bulkUnassignKeysFromGuardrailRequest: BulkUnassignKeysFromGuardrailRequest): string;
+/** @internal */
+export declare const BulkUnassignKeysFromGuardrailResponse$inboundSchema: z.ZodType<BulkUnassignKeysFromGuardrailResponse, unknown>;
+export declare function bulkUnassignKeysFromGuardrailResponseFromJSON(jsonString: string): SafeParseResult<BulkUnassignKeysFromGuardrailResponse, SDKValidationError>;
+//# sourceMappingURL=bulkunassignkeysfromguardrail.d.ts.map

package/esm/models/operations/bulkunassignkeysfromguardrail.js

@@ -0,0 +1,42 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 5ff688d2a0f6
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+/** @internal */
+export const BulkUnassignKeysFromGuardrailRequestBody$outboundSchema = z.object({
+    keyHashes: z.array(z.string()),
+}).transform((v) => {
+    return remap$(v, {
+        keyHashes: "key_hashes",
+    });
+});
+export function bulkUnassignKeysFromGuardrailRequestBodyToJSON(bulkUnassignKeysFromGuardrailRequestBody) {
+    return JSON.stringify(BulkUnassignKeysFromGuardrailRequestBody$outboundSchema.parse(bulkUnassignKeysFromGuardrailRequestBody));
+}
+/** @internal */
+export const BulkUnassignKeysFromGuardrailRequest$outboundSchema = z.object({
+    id: z.string(),
+    requestBody: z.lazy(() => BulkUnassignKeysFromGuardrailRequestBody$outboundSchema),
+}).transform((v) => {
+    return remap$(v, {
+        requestBody: "RequestBody",
+    });
+});
+export function bulkUnassignKeysFromGuardrailRequestToJSON(bulkUnassignKeysFromGuardrailRequest) {
+    return JSON.stringify(BulkUnassignKeysFromGuardrailRequest$outboundSchema.parse(bulkUnassignKeysFromGuardrailRequest));
+}
+/** @internal */
+export const BulkUnassignKeysFromGuardrailResponse$inboundSchema = z.object({
+    unassigned_count: z.number(),
+}).transform((v) => {
+    return remap$(v, {
+        "unassigned_count": "unassignedCount",
+    });
+});
+export function bulkUnassignKeysFromGuardrailResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => BulkUnassignKeysFromGuardrailResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'BulkUnassignKeysFromGuardrailResponse' from JSON`);
+}
+//# sourceMappingURL=bulkunassignkeysfromguardrail.js.map

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

@@ -0,0 +1,44 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+export type BulkUnassignMembersFromGuardrailRequestBody = {
+    /**
+     * Array of member user IDs to unassign from the guardrail
+     */
+    memberUserIds: Array<string>;
+};
+export type BulkUnassignMembersFromGuardrailRequest = {
+    /**
+     * The unique identifier of the guardrail
+     */
+    id: string;
+    requestBody: BulkUnassignMembersFromGuardrailRequestBody;
+};
+/**
+ * Unassignment result
+ */
+export type BulkUnassignMembersFromGuardrailResponse = {
+    /**
+     * Number of members successfully unassigned
+     */
+    unassignedCount: number;
+};
+/** @internal */
+export type BulkUnassignMembersFromGuardrailRequestBody$Outbound = {
+    member_user_ids: Array<string>;
+};
+/** @internal */
+export declare const BulkUnassignMembersFromGuardrailRequestBody$outboundSchema: z.ZodType<BulkUnassignMembersFromGuardrailRequestBody$Outbound, BulkUnassignMembersFromGuardrailRequestBody>;
+export declare function bulkUnassignMembersFromGuardrailRequestBodyToJSON(bulkUnassignMembersFromGuardrailRequestBody: BulkUnassignMembersFromGuardrailRequestBody): string;
+/** @internal */
+export type BulkUnassignMembersFromGuardrailRequest$Outbound = {
+    id: string;
+    RequestBody: BulkUnassignMembersFromGuardrailRequestBody$Outbound;
+};
+/** @internal */
+export declare const BulkUnassignMembersFromGuardrailRequest$outboundSchema: z.ZodType<BulkUnassignMembersFromGuardrailRequest$Outbound, BulkUnassignMembersFromGuardrailRequest>;
+export declare function bulkUnassignMembersFromGuardrailRequestToJSON(bulkUnassignMembersFromGuardrailRequest: BulkUnassignMembersFromGuardrailRequest): string;
+/** @internal */
+export declare const BulkUnassignMembersFromGuardrailResponse$inboundSchema: z.ZodType<BulkUnassignMembersFromGuardrailResponse, unknown>;
+export declare function bulkUnassignMembersFromGuardrailResponseFromJSON(jsonString: string): SafeParseResult<BulkUnassignMembersFromGuardrailResponse, SDKValidationError>;
+//# sourceMappingURL=bulkunassignmembersfromguardrail.d.ts.map

package/esm/models/operations/bulkunassignmembersfromguardrail.js

@@ -0,0 +1,42 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: ab90e9780326
+ */
+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));
+}
+/** @internal */
+export const BulkUnassignMembersFromGuardrailRequest$outboundSchema = z.object({
+    id: z.string(),
+    requestBody: z.lazy(() => BulkUnassignMembersFromGuardrailRequestBody$outboundSchema),
+}).transform((v) => {
+    return remap$(v, {
+        requestBody: "RequestBody",
+    });
+});
+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/createguardrail.d.ts

@@ -0,0 +1,136 @@
+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";
+/**
+ * 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 CreateGuardrailRequest = {
+    /**
+     * 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;
+    /**
+     * Array of model identifiers (slug or canonical_slug accepted)
+     */
+    allowedModels?: Array<string> | null | undefined;
+    /**
+     * Whether to enforce zero data retention
+     */
+    enforceZdr?: boolean | null | undefined;
+};
+/**
+ * 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;
+    /**
+     * 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 created successfully
+ */
+export type CreateGuardrailResponse = {
+    /**
+     * The created guardrail
+     */
+    data: CreateGuardrailData;
+};
+/** @internal */
+export declare const CreateGuardrailResetIntervalRequest$outboundSchema: z.ZodType<string, CreateGuardrailResetIntervalRequest>;
+/** @internal */
+export type CreateGuardrailRequest$Outbound = {
+    name: string;
+    description?: string | null | undefined;
+    limit_usd?: number | null | undefined;
+    reset_interval?: string | null | undefined;
+    allowed_providers?: Array<string> | null | undefined;
+    allowed_models?: Array<string> | null | undefined;
+    enforce_zdr?: boolean | null | undefined;
+};
+/** @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