@openrouter/sdk 1.3.21 → 1.3.23

package/esm/funcs/imagesGenerate.js

@@ -9,14 +9,14 @@ 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 { BadGatewayResponseError$inboundSchema as errors_BadGatewayResponseError$inboundSchema } from "../models/errors/badgatewayresponseerror.js"; import { BadRequestResponseError$inboundSchema as errors_BadRequestResponseError$inboundSchema } from "../models/errors/badrequestresponseerror.js"; import { EdgeNetworkTimeoutResponseError$inboundSchema as errors_EdgeNetworkTimeoutResponseError$inboundSchema } from "../models/errors/edgenetworktimeoutresponseerror.js"; import { ForbiddenResponseError$inboundSchema as errors_ForbiddenResponseError$inboundSchema } from "../models/errors/forbiddenresponseerror.js"; import { InternalServerResponseError$inboundSchema as errors_InternalServerResponseError$inboundSchema } from "../models/errors/internalserverresponseerror.js"; import { NotFoundResponseError$inboundSchema as errors_NotFoundResponseError$inboundSchema } from "../models/errors/notfoundresponseerror.js"; import { PayloadTooLargeResponseError$inboundSchema as errors_PayloadTooLargeResponseError$inboundSchema } from "../models/errors/payloadtoolargeresponseerror.js"; import { PaymentRequiredResponseError$inboundSchema as errors_PaymentRequiredResponseError$inboundSchema } from "../models/errors/paymentrequiredresponseerror.js"; import { ProviderOverloadedResponseError$inboundSchema as errors_ProviderOverloadedResponseError$inboundSchema } from "../models/errors/provideroverloadedresponseerror.js"; import { TooManyRequestsResponseError$inboundSchema as errors_TooManyRequestsResponseError$inboundSchema } from "../models/errors/toomanyrequestsresponseerror.js"; import { UnauthorizedResponseError$inboundSchema as errors_UnauthorizedResponseError$inboundSchema } from "../models/errors/unauthorizedresponseerror.js";
+import { CreateImagesRequest$outboundSchema as operations_CreateImagesRequest$outboundSchema, CreateImagesResponse$inboundSchema as operations_CreateImagesResponse$inboundSchema } from "../models/operations/createimages.js";
 import { APIPromise } from "../types/async.js";
 export function imagesGenerate(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.CreateImagesRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_CreateImagesRequest$outboundSchema.parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -86,7 +86,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, operations.CreateImagesResponse$inboundSchema), M.sse(200, operations.CreateImagesResponse$inboundSchema), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(402, errors.PaymentRequiredResponseError$inboundSchema), M.jsonErr(403, errors.ForbiddenResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$inboundSchema), M.jsonErr(413, errors.PayloadTooLargeResponseError$inboundSchema), M.jsonErr(429, errors.TooManyRequestsResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.jsonErr(502, errors.BadGatewayResponseError$inboundSchema), M.jsonErr(524, errors.EdgeNetworkTimeoutResponseError$inboundSchema), M.jsonErr(529, errors.ProviderOverloadedResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(200, operations_CreateImagesResponse$inboundSchema), M.sse(200, operations_CreateImagesResponse$inboundSchema), M.jsonErr(400, errors_BadRequestResponseError$inboundSchema), M.jsonErr(401, errors_UnauthorizedResponseError$inboundSchema), M.jsonErr(402, errors_PaymentRequiredResponseError$inboundSchema), M.jsonErr(403, errors_ForbiddenResponseError$inboundSchema), M.jsonErr(404, errors_NotFoundResponseError$inboundSchema), M.jsonErr(413, errors_PayloadTooLargeResponseError$inboundSchema), M.jsonErr(429, errors_TooManyRequestsResponseError$inboundSchema), M.jsonErr(500, errors_InternalServerResponseError$inboundSchema), M.jsonErr(502, errors_BadGatewayResponseError$inboundSchema), M.jsonErr(524, errors_EdgeNetworkTimeoutResponseError$inboundSchema), M.jsonErr(529, errors_ProviderOverloadedResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/imagesListModelEndpoints.js

@@ -9,9 +9,9 @@ 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 models from "../models/index.js";
-import * as operations from "../models/operations/index.js";
+import { InternalServerResponseError$inboundSchema as errors_InternalServerResponseError$inboundSchema } from "../models/errors/internalserverresponseerror.js"; import { NotFoundResponseError$inboundSchema as errors_NotFoundResponseError$inboundSchema } from "../models/errors/notfoundresponseerror.js";
+import { ImageModelEndpointsResponse$inboundSchema as models_ImageModelEndpointsResponse$inboundSchema } from "../models/imagemodelendpointsresponse.js";
+import { ListImageModelEndpointsRequest$outboundSchema as operations_ListImageModelEndpointsRequest$outboundSchema } from "../models/operations/listimagemodelendpoints.js";
 import { APIPromise } from "../types/async.js";
 /**
  * List endpoints for an image model
@@ -23,7 +23,7 @@ export function imagesListModelEndpoints(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.ListImageModelEndpointsRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_ListImageModelEndpointsRequest$outboundSchema.parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -98,7 +98,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, models.ImageModelEndpointsResponse$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$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_ImageModelEndpointsResponse$inboundSchema), M.jsonErr(404, errors_NotFoundResponseError$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/imagesListModels.js

@@ -9,9 +9,9 @@ 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 models from "../models/index.js";
-import * as operations from "../models/operations/index.js";
+import { InternalServerResponseError$inboundSchema as errors_InternalServerResponseError$inboundSchema } from "../models/errors/internalserverresponseerror.js";
+import { ImageModelsListResponse$inboundSchema as models_ImageModelsListResponse$inboundSchema } from "../models/imagemodelslistresponse.js";
+import { ListImageModelsRequest$outboundSchema as operations_ListImageModelsRequest$outboundSchema } from "../models/operations/listimagemodels.js";
 import { APIPromise } from "../types/async.js";
 /**
  * List image generation models
@@ -23,7 +23,7 @@ export function imagesListModels(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.ListImageModelsRequest$outboundSchema.optional().parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_ListImageModelsRequest$outboundSchema.optional().parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -88,7 +88,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, models.ImageModelsListResponse$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_ImageModelsListResponse$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/internsChat.js

@@ -9,14 +9,14 @@ 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 { InternChatErrorResponse$inboundSchema as errors_InternChatErrorResponse$inboundSchema } from "../models/errors/internchaterrorresponse.js";
+import { CreateInternChatCompletionRequest$outboundSchema as operations_CreateInternChatCompletionRequest$outboundSchema, CreateInternChatCompletionResponse$inboundSchema as operations_CreateInternChatCompletionResponse$inboundSchema } from "../models/operations/createinternchatcompletion.js";
 import { APIPromise } from "../types/async.js";
 export function internsChat(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.CreateInternChatCompletionRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_CreateInternChatCompletionRequest$outboundSchema.parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -92,15 +92,15 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.sse(200, operations.CreateInternChatCompletionResponse$inboundSchema, {
+    const [result] = await M.match(M.sse(200, operations_CreateInternChatCompletionResponse$inboundSchema, {
         key: "Result",
-    }), M.json(202, operations.CreateInternChatCompletionResponse$inboundSchema, {
+    }), M.json(202, operations_CreateInternChatCompletionResponse$inboundSchema, {
         key: "Result",
-    }), M.jsonErr([400, 401, 403, 404, 408, 410, 413], errors.InternChatErrorResponse$inboundSchema), M.jsonErr([409, 429], errors.InternChatErrorResponse$inboundSchema, {
+    }), M.jsonErr([400, 401, 403, 404, 408, 410, 413], errors_InternChatErrorResponse$inboundSchema), M.jsonErr([409, 429], errors_InternChatErrorResponse$inboundSchema, {
         hdrs: true,
-    }), M.jsonErr(503, errors.InternChatErrorResponse$inboundSchema, {
+    }), M.jsonErr(503, errors_InternChatErrorResponse$inboundSchema, {
         hdrs: true,
-    }), M.jsonErr([502, 504], errors.InternChatErrorResponse$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    }), M.jsonErr([502, 504], errors_InternChatErrorResponse$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/internsCreateIntern.js

@@ -9,9 +9,9 @@ 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 models from "../models/index.js";
-import * as operations from "../models/operations/index.js";
+import { InternLifecycleError$inboundSchema as errors_InternLifecycleError$inboundSchema } from "../models/errors/internlifecycleerror.js";
+import { Intern$inboundSchema as models_Intern$inboundSchema } from "../models/intern.js";
+import { CreateInternRequest$outboundSchema as operations_CreateInternRequest$outboundSchema } from "../models/operations/createintern.js";
 import { APIPromise } from "../types/async.js";
 /**
  * Create an intern
@@ -25,7 +25,7 @@ export function internsCreateIntern(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.CreateInternRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_CreateInternRequest$outboundSchema.parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -94,7 +94,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json([200, 201], models.Intern$inboundSchema), M.jsonErr([400, 401, 403, 404, 408, 409, 413, 415], errors.InternLifecycleError$inboundSchema), M.jsonErr([500, 502], errors.InternLifecycleError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json([200, 201], models_Intern$inboundSchema), M.jsonErr([400, 401, 403, 404, 408, 409, 413, 415], errors_InternLifecycleError$inboundSchema), M.jsonErr([500, 502], errors_InternLifecycleError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/internsDeleteIntern.js

@@ -9,9 +9,9 @@ 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 models from "../models/index.js";
-import * as operations from "../models/operations/index.js";
+import { InternLifecycleError$inboundSchema as errors_InternLifecycleError$inboundSchema } from "../models/errors/internlifecycleerror.js";
+import { DeleteInternResponse$inboundSchema as models_DeleteInternResponse$inboundSchema } from "../models/deleteinternresponse.js";
+import { DeleteInternRequest$outboundSchema as operations_DeleteInternRequest$outboundSchema } from "../models/operations/deleteintern.js";
 import { APIPromise } from "../types/async.js";
 /**
  * Delete an intern
@@ -25,7 +25,7 @@ export function internsDeleteIntern(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.DeleteInternRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_DeleteInternRequest$outboundSchema.parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -99,7 +99,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(202, models.DeleteInternResponse$inboundSchema), M.jsonErr([400, 401, 403, 404, 408, 409, 413, 415], errors.InternLifecycleError$inboundSchema), M.jsonErr([500, 502], errors.InternLifecycleError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(202, models_DeleteInternResponse$inboundSchema), M.jsonErr([400, 401, 403, 404, 408, 409, 413, 415], errors_InternLifecycleError$inboundSchema), M.jsonErr([500, 502], errors_InternLifecycleError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/internsGetIntern.js

@@ -9,9 +9,9 @@ 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 models from "../models/index.js";
-import * as operations from "../models/operations/index.js";
+import { InternLifecycleError$inboundSchema as errors_InternLifecycleError$inboundSchema } from "../models/errors/internlifecycleerror.js";
+import { Intern$inboundSchema as models_Intern$inboundSchema } from "../models/intern.js";
+import { GetInternRequest$outboundSchema as operations_GetInternRequest$outboundSchema } from "../models/operations/getintern.js";
 import { APIPromise } from "../types/async.js";
 /**
  * Get an intern
@@ -25,7 +25,7 @@ export function internsGetIntern(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.GetInternRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_GetInternRequest$outboundSchema.parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -96,7 +96,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, models.Intern$inboundSchema), M.jsonErr([401, 403, 404, 408], errors.InternLifecycleError$inboundSchema), M.jsonErr(500, errors.InternLifecycleError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(200, models_Intern$inboundSchema), M.jsonErr([401, 403, 404, 408], errors_InternLifecycleError$inboundSchema), M.jsonErr(500, errors_InternLifecycleError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/internsInvoke.js

@@ -9,8 +9,8 @@ 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 { InternChatErrorResponse$inboundSchema as errors_InternChatErrorResponse$inboundSchema } from "../models/errors/internchaterrorresponse.js";
+import { InvokeInternRequest$outboundSchema as operations_InvokeInternRequest$outboundSchema, InvokeInternResponse$inboundSchema as operations_InvokeInternResponse$inboundSchema } from "../models/operations/invokeintern.js";
 import { APIPromise } from "../types/async.js";
 /**
  * Start an intern run without waiting for it
@@ -30,7 +30,7 @@ export function internsInvoke(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.InvokeInternRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_InvokeInternRequest$outboundSchema.parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -104,13 +104,13 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(202, operations.InvokeInternResponse$inboundSchema, {
+    const [result] = await M.match(M.json(202, operations_InvokeInternResponse$inboundSchema, {
         key: "Result",
-    }), M.jsonErr([400, 401, 403, 404, 408, 413], errors.InternChatErrorResponse$inboundSchema), M.jsonErr([409, 429], errors.InternChatErrorResponse$inboundSchema, {
+    }), M.jsonErr([400, 401, 403, 404, 408, 413], errors_InternChatErrorResponse$inboundSchema), M.jsonErr([409, 429], errors_InternChatErrorResponse$inboundSchema, {
         hdrs: true,
-    }), M.jsonErr(503, errors.InternChatErrorResponse$inboundSchema, {
+    }), M.jsonErr(503, errors_InternChatErrorResponse$inboundSchema, {
         hdrs: true,
-    }), M.jsonErr([500, 502, 504], errors.InternChatErrorResponse$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    }), M.jsonErr([500, 502, 504], errors_InternChatErrorResponse$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/internsListInterns.js

@@ -9,9 +9,9 @@ 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 models from "../models/index.js";
-import * as operations from "../models/operations/index.js";
+import { InternLifecycleError$inboundSchema as errors_InternLifecycleError$inboundSchema } from "../models/errors/internlifecycleerror.js";
+import { InternListResponse$inboundSchema as models_InternListResponse$inboundSchema } from "../models/internlistresponse.js";
+import { ListInternsRequest$outboundSchema as operations_ListInternsRequest$outboundSchema } from "../models/operations/listinterns.js";
 import { APIPromise } from "../types/async.js";
 /**
  * List interns
@@ -25,7 +25,7 @@ export function internsListInterns(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.ListInternsRequest$outboundSchema.optional().parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_ListInternsRequest$outboundSchema.optional().parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -98,7 +98,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, models.InternListResponse$inboundSchema), M.jsonErr([400, 401, 403, 404, 408], errors.InternLifecycleError$inboundSchema), M.jsonErr(500, errors.InternLifecycleError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(200, models_InternListResponse$inboundSchema), M.jsonErr([400, 401, 403, 404, 408], errors_InternLifecycleError$inboundSchema), M.jsonErr(500, errors_InternLifecycleError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/internsProvisionIntern.js

@@ -9,9 +9,9 @@ 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 models from "../models/index.js";
-import * as operations from "../models/operations/index.js";
+import { InternLifecycleError$inboundSchema as errors_InternLifecycleError$inboundSchema } from "../models/errors/internlifecycleerror.js";
+import { ProvisionInternResponse$inboundSchema as models_ProvisionInternResponse$inboundSchema } from "../models/provisioninternresponse.js";
+import { ProvisionInternRequest$outboundSchema as operations_ProvisionInternRequest$outboundSchema } from "../models/operations/provisionintern.js";
 import { APIPromise } from "../types/async.js";
 /**
  * Provision an intern
@@ -25,7 +25,7 @@ export function internsProvisionIntern(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.ProvisionInternRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_ProvisionInternRequest$outboundSchema.parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -96,7 +96,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(202, models.ProvisionInternResponse$inboundSchema), M.jsonErr([400, 401, 403, 404, 408, 409, 413, 415], errors.InternLifecycleError$inboundSchema), M.jsonErr([500, 502], errors.InternLifecycleError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(202, models_ProvisionInternResponse$inboundSchema), M.jsonErr([400, 401, 403, 404, 408, 409, 413, 415], errors_InternLifecycleError$inboundSchema), M.jsonErr([500, 502], errors_InternLifecycleError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/internsSuspendIntern.js

@@ -9,9 +9,9 @@ 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 models from "../models/index.js";
-import * as operations from "../models/operations/index.js";
+import { InternLifecycleError$inboundSchema as errors_InternLifecycleError$inboundSchema } from "../models/errors/internlifecycleerror.js";
+import { SuspendInternResponse$inboundSchema as models_SuspendInternResponse$inboundSchema } from "../models/suspendinternresponse.js";
+import { SuspendInternRequest$outboundSchema as operations_SuspendInternRequest$outboundSchema } from "../models/operations/suspendintern.js";
 import { APIPromise } from "../types/async.js";
 /**
  * Suspend an intern
@@ -25,7 +25,7 @@ export function internsSuspendIntern(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.SuspendInternRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_SuspendInternRequest$outboundSchema.parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -96,7 +96,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, models.SuspendInternResponse$inboundSchema), M.jsonErr([400, 401, 403, 404, 408, 409, 413, 415], errors.InternLifecycleError$inboundSchema), M.jsonErr([500, 502], errors.InternLifecycleError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(200, models_SuspendInternResponse$inboundSchema), M.jsonErr([400, 401, 403, 404, 408, 409, 413, 415], errors_InternLifecycleError$inboundSchema), M.jsonErr([500, 502], errors_InternLifecycleError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/internsUpdateIntern.js

@@ -9,9 +9,9 @@ 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 models from "../models/index.js";
-import * as operations from "../models/operations/index.js";
+import { InternLifecycleError$inboundSchema as errors_InternLifecycleError$inboundSchema } from "../models/errors/internlifecycleerror.js";
+import { Intern$inboundSchema as models_Intern$inboundSchema } from "../models/intern.js";
+import { UpdateInternRequest$outboundSchema as operations_UpdateInternRequest$outboundSchema } from "../models/operations/updateintern.js";
 import { APIPromise } from "../types/async.js";
 /**
  * Update an intern
@@ -25,7 +25,7 @@ export function internsUpdateIntern(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.UpdateInternRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_UpdateInternRequest$outboundSchema.parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -99,7 +99,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, models.Intern$inboundSchema), M.jsonErr([400, 401, 403, 404, 408, 409, 413, 415], errors.InternLifecycleError$inboundSchema), M.jsonErr(500, errors.InternLifecycleError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(200, models_Intern$inboundSchema), M.jsonErr([400, 401, 403, 404, 408, 409, 413, 415], errors_InternLifecycleError$inboundSchema), M.jsonErr(500, errors_InternLifecycleError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/modelsCount.js

@@ -9,9 +9,9 @@ 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 models from "../models/index.js";
-import * as operations from "../models/operations/index.js";
+import { BadRequestResponseError$inboundSchema as errors_BadRequestResponseError$inboundSchema } from "../models/errors/badrequestresponseerror.js"; import { ForbiddenResponseError$inboundSchema as errors_ForbiddenResponseError$inboundSchema } from "../models/errors/forbiddenresponseerror.js"; import { InternalServerResponseError$inboundSchema as errors_InternalServerResponseError$inboundSchema } from "../models/errors/internalserverresponseerror.js";
+import { ModelsCountResponse$inboundSchema as models_ModelsCountResponse$inboundSchema } from "../models/modelscountresponse.js";
+import { ListModelsCountRequest$outboundSchema as operations_ListModelsCountRequest$outboundSchema } from "../models/operations/listmodelscount.js";
 import { APIPromise } from "../types/async.js";
 /**
  * Get total count of available models
@@ -20,7 +20,7 @@ export function modelsCount(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.ListModelsCountRequest$outboundSchema.optional().parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_ListModelsCountRequest$outboundSchema.optional().parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -89,7 +89,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, models.ModelsCountResponse$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 });
+    const [result] = await M.match(M.json(200, models_ModelsCountResponse$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 }];
     }

package/esm/funcs/modelsGet.js

@@ -9,9 +9,9 @@ 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 models from "../models/index.js";
-import * as operations from "../models/operations/index.js";
+import { ForbiddenResponseError$inboundSchema as errors_ForbiddenResponseError$inboundSchema } from "../models/errors/forbiddenresponseerror.js"; import { InternalServerResponseError$inboundSchema as errors_InternalServerResponseError$inboundSchema } from "../models/errors/internalserverresponseerror.js"; import { NotFoundResponseError$inboundSchema as errors_NotFoundResponseError$inboundSchema } from "../models/errors/notfoundresponseerror.js";
+import { ModelResponse$inboundSchema as models_ModelResponse$inboundSchema } from "../models/modelresponse.js";
+import { GetModelRequest$outboundSchema as operations_GetModelRequest$outboundSchema } from "../models/operations/getmodel.js";
 import { APIPromise } from "../types/async.js";
 /**
  * Get a model by its slug
@@ -23,7 +23,7 @@ export function modelsGet(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.GetModelRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_GetModelRequest$outboundSchema.parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -98,7 +98,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, models.ModelResponse$inboundSchema), M.jsonErr(403, errors.ForbiddenResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$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_ModelResponse$inboundSchema), M.jsonErr(403, errors_ForbiddenResponseError$inboundSchema), M.jsonErr(404, errors_NotFoundResponseError$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/modelsList.js

@@ -9,8 +9,8 @@ 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 { BadRequestResponseError$inboundSchema as errors_BadRequestResponseError$inboundSchema } from "../models/errors/badrequestresponseerror.js"; import { ForbiddenResponseError$inboundSchema as errors_ForbiddenResponseError$inboundSchema } from "../models/errors/forbiddenresponseerror.js"; import { InternalServerResponseError$inboundSchema as errors_InternalServerResponseError$inboundSchema } from "../models/errors/internalserverresponseerror.js";
+import { GetModelsRequest$outboundSchema as operations_GetModelsRequest$outboundSchema, GetModelsResponse$inboundSchema as operations_GetModelsResponse$inboundSchema } from "../models/operations/getmodels.js";
 import { APIPromise } from "../types/async.js";
 import { createPageIterator, haltIterator, } from "../types/operations.js";
 /**
@@ -20,7 +20,7 @@ export function modelsList(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.GetModelsRequest$outboundSchema.optional().parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_GetModelsRequest$outboundSchema.optional().parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [haltIterator(parsed), { status: "invalid" }];
     }
@@ -117,7 +117,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result, raw] = await M.match(M.json(200, operations.GetModelsResponse$inboundSchema, { key: "Result" }), 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 });
+    const [result, raw] = await M.match(M.json(200, operations_GetModelsResponse$inboundSchema, { key: "Result" }), 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 [haltIterator(result), {
                 status: "complete",

package/esm/funcs/modelsListForUser.js

@@ -9,8 +9,8 @@ import { compactMap } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { resolveSecurity } 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 { ForbiddenResponseError$inboundSchema as errors_ForbiddenResponseError$inboundSchema } from "../models/errors/forbiddenresponseerror.js"; import { InternalServerResponseError$inboundSchema as errors_InternalServerResponseError$inboundSchema } from "../models/errors/internalserverresponseerror.js"; import { NotFoundResponseError$inboundSchema as errors_NotFoundResponseError$inboundSchema } from "../models/errors/notfoundresponseerror.js"; import { UnauthorizedResponseError$inboundSchema as errors_UnauthorizedResponseError$inboundSchema } from "../models/errors/unauthorizedresponseerror.js";
+import { ListModelsUserRequest$outboundSchema as operations_ListModelsUserRequest$outboundSchema, ListModelsUserResponse$inboundSchema as operations_ListModelsUserResponse$inboundSchema } from "../models/operations/listmodelsuser.js";
 import { APIPromise } from "../types/async.js";
 import { createPageIterator, haltIterator, } from "../types/operations.js";
 /**
@@ -23,7 +23,7 @@ export function modelsListForUser(client, security, request, options) {
     return new APIPromise($do(client, security, request, options));
 }
 async function $do(client, security, request, options) {
-    const parsed = safeParse(request, (value) => operations.ListModelsUserRequest$outboundSchema.optional().parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_ListModelsUserRequest$outboundSchema.optional().parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [haltIterator(parsed), { status: "invalid" }];
     }
@@ -98,9 +98,9 @@ async function $do(client, security, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result, raw] = await M.match(M.json(200, operations.ListModelsUserResponse$inboundSchema, {
+    const [result, raw] = await M.match(M.json(200, operations_ListModelsUserResponse$inboundSchema, {
         key: "Result",
-    }), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(403, errors.ForbiddenResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    }), M.jsonErr(401, errors_UnauthorizedResponseError$inboundSchema), M.jsonErr(403, errors_ForbiddenResponseError$inboundSchema), M.jsonErr(404, errors_NotFoundResponseError$inboundSchema), M.jsonErr(500, errors_InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [haltIterator(result), {
                 status: "complete",

package/esm/funcs/oAuthCreateAuthCode.js

@@ -9,8 +9,8 @@ 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 { BadRequestResponseError$inboundSchema as errors_BadRequestResponseError$inboundSchema } from "../models/errors/badrequestresponseerror.js"; import { ConflictResponseError$inboundSchema as errors_ConflictResponseError$inboundSchema } from "../models/errors/conflictresponseerror.js"; import { ForbiddenResponseError$inboundSchema as errors_ForbiddenResponseError$inboundSchema } from "../models/errors/forbiddenresponseerror.js"; import { InternalServerResponseError$inboundSchema as errors_InternalServerResponseError$inboundSchema } from "../models/errors/internalserverresponseerror.js"; import { UnauthorizedResponseError$inboundSchema as errors_UnauthorizedResponseError$inboundSchema } from "../models/errors/unauthorizedresponseerror.js";
+import { CreateAuthKeysCodeRequest$outboundSchema as operations_CreateAuthKeysCodeRequest$outboundSchema, CreateAuthKeysCodeResponse$inboundSchema as operations_CreateAuthKeysCodeResponse$inboundSchema } from "../models/operations/createauthkeyscode.js";
 import { APIPromise } from "../types/async.js";
 /**
  * Create authorization code
@@ -22,7 +22,7 @@ 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");
+    const parsed = safeParse(request, (value) => operations_CreateAuthKeysCodeRequest$outboundSchema.parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -88,7 +88,7 @@ async function $do(client, request, options) {
     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(403, errors.ForbiddenResponseError$inboundSchema), M.jsonErr(409, errors.ConflictResponseError$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, operations_CreateAuthKeysCodeResponse$inboundSchema), M.jsonErr(400, errors_BadRequestResponseError$inboundSchema), M.jsonErr(401, errors_UnauthorizedResponseError$inboundSchema), M.jsonErr(403, errors_ForbiddenResponseError$inboundSchema), M.jsonErr(409, errors_ConflictResponseError$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/oAuthCreateOauthToken.js

@@ -9,9 +9,9 @@ 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 models from "../models/index.js";
-import * as operations from "../models/operations/index.js";
+import { OAuthErrorResponse$inboundSchema as errors_OAuthErrorResponse$inboundSchema } from "../models/errors/oautherrorresponse.js";
+import { TokenExchangeResponse$inboundSchema as models_TokenExchangeResponse$inboundSchema } from "../models/tokenexchangeresponse.js";
+import { CreateOauthTokenRequest$outboundSchema as operations_CreateOauthTokenRequest$outboundSchema } from "../models/operations/createoauthtoken.js";
 import { APIPromise } from "../types/async.js";
 /**
  * Exchange a workload identity token
@@ -23,7 +23,7 @@ export function oAuthCreateOauthToken(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.CreateOauthTokenRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_CreateOauthTokenRequest$outboundSchema.parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -91,7 +91,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, models.TokenExchangeResponse$inboundSchema), M.jsonErr([400, 429], errors.OAuthErrorResponse$inboundSchema), M.jsonErr([500, 503], errors.OAuthErrorResponse$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(200, models_TokenExchangeResponse$inboundSchema), M.jsonErr([400, 429], errors_OAuthErrorResponse$inboundSchema), M.jsonErr([500, 503], errors_OAuthErrorResponse$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }