@openrouter/sdk 0.0.1-beta.12 → 0.0.1-beta.14

package/esm/funcs/modelsList.js

@@ -8,6 +8,7 @@ import { safeParse } from "../lib/schemas.js";
 import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
 import { pathToFunc } from "../lib/url.js";
 import * as errors from "../models/errors/index.js";
+import * as models from "../models/index.js";
 import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
 /**
@@ -27,11 +28,9 @@ async function $do(client, request, options) {
     const query = encodeFormQuery({
         "category": payload?.category,
         "supported_parameters": payload?.supported_parameters,
-        "use_rss": payload?.use_rss,
-        "use_rss_chat_links": payload?.use_rss_chat_links,
     });
     const headers = new Headers(compactMap({
-        Accept: "application/json;q=1, application/rss+xml;q=0",
+        Accept: "application/json",
     }));
     const secConfig = await extractSecurity(client._options.apiKey);
     const securityInput = secConfig == null ? {} : { apiKey: secConfig };
@@ -76,9 +75,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, operations.GetModelsResponse$inboundSchema), M.text(200, operations.GetModelsResponse$inboundSchema, {
-        ctype: "application/rss+xml",
-    }), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(200, models.ModelsListResponse$inboundSchema), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/oAuthCreateAuthCode.d.ts

@@ -0,0 +1,18 @@
+import { OpenRouterCore } from "../core.js";
+import { RequestOptions } from "../lib/sdks.js";
+import { ConnectionError, InvalidRequestError, RequestAbortedError, RequestTimeoutError, UnexpectedClientError } from "../models/errors/httpclienterrors.js";
+import * as errors from "../models/errors/index.js";
+import { OpenRouterError } from "../models/errors/openroutererror.js";
+import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
+import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import * as operations from "../models/operations/index.js";
+import { APIPromise } from "../types/async.js";
+import { Result } from "../types/fp.js";
+/**
+ * Create authorization code
+ *
+ * @remarks
+ * Create an authorization code for the PKCE flow to generate a user-controlled API key
+ */
+export declare function oAuthCreateAuthCode(client: OpenRouterCore, request: operations.CreateAuthKeysCodeRequest, options?: RequestOptions): APIPromise<Result<operations.CreateAuthKeysCodeResponse, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+//# sourceMappingURL=oAuthCreateAuthCode.d.ts.map

package/esm/funcs/oAuthCreateAuthCode.js

@@ -0,0 +1,82 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import { encodeJSON } from "../lib/encodings.js";
+import * as M from "../lib/matchers.js";
+import { compactMap } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
+import { pathToFunc } from "../lib/url.js";
+import * as errors from "../models/errors/index.js";
+import * as operations from "../models/operations/index.js";
+import { APIPromise } from "../types/async.js";
+/**
+ * Create authorization code
+ *
+ * @remarks
+ * Create an authorization code for the PKCE flow to generate a user-controlled API key
+ */
+export function oAuthCreateAuthCode(client, request, options) {
+    return new APIPromise($do(client, request, options));
+}
+async function $do(client, request, options) {
+    const parsed = safeParse(request, (value) => operations.CreateAuthKeysCodeRequest$outboundSchema.parse(value), "Input validation failed");
+    if (!parsed.ok) {
+        return [parsed, { status: "invalid" }];
+    }
+    const payload = parsed.value;
+    const body = encodeJSON("body", payload, { explode: true });
+    const path = pathToFunc("/auth/keys/code")();
+    const headers = new Headers(compactMap({
+        "Content-Type": "application/json",
+        Accept: "application/json",
+    }));
+    const secConfig = await extractSecurity(client._options.apiKey);
+    const securityInput = secConfig == null ? {} : { apiKey: secConfig };
+    const requestSecurity = resolveGlobalSecurity(securityInput);
+    const context = {
+        options: client._options,
+        baseURL: options?.serverURL ?? client._baseURL ?? "",
+        operationID: "createAuthKeysCode",
+        oAuth2Scopes: null,
+        resolvedSecurity: requestSecurity,
+        securitySource: client._options.apiKey,
+        retryConfig: options?.retries
+            || client._options.retryConfig
+            || { strategy: "none" },
+        retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+    };
+    const requestRes = client._createRequest(context, {
+        security: requestSecurity,
+        method: "POST",
+        baseURL: options?.serverURL,
+        path: path,
+        headers: headers,
+        body: body,
+        userAgent: client._options.userAgent,
+        timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+    }, options);
+    if (!requestRes.ok) {
+        return [requestRes, { status: "invalid" }];
+    }
+    const req = requestRes.value;
+    const doResult = await client._do(req, {
+        context,
+        errorCodes: ["400", "401", "4XX", "500", "5XX"],
+        retryConfig: context.retryConfig,
+        retryCodes: context.retryCodes,
+    });
+    if (!doResult.ok) {
+        return [doResult, { status: "request-error", request: req }];
+    }
+    const response = doResult.value;
+    const responseFields = {
+        HttpMeta: { Response: response, Request: req },
+    };
+    const [result] = await M.match(M.json(200, operations.CreateAuthKeysCodeResponse$inboundSchema), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    if (!result.ok) {
+        return [result, { status: "complete", request: req, response }];
+    }
+    return [result, { status: "complete", request: req, response }];
+}
+//# sourceMappingURL=oAuthCreateAuthCode.js.map

package/esm/funcs/oAuthCreateAuthorizationUrl.d.ts

@@ -9,13 +9,13 @@ declare const CreateAuthorizationurlParamsSchema: z.ZodUnion<[z.ZodObject<{
     codeChallenge: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     callbackUrl: string | URL;
-    codeChallengeMethod: "S256" | "plain";
     codeChallenge: string;
+    codeChallengeMethod: "S256" | "plain";
     limit?: number | undefined;
 }, {
     callbackUrl: string | URL;
-    codeChallengeMethod: "S256" | "plain";
     codeChallenge: string;
+    codeChallengeMethod: "S256" | "plain";
     limit?: number | undefined;
 }>, z.ZodObject<{
     callbackUrl: z.ZodUnion<[z.ZodString, z.ZodType<URL, z.ZodTypeDef, URL>]>;

package/esm/funcs/oAuthExchangeAuthCodeForAPIKey.d.ts

@@ -0,0 +1,18 @@
+import { OpenRouterCore } from "../core.js";
+import { RequestOptions } from "../lib/sdks.js";
+import { ConnectionError, InvalidRequestError, RequestAbortedError, RequestTimeoutError, UnexpectedClientError } from "../models/errors/httpclienterrors.js";
+import * as errors from "../models/errors/index.js";
+import { OpenRouterError } from "../models/errors/openroutererror.js";
+import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
+import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import * as operations from "../models/operations/index.js";
+import { APIPromise } from "../types/async.js";
+import { Result } from "../types/fp.js";
+/**
+ * Exchange authorization code for API key
+ *
+ * @remarks
+ * Exchange an authorization code from the PKCE flow for a user-controlled API key
+ */
+export declare function oAuthExchangeAuthCodeForAPIKey(client: OpenRouterCore, request: operations.ExchangeAuthCodeForAPIKeyRequest, options?: RequestOptions): APIPromise<Result<operations.ExchangeAuthCodeForAPIKeyResponse, errors.BadRequestResponseError | errors.ForbiddenResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+//# sourceMappingURL=oAuthExchangeAuthCodeForAPIKey.d.ts.map

package/esm/funcs/oAuthExchangeAuthCodeForAPIKey.js

@@ -0,0 +1,82 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import { encodeJSON } from "../lib/encodings.js";
+import * as M from "../lib/matchers.js";
+import { compactMap } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
+import { pathToFunc } from "../lib/url.js";
+import * as errors from "../models/errors/index.js";
+import * as operations from "../models/operations/index.js";
+import { APIPromise } from "../types/async.js";
+/**
+ * Exchange authorization code for API key
+ *
+ * @remarks
+ * Exchange an authorization code from the PKCE flow for a user-controlled API key
+ */
+export function oAuthExchangeAuthCodeForAPIKey(client, request, options) {
+    return new APIPromise($do(client, request, options));
+}
+async function $do(client, request, options) {
+    const parsed = safeParse(request, (value) => operations.ExchangeAuthCodeForAPIKeyRequest$outboundSchema.parse(value), "Input validation failed");
+    if (!parsed.ok) {
+        return [parsed, { status: "invalid" }];
+    }
+    const payload = parsed.value;
+    const body = encodeJSON("body", payload, { explode: true });
+    const path = pathToFunc("/auth/keys")();
+    const headers = new Headers(compactMap({
+        "Content-Type": "application/json",
+        Accept: "application/json",
+    }));
+    const secConfig = await extractSecurity(client._options.apiKey);
+    const securityInput = secConfig == null ? {} : { apiKey: secConfig };
+    const requestSecurity = resolveGlobalSecurity(securityInput);
+    const context = {
+        options: client._options,
+        baseURL: options?.serverURL ?? client._baseURL ?? "",
+        operationID: "exchangeAuthCodeForAPIKey",
+        oAuth2Scopes: null,
+        resolvedSecurity: requestSecurity,
+        securitySource: client._options.apiKey,
+        retryConfig: options?.retries
+            || client._options.retryConfig
+            || { strategy: "none" },
+        retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+    };
+    const requestRes = client._createRequest(context, {
+        security: requestSecurity,
+        method: "POST",
+        baseURL: options?.serverURL,
+        path: path,
+        headers: headers,
+        body: body,
+        userAgent: client._options.userAgent,
+        timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+    }, options);
+    if (!requestRes.ok) {
+        return [requestRes, { status: "invalid" }];
+    }
+    const req = requestRes.value;
+    const doResult = await client._do(req, {
+        context,
+        errorCodes: ["400", "403", "4XX", "500", "5XX"],
+        retryConfig: context.retryConfig,
+        retryCodes: context.retryCodes,
+    });
+    if (!doResult.ok) {
+        return [doResult, { status: "request-error", request: req }];
+    }
+    const response = doResult.value;
+    const responseFields = {
+        HttpMeta: { Response: response, Request: req },
+    };
+    const [result] = await M.match(M.json(200, operations.ExchangeAuthCodeForAPIKeyResponse$inboundSchema), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(403, errors.ForbiddenResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    if (!result.ok) {
+        return [result, { status: "complete", request: req, response }];
+    }
+    return [result, { status: "complete", request: req, response }];
+}
+//# sourceMappingURL=oAuthExchangeAuthCodeForAPIKey.js.map

package/esm/lib/config.d.ts

@@ -37,8 +37,8 @@ export declare function serverURLFromOptions(options: SDKOptions): URL | null;
 export declare const SDK_METADATA: {
     readonly language: "typescript";
     readonly openapiDocVersion: "1.0.0";
-    readonly sdkVersion: "0.0.1-beta.12";
+    readonly sdkVersion: "0.0.1-beta.14";
     readonly genVersion: "2.731.4";
-    readonly userAgent: "speakeasy-sdk/typescript 0.0.1-beta.12 2.731.4 1.0.0 @openrouter/sdk";
+    readonly userAgent: "speakeasy-sdk/typescript 0.0.1-beta.14 2.731.4 1.0.0 @openrouter/sdk";
 };
 //# sourceMappingURL=config.d.ts.map

package/esm/lib/config.js

@@ -25,8 +25,8 @@ export function serverURLFromOptions(options) {
 export const SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.0.0",
-    sdkVersion: "0.0.1-beta.12",
+    sdkVersion: "0.0.1-beta.14",
     genVersion: "2.731.4",
-    userAgent: "speakeasy-sdk/typescript 0.0.1-beta.12 2.731.4 1.0.0 @openrouter/sdk",
+    userAgent: "speakeasy-sdk/typescript 0.0.1-beta.14 2.731.4 1.0.0 @openrouter/sdk",
 };
 //# sourceMappingURL=config.js.map

package/esm/lib/event-streams.d.ts

@@ -4,7 +4,7 @@ export type SseMessage<T> = {
     id?: string | undefined;
     retry?: number | undefined;
 };
-export declare class EventStream<T extends SseMessage<unknown>> extends ReadableStream<T> {
+export declare class EventStream<T> extends ReadableStream<T> {
     constructor(responseBody: ReadableStream<Uint8Array>, parse: (x: SseMessage<string>) => IteratorResult<T, undefined>);
     [Symbol.asyncIterator](): AsyncIterableIterator<T>;
 }

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

@@ -0,0 +1,145 @@
+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";
+/**
+ * The method used to generate the code challenge
+ */
+export declare const CreateAuthKeysCodeCodeChallengeMethod: {
+    readonly S256: "S256";
+    readonly Plain: "plain";
+};
+/**
+ * The method used to generate the code challenge
+ */
+export type CreateAuthKeysCodeCodeChallengeMethod = OpenEnum<typeof CreateAuthKeysCodeCodeChallengeMethod>;
+export type CreateAuthKeysCodeRequest = {
+    /**
+     * The callback URL to redirect to after authorization. Note, only https URLs on ports 443 and 3000 are allowed.
+     */
+    callbackUrl: string;
+    /**
+     * PKCE code challenge for enhanced security
+     */
+    codeChallenge?: string | undefined;
+    /**
+     * The method used to generate the code challenge
+     */
+    codeChallengeMethod?: CreateAuthKeysCodeCodeChallengeMethod | undefined;
+    /**
+     * Credit limit for the API key to be created
+     */
+    limit?: number | undefined;
+};
+/**
+ * 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
+     */
+    appId: number;
+    /**
+     * ISO 8601 timestamp of when the auth code was created
+     */
+    createdAt: string;
+};
+/**
+ * Successfully created authorization code
+ */
+export type CreateAuthKeysCodeResponse = {
+    /**
+     * Auth code data
+     */
+    data: CreateAuthKeysCodeData;
+};
+/** @internal */
+export declare const CreateAuthKeysCodeCodeChallengeMethod$inboundSchema: z.ZodType<CreateAuthKeysCodeCodeChallengeMethod, unknown>;
+/** @internal */
+export declare const CreateAuthKeysCodeCodeChallengeMethod$outboundSchema: z.ZodType<CreateAuthKeysCodeCodeChallengeMethod, CreateAuthKeysCodeCodeChallengeMethod>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace CreateAuthKeysCodeCodeChallengeMethod$ {
+    /** @deprecated use `CreateAuthKeysCodeCodeChallengeMethod$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<CreateAuthKeysCodeCodeChallengeMethod, unknown, z.core.$ZodTypeInternals<CreateAuthKeysCodeCodeChallengeMethod, unknown>>;
+    /** @deprecated use `CreateAuthKeysCodeCodeChallengeMethod$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<CreateAuthKeysCodeCodeChallengeMethod, CreateAuthKeysCodeCodeChallengeMethod, z.core.$ZodTypeInternals<CreateAuthKeysCodeCodeChallengeMethod, CreateAuthKeysCodeCodeChallengeMethod>>;
+}
+/** @internal */
+export declare const CreateAuthKeysCodeRequest$inboundSchema: z.ZodType<CreateAuthKeysCodeRequest, unknown>;
+/** @internal */
+export type CreateAuthKeysCodeRequest$Outbound = {
+    callback_url: string;
+    code_challenge?: string | undefined;
+    code_challenge_method?: string | undefined;
+    limit?: number | undefined;
+};
+/** @internal */
+export declare const CreateAuthKeysCodeRequest$outboundSchema: z.ZodType<CreateAuthKeysCodeRequest$Outbound, CreateAuthKeysCodeRequest>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace CreateAuthKeysCodeRequest$ {
+    /** @deprecated use `CreateAuthKeysCodeRequest$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<CreateAuthKeysCodeRequest, unknown, z.core.$ZodTypeInternals<CreateAuthKeysCodeRequest, unknown>>;
+    /** @deprecated use `CreateAuthKeysCodeRequest$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<CreateAuthKeysCodeRequest$Outbound, CreateAuthKeysCodeRequest, z.core.$ZodTypeInternals<CreateAuthKeysCodeRequest$Outbound, CreateAuthKeysCodeRequest>>;
+    /** @deprecated use `CreateAuthKeysCodeRequest$Outbound` instead. */
+    type Outbound = CreateAuthKeysCodeRequest$Outbound;
+}
+export declare function createAuthKeysCodeRequestToJSON(createAuthKeysCodeRequest: CreateAuthKeysCodeRequest): string;
+export declare function createAuthKeysCodeRequestFromJSON(jsonString: string): SafeParseResult<CreateAuthKeysCodeRequest, SDKValidationError>;
+/** @internal */
+export declare const CreateAuthKeysCodeData$inboundSchema: z.ZodType<CreateAuthKeysCodeData, unknown>;
+/** @internal */
+export type CreateAuthKeysCodeData$Outbound = {
+    id: string;
+    app_id: number;
+    created_at: string;
+};
+/** @internal */
+export declare const CreateAuthKeysCodeData$outboundSchema: z.ZodType<CreateAuthKeysCodeData$Outbound, CreateAuthKeysCodeData>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace CreateAuthKeysCodeData$ {
+    /** @deprecated use `CreateAuthKeysCodeData$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<CreateAuthKeysCodeData, unknown, z.core.$ZodTypeInternals<CreateAuthKeysCodeData, unknown>>;
+    /** @deprecated use `CreateAuthKeysCodeData$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<CreateAuthKeysCodeData$Outbound, CreateAuthKeysCodeData, z.core.$ZodTypeInternals<CreateAuthKeysCodeData$Outbound, CreateAuthKeysCodeData>>;
+    /** @deprecated use `CreateAuthKeysCodeData$Outbound` instead. */
+    type Outbound = CreateAuthKeysCodeData$Outbound;
+}
+export declare function createAuthKeysCodeDataToJSON(createAuthKeysCodeData: CreateAuthKeysCodeData): string;
+export declare function createAuthKeysCodeDataFromJSON(jsonString: string): SafeParseResult<CreateAuthKeysCodeData, SDKValidationError>;
+/** @internal */
+export declare const CreateAuthKeysCodeResponse$inboundSchema: z.ZodType<CreateAuthKeysCodeResponse, unknown>;
+/** @internal */
+export type CreateAuthKeysCodeResponse$Outbound = {
+    data: CreateAuthKeysCodeData$Outbound;
+};
+/** @internal */
+export declare const CreateAuthKeysCodeResponse$outboundSchema: z.ZodType<CreateAuthKeysCodeResponse$Outbound, CreateAuthKeysCodeResponse>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace CreateAuthKeysCodeResponse$ {
+    /** @deprecated use `CreateAuthKeysCodeResponse$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<CreateAuthKeysCodeResponse, unknown, z.core.$ZodTypeInternals<CreateAuthKeysCodeResponse, unknown>>;
+    /** @deprecated use `CreateAuthKeysCodeResponse$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<CreateAuthKeysCodeResponse$Outbound, CreateAuthKeysCodeResponse, z.core.$ZodTypeInternals<CreateAuthKeysCodeResponse$Outbound, CreateAuthKeysCodeResponse>>;
+    /** @deprecated use `CreateAuthKeysCodeResponse$Outbound` instead. */
+    type Outbound = CreateAuthKeysCodeResponse$Outbound;
+}
+export declare function createAuthKeysCodeResponseToJSON(createAuthKeysCodeResponse: CreateAuthKeysCodeResponse): string;
+export declare function createAuthKeysCodeResponseFromJSON(jsonString: string): SafeParseResult<CreateAuthKeysCodeResponse, SDKValidationError>;
+//# sourceMappingURL=createauthkeyscode.d.ts.map

package/esm/models/operations/createauthkeyscode.js

@@ -0,0 +1,146 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { catchUnrecognizedEnum, } from "../../types/enums.js";
+/**
+ * The method used to generate the code challenge
+ */
+export const CreateAuthKeysCodeCodeChallengeMethod = {
+    S256: "S256",
+    Plain: "plain",
+};
+/** @internal */
+export const CreateAuthKeysCodeCodeChallengeMethod$inboundSchema = z
+    .union([
+    z.enum(CreateAuthKeysCodeCodeChallengeMethod),
+    z.string().transform(catchUnrecognizedEnum),
+]);
+/** @internal */
+export const CreateAuthKeysCodeCodeChallengeMethod$outboundSchema = z.union([
+    z.enum(CreateAuthKeysCodeCodeChallengeMethod),
+    z.string().and(z.custom()),
+]);
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var CreateAuthKeysCodeCodeChallengeMethod$;
+(function (CreateAuthKeysCodeCodeChallengeMethod$) {
+    /** @deprecated use `CreateAuthKeysCodeCodeChallengeMethod$inboundSchema` instead. */
+    CreateAuthKeysCodeCodeChallengeMethod$.inboundSchema = CreateAuthKeysCodeCodeChallengeMethod$inboundSchema;
+    /** @deprecated use `CreateAuthKeysCodeCodeChallengeMethod$outboundSchema` instead. */
+    CreateAuthKeysCodeCodeChallengeMethod$.outboundSchema = CreateAuthKeysCodeCodeChallengeMethod$outboundSchema;
+})(CreateAuthKeysCodeCodeChallengeMethod$ || (CreateAuthKeysCodeCodeChallengeMethod$ = {}));
+/** @internal */
+export const CreateAuthKeysCodeRequest$inboundSchema = z.object({
+    callback_url: z.string(),
+    code_challenge: z.string().optional(),
+    code_challenge_method: CreateAuthKeysCodeCodeChallengeMethod$inboundSchema
+        .optional(),
+    limit: z.number().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "callback_url": "callbackUrl",
+        "code_challenge": "codeChallenge",
+        "code_challenge_method": "codeChallengeMethod",
+    });
+});
+/** @internal */
+export const CreateAuthKeysCodeRequest$outboundSchema = z.object({
+    callbackUrl: z.string(),
+    codeChallenge: z.string().optional(),
+    codeChallengeMethod: CreateAuthKeysCodeCodeChallengeMethod$outboundSchema
+        .optional(),
+    limit: z.number().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        callbackUrl: "callback_url",
+        codeChallenge: "code_challenge",
+        codeChallengeMethod: "code_challenge_method",
+    });
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var CreateAuthKeysCodeRequest$;
+(function (CreateAuthKeysCodeRequest$) {
+    /** @deprecated use `CreateAuthKeysCodeRequest$inboundSchema` instead. */
+    CreateAuthKeysCodeRequest$.inboundSchema = CreateAuthKeysCodeRequest$inboundSchema;
+    /** @deprecated use `CreateAuthKeysCodeRequest$outboundSchema` instead. */
+    CreateAuthKeysCodeRequest$.outboundSchema = CreateAuthKeysCodeRequest$outboundSchema;
+})(CreateAuthKeysCodeRequest$ || (CreateAuthKeysCodeRequest$ = {}));
+export function createAuthKeysCodeRequestToJSON(createAuthKeysCodeRequest) {
+    return JSON.stringify(CreateAuthKeysCodeRequest$outboundSchema.parse(createAuthKeysCodeRequest));
+}
+export function createAuthKeysCodeRequestFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CreateAuthKeysCodeRequest$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateAuthKeysCodeRequest' from JSON`);
+}
+/** @internal */
+export const CreateAuthKeysCodeData$inboundSchema = z.object({
+    id: z.string(),
+    app_id: z.number(),
+    created_at: z.string(),
+}).transform((v) => {
+    return remap$(v, {
+        "app_id": "appId",
+        "created_at": "createdAt",
+    });
+});
+/** @internal */
+export const CreateAuthKeysCodeData$outboundSchema = z.object({
+    id: z.string(),
+    appId: z.number(),
+    createdAt: z.string(),
+}).transform((v) => {
+    return remap$(v, {
+        appId: "app_id",
+        createdAt: "created_at",
+    });
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var CreateAuthKeysCodeData$;
+(function (CreateAuthKeysCodeData$) {
+    /** @deprecated use `CreateAuthKeysCodeData$inboundSchema` instead. */
+    CreateAuthKeysCodeData$.inboundSchema = CreateAuthKeysCodeData$inboundSchema;
+    /** @deprecated use `CreateAuthKeysCodeData$outboundSchema` instead. */
+    CreateAuthKeysCodeData$.outboundSchema = CreateAuthKeysCodeData$outboundSchema;
+})(CreateAuthKeysCodeData$ || (CreateAuthKeysCodeData$ = {}));
+export function createAuthKeysCodeDataToJSON(createAuthKeysCodeData) {
+    return JSON.stringify(CreateAuthKeysCodeData$outboundSchema.parse(createAuthKeysCodeData));
+}
+export function createAuthKeysCodeDataFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CreateAuthKeysCodeData$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateAuthKeysCodeData' from JSON`);
+}
+/** @internal */
+export const CreateAuthKeysCodeResponse$inboundSchema = z.object({
+    data: z.lazy(() => CreateAuthKeysCodeData$inboundSchema),
+});
+/** @internal */
+export const CreateAuthKeysCodeResponse$outboundSchema = z.object({
+    data: z.lazy(() => CreateAuthKeysCodeData$outboundSchema),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var CreateAuthKeysCodeResponse$;
+(function (CreateAuthKeysCodeResponse$) {
+    /** @deprecated use `CreateAuthKeysCodeResponse$inboundSchema` instead. */
+    CreateAuthKeysCodeResponse$.inboundSchema = CreateAuthKeysCodeResponse$inboundSchema;
+    /** @deprecated use `CreateAuthKeysCodeResponse$outboundSchema` instead. */
+    CreateAuthKeysCodeResponse$.outboundSchema = CreateAuthKeysCodeResponse$outboundSchema;
+})(CreateAuthKeysCodeResponse$ || (CreateAuthKeysCodeResponse$ = {}));
+export function createAuthKeysCodeResponseToJSON(createAuthKeysCodeResponse) {
+    return JSON.stringify(CreateAuthKeysCodeResponse$outboundSchema.parse(createAuthKeysCodeResponse));
+}
+export function createAuthKeysCodeResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CreateAuthKeysCodeResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateAuthKeysCodeResponse' from JSON`);
+}
+//# sourceMappingURL=createauthkeyscode.js.map

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

@@ -0,0 +1,58 @@
+import * as z from "zod/v4";
+import { EventStream } from "../../lib/event-streams.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import * as models from "../index.js";
+/**
+ * Successful response
+ */
+export type CreateResponsesResponseBody = {
+    /**
+     * Union of all possible event types emitted during response streaming
+     */
+    data: models.OpenResponsesStreamEvent;
+};
+export type CreateResponsesResponse = models.OpenResponsesNonStreamingResponse | EventStream<models.OpenResponsesStreamEvent>;
+/** @internal */
+export declare const CreateResponsesResponseBody$inboundSchema: z.ZodType<CreateResponsesResponseBody, unknown>;
+/** @internal */
+export type CreateResponsesResponseBody$Outbound = {
+    data: models.OpenResponsesStreamEvent$Outbound;
+};
+/** @internal */
+export declare const CreateResponsesResponseBody$outboundSchema: z.ZodType<CreateResponsesResponseBody$Outbound, CreateResponsesResponseBody>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace CreateResponsesResponseBody$ {
+    /** @deprecated use `CreateResponsesResponseBody$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<CreateResponsesResponseBody, unknown, z.core.$ZodTypeInternals<CreateResponsesResponseBody, unknown>>;
+    /** @deprecated use `CreateResponsesResponseBody$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<CreateResponsesResponseBody$Outbound, CreateResponsesResponseBody, z.core.$ZodTypeInternals<CreateResponsesResponseBody$Outbound, CreateResponsesResponseBody>>;
+    /** @deprecated use `CreateResponsesResponseBody$Outbound` instead. */
+    type Outbound = CreateResponsesResponseBody$Outbound;
+}
+export declare function createResponsesResponseBodyToJSON(createResponsesResponseBody: CreateResponsesResponseBody): string;
+export declare function createResponsesResponseBodyFromJSON(jsonString: string): SafeParseResult<CreateResponsesResponseBody, SDKValidationError>;
+/** @internal */
+export declare const CreateResponsesResponse$inboundSchema: z.ZodType<CreateResponsesResponse, unknown>;
+/** @internal */
+export type CreateResponsesResponse$Outbound = models.OpenResponsesNonStreamingResponse$Outbound | never;
+/** @internal */
+export declare const CreateResponsesResponse$outboundSchema: z.ZodType<CreateResponsesResponse$Outbound, CreateResponsesResponse>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace CreateResponsesResponse$ {
+    /** @deprecated use `CreateResponsesResponse$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<CreateResponsesResponse, unknown, z.core.$ZodTypeInternals<CreateResponsesResponse, unknown>>;
+    /** @deprecated use `CreateResponsesResponse$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<models.OpenResponsesNonStreamingResponse$Outbound, CreateResponsesResponse, z.core.$ZodTypeInternals<models.OpenResponsesNonStreamingResponse$Outbound, CreateResponsesResponse>>;
+    /** @deprecated use `CreateResponsesResponse$Outbound` instead. */
+    type Outbound = CreateResponsesResponse$Outbound;
+}
+export declare function createResponsesResponseToJSON(createResponsesResponse: CreateResponsesResponse): string;
+export declare function createResponsesResponseFromJSON(jsonString: string): SafeParseResult<CreateResponsesResponse, SDKValidationError>;
+//# sourceMappingURL=createresponses.d.ts.map