@openrouter/sdk 1.3.20 → 1.3.22

package/esm/funcs/filesUpload.js

@@ -10,9 +10,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 { BadGatewayResponseError$inboundSchema as errors_BadGatewayResponseError$inboundSchema } from "../models/errors/badgatewayresponseerror.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 { PayloadTooLargeResponseError$inboundSchema as errors_PayloadTooLargeResponseError$inboundSchema } from "../models/errors/payloadtoolargeresponseerror.js"; import { ServiceUnavailableResponseError$inboundSchema as errors_ServiceUnavailableResponseError$inboundSchema } from "../models/errors/serviceunavailableresponseerror.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 { FileResponse$inboundSchema as models_FileResponse$inboundSchema } from "../models/fileresponse.js";
+import { UploadFileRequest$outboundSchema as operations_UploadFileRequest$outboundSchema } from "../models/operations/uploadfile.js";
 import { APIPromise } from "../types/async.js";
 import { isBlobLike } from "../types/blobs.js";
 import { isReadableStream } from "../types/streams.js";
@@ -26,7 +26,7 @@ export function filesUpload(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.UploadFileRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_UploadFileRequest$outboundSchema.parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -113,7 +113,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, models.FileResponse$inboundSchema), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(403, errors.ForbiddenResponseError$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(503, errors.ServiceUnavailableResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(200, models_FileResponse$inboundSchema), M.jsonErr(400, errors_BadRequestResponseError$inboundSchema), M.jsonErr(401, errors_UnauthorizedResponseError$inboundSchema), M.jsonErr(403, errors_ForbiddenResponseError$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(503, errors_ServiceUnavailableResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/generationsGetGeneration.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 { BadGatewayResponseError$inboundSchema as errors_BadGatewayResponseError$inboundSchema } from "../models/errors/badgatewayresponseerror.js"; import { EdgeNetworkTimeoutResponseError$inboundSchema as errors_EdgeNetworkTimeoutResponseError$inboundSchema } from "../models/errors/edgenetworktimeoutresponseerror.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 { 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 { GenerationResponse$inboundSchema as models_GenerationResponse$inboundSchema } from "../models/generationresponse.js";
+import { GetGenerationRequest$outboundSchema as operations_GetGenerationRequest$outboundSchema } from "../models/operations/getgeneration.js";
 import { APIPromise } from "../types/async.js";
 /**
  * Get request & usage metadata for a generation
@@ -20,7 +20,7 @@ export function generationsGetGeneration(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.GetGenerationRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_GetGenerationRequest$outboundSchema.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.GenerationResponse$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(402, errors.PaymentRequiredResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$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, models_GenerationResponse$inboundSchema), M.jsonErr(401, errors_UnauthorizedResponseError$inboundSchema), M.jsonErr(402, errors_PaymentRequiredResponseError$inboundSchema), M.jsonErr(404, errors_NotFoundResponseError$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/generationsListGenerationContent.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 { BadGatewayResponseError$inboundSchema as errors_BadGatewayResponseError$inboundSchema } from "../models/errors/badgatewayresponseerror.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 { 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 { GenerationContentResponse$inboundSchema as models_GenerationContentResponse$inboundSchema } from "../models/generationcontentresponse.js";
+import { ListGenerationContentRequest$outboundSchema as operations_ListGenerationContentRequest$outboundSchema } from "../models/operations/listgenerationcontent.js";
 import { APIPromise } from "../types/async.js";
 /**
  * Get stored prompt, completion, and error content for a generation
@@ -20,7 +20,7 @@ export function generationsListGenerationContent(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.ListGenerationContentRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_ListGenerationContentRequest$outboundSchema.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.GenerationContentResponse$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(403, errors.ForbiddenResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$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, models_GenerationContentResponse$inboundSchema), M.jsonErr(401, errors_UnauthorizedResponseError$inboundSchema), M.jsonErr(403, errors_ForbiddenResponseError$inboundSchema), M.jsonErr(404, errors_NotFoundResponseError$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/generationsSubmitFeedback.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 { InternalServerResponseError$inboundSchema as errors_InternalServerResponseError$inboundSchema } from "../models/errors/internalserverresponseerror.js"; import { NotFoundResponseError$inboundSchema as errors_NotFoundResponseError$inboundSchema } from "../models/errors/notfoundresponseerror.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 { SubmitGenerationFeedbackResponse$inboundSchema as models_SubmitGenerationFeedbackResponse$inboundSchema } from "../models/submitgenerationfeedbackresponse.js";
+import { SubmitGenerationFeedbackRequest$outboundSchema as operations_SubmitGenerationFeedbackRequest$outboundSchema } from "../models/operations/submitgenerationfeedback.js";
 import { APIPromise } from "../types/async.js";
 /**
  * Submit feedback for a generation
@@ -23,7 +23,7 @@ export function generationsSubmitFeedback(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.SubmitGenerationFeedbackRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_SubmitGenerationFeedbackRequest$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.SubmitGenerationFeedbackResponse$inboundSchema), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$inboundSchema), M.jsonErr(429, errors.TooManyRequestsResponseError$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_SubmitGenerationFeedbackResponse$inboundSchema), M.jsonErr(400, errors_BadRequestResponseError$inboundSchema), M.jsonErr(401, errors_UnauthorizedResponseError$inboundSchema), M.jsonErr(404, errors_NotFoundResponseError$inboundSchema), M.jsonErr(429, errors_TooManyRequestsResponseError$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/guardrailsBulkAssignKeys.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 { NotFoundResponseError$inboundSchema as errors_NotFoundResponseError$inboundSchema } from "../models/errors/notfoundresponseerror.js"; import { UnauthorizedResponseError$inboundSchema as errors_UnauthorizedResponseError$inboundSchema } from "../models/errors/unauthorizedresponseerror.js";
+import { BulkAssignKeysResponse$inboundSchema as models_BulkAssignKeysResponse$inboundSchema } from "../models/bulkassignkeysresponse.js";
+import { BulkAssignKeysToGuardrailRequest$outboundSchema as operations_BulkAssignKeysToGuardrailRequest$outboundSchema } from "../models/operations/bulkassignkeystoguardrail.js";
 import { APIPromise } from "../types/async.js";
 /**
  * Bulk assign keys to a guardrail
@@ -23,7 +23,7 @@ export function guardrailsBulkAssignKeys(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.BulkAssignKeysToGuardrailRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_BulkAssignKeysToGuardrailRequest$outboundSchema.parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -97,7 +97,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, models.BulkAssignKeysResponse$inboundSchema), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), 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 });
+    const [result] = await M.match(M.json(200, models_BulkAssignKeysResponse$inboundSchema), M.jsonErr(400, errors_BadRequestResponseError$inboundSchema), 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 [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/guardrailsBulkAssignMembers.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 { 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 { BulkAssignMembersResponse$inboundSchema as models_BulkAssignMembersResponse$inboundSchema } from "../models/bulkassignmembersresponse.js";
+import { BulkAssignMembersToGuardrailRequest$outboundSchema as operations_BulkAssignMembersToGuardrailRequest$outboundSchema } from "../models/operations/bulkassignmemberstoguardrail.js";
 import { APIPromise } from "../types/async.js";
 /**
  * Bulk assign members to a guardrail
@@ -23,7 +23,7 @@ export function guardrailsBulkAssignMembers(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.BulkAssignMembersToGuardrailRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_BulkAssignMembersToGuardrailRequest$outboundSchema.parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -97,7 +97,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, models.BulkAssignMembersResponse$inboundSchema), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$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_BulkAssignMembersResponse$inboundSchema), M.jsonErr(400, errors_BadRequestResponseError$inboundSchema), M.jsonErr(401, errors_UnauthorizedResponseError$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/guardrailsBulkUnassignKeys.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 { 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 { BulkUnassignKeysResponse$inboundSchema as models_BulkUnassignKeysResponse$inboundSchema } from "../models/bulkunassignkeysresponse.js";
+import { BulkUnassignKeysFromGuardrailRequest$outboundSchema as operations_BulkUnassignKeysFromGuardrailRequest$outboundSchema } from "../models/operations/bulkunassignkeysfromguardrail.js";
 import { APIPromise } from "../types/async.js";
 /**
  * Bulk unassign keys from a guardrail
@@ -23,7 +23,7 @@ export function guardrailsBulkUnassignKeys(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.BulkUnassignKeysFromGuardrailRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_BulkUnassignKeysFromGuardrailRequest$outboundSchema.parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -97,7 +97,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, models.BulkUnassignKeysResponse$inboundSchema), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$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_BulkUnassignKeysResponse$inboundSchema), M.jsonErr(400, errors_BadRequestResponseError$inboundSchema), M.jsonErr(401, errors_UnauthorizedResponseError$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/guardrailsBulkUnassignMembers.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 { 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 { BulkUnassignMembersResponse$inboundSchema as models_BulkUnassignMembersResponse$inboundSchema } from "../models/bulkunassignmembersresponse.js";
+import { BulkUnassignMembersFromGuardrailRequest$outboundSchema as operations_BulkUnassignMembersFromGuardrailRequest$outboundSchema } from "../models/operations/bulkunassignmembersfromguardrail.js";
 import { APIPromise } from "../types/async.js";
 /**
  * Bulk unassign members from a guardrail
@@ -23,7 +23,7 @@ export function guardrailsBulkUnassignMembers(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.BulkUnassignMembersFromGuardrailRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_BulkUnassignMembersFromGuardrailRequest$outboundSchema.parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -97,7 +97,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, models.BulkUnassignMembersResponse$inboundSchema), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$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_BulkUnassignMembersResponse$inboundSchema), M.jsonErr(400, errors_BadRequestResponseError$inboundSchema), M.jsonErr(401, errors_UnauthorizedResponseError$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/guardrailsCreate.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 { UnauthorizedResponseError$inboundSchema as errors_UnauthorizedResponseError$inboundSchema } from "../models/errors/unauthorizedresponseerror.js";
+import { CreateGuardrailResponse$inboundSchema as models_CreateGuardrailResponse$inboundSchema } from "../models/createguardrailresponse.js";
+import { CreateGuardrailRequest$outboundSchema as operations_CreateGuardrailRequest$outboundSchema } from "../models/operations/createguardrail.js";
 import { APIPromise } from "../types/async.js";
 /**
  * Create a guardrail
@@ -23,7 +23,7 @@ export function guardrailsCreate(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.CreateGuardrailRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_CreateGuardrailRequest$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(201, models.CreateGuardrailResponse$inboundSchema), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$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(201, models_CreateGuardrailResponse$inboundSchema), M.jsonErr(400, errors_BadRequestResponseError$inboundSchema), M.jsonErr(401, errors_UnauthorizedResponseError$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/guardrailsDelete.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 { UnauthorizedResponseError$inboundSchema as errors_UnauthorizedResponseError$inboundSchema } from "../models/errors/unauthorizedresponseerror.js";
+import { DeleteGuardrailResponse$inboundSchema as models_DeleteGuardrailResponse$inboundSchema } from "../models/deleteguardrailresponse.js";
+import { DeleteGuardrailRequest$outboundSchema as operations_DeleteGuardrailRequest$outboundSchema } from "../models/operations/deleteguardrail.js";
 import { APIPromise } from "../types/async.js";
 /**
  * Delete a guardrail
@@ -23,7 +23,7 @@ export function guardrailsDelete(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.DeleteGuardrailRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_DeleteGuardrailRequest$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, models.DeleteGuardrailResponse$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$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_DeleteGuardrailResponse$inboundSchema), M.jsonErr(401, errors_UnauthorizedResponseError$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/guardrailsGet.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 { UnauthorizedResponseError$inboundSchema as errors_UnauthorizedResponseError$inboundSchema } from "../models/errors/unauthorizedresponseerror.js";
+import { GetGuardrailResponse$inboundSchema as models_GetGuardrailResponse$inboundSchema } from "../models/getguardrailresponse.js";
+import { GetGuardrailRequest$outboundSchema as operations_GetGuardrailRequest$outboundSchema } from "../models/operations/getguardrail.js";
 import { APIPromise } from "../types/async.js";
 /**
  * Get a guardrail
@@ -23,7 +23,7 @@ export function guardrailsGet(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.GetGuardrailRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_GetGuardrailRequest$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, models.GetGuardrailResponse$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$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_GetGuardrailResponse$inboundSchema), M.jsonErr(401, errors_UnauthorizedResponseError$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/guardrailsList.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 { InternalServerResponseError$inboundSchema as errors_InternalServerResponseError$inboundSchema } from "../models/errors/internalserverresponseerror.js"; import { UnauthorizedResponseError$inboundSchema as errors_UnauthorizedResponseError$inboundSchema } from "../models/errors/unauthorizedresponseerror.js";
+import { ListGuardrailsRequest$outboundSchema as operations_ListGuardrailsRequest$outboundSchema, ListGuardrailsResponse$inboundSchema as operations_ListGuardrailsResponse$inboundSchema } from "../models/operations/listguardrails.js";
 import { APIPromise } from "../types/async.js";
 import { createPageIterator, haltIterator, } from "../types/operations.js";
 /**
@@ -23,7 +23,7 @@ export function guardrailsList(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.ListGuardrailsRequest$outboundSchema.optional().parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_ListGuardrailsRequest$outboundSchema.optional().parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [haltIterator(parsed), { status: "invalid" }];
     }
@@ -94,9 +94,9 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result, raw] = await M.match(M.json(200, operations.ListGuardrailsResponse$inboundSchema, {
+    const [result, raw] = await M.match(M.json(200, operations_ListGuardrailsResponse$inboundSchema, {
         key: "Result",
-    }), 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 });
+    }), 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 [haltIterator(result), {
                 status: "complete",

package/esm/funcs/guardrailsListGuardrailKeyAssignments.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 { 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 { ListGuardrailKeyAssignmentsRequest$outboundSchema as operations_ListGuardrailKeyAssignmentsRequest$outboundSchema, ListGuardrailKeyAssignmentsResponse$inboundSchema as operations_ListGuardrailKeyAssignmentsResponse$inboundSchema } from "../models/operations/listguardrailkeyassignments.js";
 import { APIPromise } from "../types/async.js";
 import { createPageIterator, haltIterator, } from "../types/operations.js";
 /**
@@ -23,7 +23,7 @@ export function guardrailsListGuardrailKeyAssignments(client, request, options)
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.ListGuardrailKeyAssignmentsRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_ListGuardrailKeyAssignmentsRequest$outboundSchema.parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [haltIterator(parsed), { status: "invalid" }];
     }
@@ -99,9 +99,9 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result, raw] = await M.match(M.json(200, operations.ListGuardrailKeyAssignmentsResponse$inboundSchema, {
+    const [result, raw] = await M.match(M.json(200, operations_ListGuardrailKeyAssignmentsResponse$inboundSchema, {
         key: "Result",
-    }), M.jsonErr(401, errors.UnauthorizedResponseError$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(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/guardrailsListGuardrailMemberAssignments.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 { 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 { ListGuardrailMemberAssignmentsRequest$outboundSchema as operations_ListGuardrailMemberAssignmentsRequest$outboundSchema, ListGuardrailMemberAssignmentsResponse$inboundSchema as operations_ListGuardrailMemberAssignmentsResponse$inboundSchema } from "../models/operations/listguardrailmemberassignments.js";
 import { APIPromise } from "../types/async.js";
 import { createPageIterator, haltIterator, } from "../types/operations.js";
 /**
@@ -23,7 +23,7 @@ export function guardrailsListGuardrailMemberAssignments(client, request, option
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.ListGuardrailMemberAssignmentsRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_ListGuardrailMemberAssignmentsRequest$outboundSchema.parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [haltIterator(parsed), { status: "invalid" }];
     }
@@ -99,7 +99,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result, raw] = await M.match(M.json(200, operations.ListGuardrailMemberAssignmentsResponse$inboundSchema, { key: "Result" }), M.jsonErr(401, errors.UnauthorizedResponseError$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, raw] = await M.match(M.json(200, operations_ListGuardrailMemberAssignmentsResponse$inboundSchema, { key: "Result" }), M.jsonErr(401, errors_UnauthorizedResponseError$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/guardrailsListKeyAssignments.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 { InternalServerResponseError$inboundSchema as errors_InternalServerResponseError$inboundSchema } from "../models/errors/internalserverresponseerror.js"; import { UnauthorizedResponseError$inboundSchema as errors_UnauthorizedResponseError$inboundSchema } from "../models/errors/unauthorizedresponseerror.js";
+import { ListKeyAssignmentsRequest$outboundSchema as operations_ListKeyAssignmentsRequest$outboundSchema, ListKeyAssignmentsResponse$inboundSchema as operations_ListKeyAssignmentsResponse$inboundSchema } from "../models/operations/listkeyassignments.js";
 import { APIPromise } from "../types/async.js";
 import { createPageIterator, haltIterator, } from "../types/operations.js";
 /**
@@ -23,7 +23,7 @@ export function guardrailsListKeyAssignments(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.ListKeyAssignmentsRequest$outboundSchema.optional().parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_ListKeyAssignmentsRequest$outboundSchema.optional().parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [haltIterator(parsed), { status: "invalid" }];
     }
@@ -93,9 +93,9 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result, raw] = await M.match(M.json(200, operations.ListKeyAssignmentsResponse$inboundSchema, {
+    const [result, raw] = await M.match(M.json(200, operations_ListKeyAssignmentsResponse$inboundSchema, {
         key: "Result",
-    }), M.jsonErr(401, errors.UnauthorizedResponseError$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(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/guardrailsListMemberAssignments.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 { InternalServerResponseError$inboundSchema as errors_InternalServerResponseError$inboundSchema } from "../models/errors/internalserverresponseerror.js"; import { UnauthorizedResponseError$inboundSchema as errors_UnauthorizedResponseError$inboundSchema } from "../models/errors/unauthorizedresponseerror.js";
+import { ListMemberAssignmentsRequest$outboundSchema as operations_ListMemberAssignmentsRequest$outboundSchema, ListMemberAssignmentsResponse$inboundSchema as operations_ListMemberAssignmentsResponse$inboundSchema } from "../models/operations/listmemberassignments.js";
 import { APIPromise } from "../types/async.js";
 import { createPageIterator, haltIterator, } from "../types/operations.js";
 /**
@@ -23,7 +23,7 @@ export function guardrailsListMemberAssignments(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.ListMemberAssignmentsRequest$outboundSchema.optional().parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_ListMemberAssignmentsRequest$outboundSchema.optional().parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [haltIterator(parsed), { status: "invalid" }];
     }
@@ -93,9 +93,9 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result, raw] = await M.match(M.json(200, operations.ListMemberAssignmentsResponse$inboundSchema, {
+    const [result, raw] = await M.match(M.json(200, operations_ListMemberAssignmentsResponse$inboundSchema, {
         key: "Result",
-    }), M.jsonErr(401, errors.UnauthorizedResponseError$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(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/guardrailsUpdate.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 { 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 { NotFoundResponseError$inboundSchema as errors_NotFoundResponseError$inboundSchema } from "../models/errors/notfoundresponseerror.js"; import { UnauthorizedResponseError$inboundSchema as errors_UnauthorizedResponseError$inboundSchema } from "../models/errors/unauthorizedresponseerror.js";
+import { UpdateGuardrailResponse$inboundSchema as models_UpdateGuardrailResponse$inboundSchema } from "../models/updateguardrailresponse.js";
+import { UpdateGuardrailRequest$outboundSchema as operations_UpdateGuardrailRequest$outboundSchema } from "../models/operations/updateguardrail.js";
 import { APIPromise } from "../types/async.js";
 /**
  * Update a guardrail
@@ -23,7 +23,7 @@ export function guardrailsUpdate(client, request, options) {
     return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
-    const parsed = safeParse(request, (value) => operations.UpdateGuardrailRequest$outboundSchema.parse(value), "Input validation failed");
+    const parsed = safeParse(request, (value) => operations_UpdateGuardrailRequest$outboundSchema.parse(value), "Input validation failed");
     if (!parsed.ok) {
         return [parsed, { status: "invalid" }];
     }
@@ -97,7 +97,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, models.UpdateGuardrailResponse$inboundSchema), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(403, errors.ForbiddenResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$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, models_UpdateGuardrailResponse$inboundSchema), M.jsonErr(400, errors_BadRequestResponseError$inboundSchema), M.jsonErr(401, errors_UnauthorizedResponseError$inboundSchema), M.jsonErr(403, errors_ForbiddenResponseError$inboundSchema), M.jsonErr(404, errors_NotFoundResponseError$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 }];
     }