@orq-ai/node 4.13.0-rc.4 → 4.13.0-rc.6

package/src/models/components/mcpoauthconfig.ts

@@ -0,0 +1,72 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type McpOAuthConfig = {
+  clientId?: string | undefined;
+  tokenUrl?: string | undefined;
+  scopes?: Array<string> | undefined;
+  maskedValue?: string | undefined;
+};
+
+/** @internal */
+export const McpOAuthConfig$inboundSchema: z.ZodType<
+  McpOAuthConfig,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  client_id: z.string().optional(),
+  token_url: z.string().optional(),
+  scopes: z.array(z.string()).optional(),
+  masked_value: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "client_id": "clientId",
+    "token_url": "tokenUrl",
+    "masked_value": "maskedValue",
+  });
+});
+/** @internal */
+export type McpOAuthConfig$Outbound = {
+  client_id?: string | undefined;
+  token_url?: string | undefined;
+  scopes?: Array<string> | undefined;
+  masked_value?: string | undefined;
+};
+
+/** @internal */
+export const McpOAuthConfig$outboundSchema: z.ZodType<
+  McpOAuthConfig$Outbound,
+  z.ZodTypeDef,
+  McpOAuthConfig
+> = z.object({
+  clientId: z.string().optional(),
+  tokenUrl: z.string().optional(),
+  scopes: z.array(z.string()).optional(),
+  maskedValue: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    clientId: "client_id",
+    tokenUrl: "token_url",
+    maskedValue: "masked_value",
+  });
+});
+
+export function mcpOAuthConfigToJSON(mcpOAuthConfig: McpOAuthConfig): string {
+  return JSON.stringify(McpOAuthConfig$outboundSchema.parse(mcpOAuthConfig));
+}
+export function mcpOAuthConfigFromJSON(
+  jsonString: string,
+): SafeParseResult<McpOAuthConfig, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => McpOAuthConfig$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'McpOAuthConfig' from JSON`,
+  );
+}

package/src/models/components/mcpruntimelimits.ts

@@ -0,0 +1,96 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type McpRuntimeLimits = {
+  requestTimeoutMs?: number | undefined;
+  toolTimeoutMs?: number | undefined;
+  maxRequestBytes?: number | undefined;
+  maxResponseBytes?: number | undefined;
+  maxToolsPerGateway?: number | undefined;
+  perTokenRequestsPerMinute?: number | undefined;
+  perGatewayRequestsPerMinute?: number | undefined;
+};
+
+/** @internal */
+export const McpRuntimeLimits$inboundSchema: z.ZodType<
+  McpRuntimeLimits,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  request_timeout_ms: z.number().int().optional(),
+  tool_timeout_ms: z.number().int().optional(),
+  max_request_bytes: z.number().int().optional(),
+  max_response_bytes: z.number().int().optional(),
+  max_tools_per_gateway: z.number().int().optional(),
+  per_token_requests_per_minute: z.number().int().optional(),
+  per_gateway_requests_per_minute: z.number().int().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "request_timeout_ms": "requestTimeoutMs",
+    "tool_timeout_ms": "toolTimeoutMs",
+    "max_request_bytes": "maxRequestBytes",
+    "max_response_bytes": "maxResponseBytes",
+    "max_tools_per_gateway": "maxToolsPerGateway",
+    "per_token_requests_per_minute": "perTokenRequestsPerMinute",
+    "per_gateway_requests_per_minute": "perGatewayRequestsPerMinute",
+  });
+});
+/** @internal */
+export type McpRuntimeLimits$Outbound = {
+  request_timeout_ms?: number | undefined;
+  tool_timeout_ms?: number | undefined;
+  max_request_bytes?: number | undefined;
+  max_response_bytes?: number | undefined;
+  max_tools_per_gateway?: number | undefined;
+  per_token_requests_per_minute?: number | undefined;
+  per_gateway_requests_per_minute?: number | undefined;
+};
+
+/** @internal */
+export const McpRuntimeLimits$outboundSchema: z.ZodType<
+  McpRuntimeLimits$Outbound,
+  z.ZodTypeDef,
+  McpRuntimeLimits
+> = z.object({
+  requestTimeoutMs: z.number().int().optional(),
+  toolTimeoutMs: z.number().int().optional(),
+  maxRequestBytes: z.number().int().optional(),
+  maxResponseBytes: z.number().int().optional(),
+  maxToolsPerGateway: z.number().int().optional(),
+  perTokenRequestsPerMinute: z.number().int().optional(),
+  perGatewayRequestsPerMinute: z.number().int().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    requestTimeoutMs: "request_timeout_ms",
+    toolTimeoutMs: "tool_timeout_ms",
+    maxRequestBytes: "max_request_bytes",
+    maxResponseBytes: "max_response_bytes",
+    maxToolsPerGateway: "max_tools_per_gateway",
+    perTokenRequestsPerMinute: "per_token_requests_per_minute",
+    perGatewayRequestsPerMinute: "per_gateway_requests_per_minute",
+  });
+});
+
+export function mcpRuntimeLimitsToJSON(
+  mcpRuntimeLimits: McpRuntimeLimits,
+): string {
+  return JSON.stringify(
+    McpRuntimeLimits$outboundSchema.parse(mcpRuntimeLimits),
+  );
+}
+export function mcpRuntimeLimitsFromJSON(
+  jsonString: string,
+): SafeParseResult<McpRuntimeLimits, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => McpRuntimeLimits$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'McpRuntimeLimits' from JSON`,
+  );
+}

package/src/models/components/mcpserver.ts

@@ -0,0 +1,81 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import { McpAuthConfig, McpAuthConfig$inboundSchema } from "./mcpauthconfig.js";
+import { McpConnection, McpConnection$inboundSchema } from "./mcpconnection.js";
+import {
+  McpServerSharing,
+  McpServerSharing$inboundSchema,
+} from "./mcpserversharing.js";
+import {
+  McpServerStatus,
+  McpServerStatus$inboundSchema,
+} from "./mcpserverstatus.js";
+import { McpSyncState, McpSyncState$inboundSchema } from "./mcpsyncstate.js";
+import { McpTool, McpTool$inboundSchema } from "./mcptool.js";
+import {
+  McpToolExposure,
+  McpToolExposure$inboundSchema,
+} from "./mcptoolexposure.js";
+
+export type McpServer = {
+  id?: string | undefined;
+  key?: string | undefined;
+  displayName?: string | undefined;
+  description?: string | undefined;
+  projectId?: string | undefined;
+  connection?: McpConnection | undefined;
+  auth?: McpAuthConfig | undefined;
+  defaultToolExposure?: McpToolExposure | undefined;
+  status?: McpServerStatus | undefined;
+  syncState?: McpSyncState | undefined;
+  tools?: Array<McpTool> | undefined;
+  created?: string | undefined;
+  updated?: string | undefined;
+  sharing?: McpServerSharing | undefined;
+};
+
+/** @internal */
+export const McpServer$inboundSchema: z.ZodType<
+  McpServer,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string().optional(),
+  key: z.string().optional(),
+  display_name: z.string().optional(),
+  description: z.string().optional(),
+  project_id: z.string().optional(),
+  connection: McpConnection$inboundSchema.optional(),
+  auth: McpAuthConfig$inboundSchema.optional(),
+  default_tool_exposure: McpToolExposure$inboundSchema.optional(),
+  status: McpServerStatus$inboundSchema.optional(),
+  sync_state: McpSyncState$inboundSchema.optional(),
+  tools: z.array(McpTool$inboundSchema).optional(),
+  created: z.string().optional(),
+  updated: z.string().optional(),
+  sharing: McpServerSharing$inboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "display_name": "displayName",
+    "project_id": "projectId",
+    "default_tool_exposure": "defaultToolExposure",
+    "sync_state": "syncState",
+  });
+});
+
+export function mcpServerFromJSON(
+  jsonString: string,
+): SafeParseResult<McpServer, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => McpServer$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'McpServer' from JSON`,
+  );
+}

package/src/models/components/mcpserversharing.ts

@@ -0,0 +1,69 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  McpServerSharingScope,
+  McpServerSharingScope$inboundSchema,
+  McpServerSharingScope$outboundSchema,
+} from "./mcpserversharingscope.js";
+
+export type McpServerSharing = {
+  scope?: McpServerSharingScope | undefined;
+  projectIds?: Array<string> | undefined;
+};
+
+/** @internal */
+export const McpServerSharing$inboundSchema: z.ZodType<
+  McpServerSharing,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  scope: McpServerSharingScope$inboundSchema.optional(),
+  project_ids: z.array(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "project_ids": "projectIds",
+  });
+});
+/** @internal */
+export type McpServerSharing$Outbound = {
+  scope?: string | undefined;
+  project_ids?: Array<string> | undefined;
+};
+
+/** @internal */
+export const McpServerSharing$outboundSchema: z.ZodType<
+  McpServerSharing$Outbound,
+  z.ZodTypeDef,
+  McpServerSharing
+> = z.object({
+  scope: McpServerSharingScope$outboundSchema.optional(),
+  projectIds: z.array(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    projectIds: "project_ids",
+  });
+});
+
+export function mcpServerSharingToJSON(
+  mcpServerSharing: McpServerSharing,
+): string {
+  return JSON.stringify(
+    McpServerSharing$outboundSchema.parse(mcpServerSharing),
+  );
+}
+export function mcpServerSharingFromJSON(
+  jsonString: string,
+): SafeParseResult<McpServerSharing, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => McpServerSharing$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'McpServerSharing' from JSON`,
+  );
+}

package/src/models/components/mcpserversharingscope.ts

@@ -0,0 +1,24 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+
+export const McpServerSharingScope = {
+  McpServerSharingScopeUnspecified: "MCP_SERVER_SHARING_SCOPE_UNSPECIFIED",
+  McpServerSharingScopeProject: "MCP_SERVER_SHARING_SCOPE_PROJECT",
+  McpServerSharingScopeWorkspace: "MCP_SERVER_SHARING_SCOPE_WORKSPACE",
+  McpServerSharingScopeSelectedProjects:
+    "MCP_SERVER_SHARING_SCOPE_SELECTED_PROJECTS",
+} as const;
+export type McpServerSharingScope = ClosedEnum<typeof McpServerSharingScope>;
+
+/** @internal */
+export const McpServerSharingScope$inboundSchema: z.ZodNativeEnum<
+  typeof McpServerSharingScope
+> = z.nativeEnum(McpServerSharingScope);
+/** @internal */
+export const McpServerSharingScope$outboundSchema: z.ZodNativeEnum<
+  typeof McpServerSharingScope
+> = McpServerSharingScope$inboundSchema;

package/src/models/components/mcpserverstatus.ts

@@ -0,0 +1,23 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+
+export const McpServerStatus = {
+  McpServerStatusUnspecified: "MCP_SERVER_STATUS_UNSPECIFIED",
+  McpServerStatusActive: "MCP_SERVER_STATUS_ACTIVE",
+  McpServerStatusDisabled: "MCP_SERVER_STATUS_DISABLED",
+  McpServerStatusError: "MCP_SERVER_STATUS_ERROR",
+} as const;
+export type McpServerStatus = ClosedEnum<typeof McpServerStatus>;
+
+/** @internal */
+export const McpServerStatus$inboundSchema: z.ZodNativeEnum<
+  typeof McpServerStatus
+> = z.nativeEnum(McpServerStatus);
+/** @internal */
+export const McpServerStatus$outboundSchema: z.ZodNativeEnum<
+  typeof McpServerStatus
+> = McpServerStatus$inboundSchema;

package/src/models/components/mcpsession.ts

@@ -0,0 +1,54 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  McpSessionStatus,
+  McpSessionStatus$inboundSchema,
+} from "./mcpsessionstatus.js";
+
+export type McpSession = {
+  id?: string | undefined;
+  mcpGatewayId?: string | undefined;
+  mcpServerId?: string | undefined;
+  accountId?: string | undefined;
+  status?: McpSessionStatus | undefined;
+  created?: string | undefined;
+  updated?: string | undefined;
+};
+
+/** @internal */
+export const McpSession$inboundSchema: z.ZodType<
+  McpSession,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string().optional(),
+  mcp_gateway_id: z.string().optional(),
+  mcp_server_id: z.string().optional(),
+  account_id: z.string().optional(),
+  status: McpSessionStatus$inboundSchema.optional(),
+  created: z.string().optional(),
+  updated: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "mcp_gateway_id": "mcpGatewayId",
+    "mcp_server_id": "mcpServerId",
+    "account_id": "accountId",
+  });
+});
+
+export function mcpSessionFromJSON(
+  jsonString: string,
+): SafeParseResult<McpSession, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => McpSession$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'McpSession' from JSON`,
+  );
+}

package/src/models/components/mcpsessionstatus.ts

@@ -0,0 +1,22 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+
+export const McpSessionStatus = {
+  McpSessionStatusUnspecified: "MCP_SESSION_STATUS_UNSPECIFIED",
+  McpSessionStatusActive: "MCP_SESSION_STATUS_ACTIVE",
+  McpSessionStatusRevoked: "MCP_SESSION_STATUS_REVOKED",
+} as const;
+export type McpSessionStatus = ClosedEnum<typeof McpSessionStatus>;
+
+/** @internal */
+export const McpSessionStatus$inboundSchema: z.ZodNativeEnum<
+  typeof McpSessionStatus
+> = z.nativeEnum(McpSessionStatus);
+/** @internal */
+export const McpSessionStatus$outboundSchema: z.ZodNativeEnum<
+  typeof McpSessionStatus
+> = McpSessionStatus$inboundSchema;

package/src/models/components/mcpsyncstate.ts

@@ -0,0 +1,50 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import { SyncStatus, SyncStatus$inboundSchema } from "./syncstatus.js";
+
+export type McpSyncState = {
+  status?: SyncStatus | undefined;
+  toolsTotal?: number | undefined;
+  toolsAdded?: number | undefined;
+  toolsRemoved?: number | undefined;
+  lastSyncedAt?: string | undefined;
+  errors?: Array<string> | undefined;
+};
+
+/** @internal */
+export const McpSyncState$inboundSchema: z.ZodType<
+  McpSyncState,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  status: SyncStatus$inboundSchema.optional(),
+  tools_total: z.number().int().optional(),
+  tools_added: z.number().int().optional(),
+  tools_removed: z.number().int().optional(),
+  last_synced_at: z.string().optional(),
+  errors: z.array(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "tools_total": "toolsTotal",
+    "tools_added": "toolsAdded",
+    "tools_removed": "toolsRemoved",
+    "last_synced_at": "lastSyncedAt",
+  });
+});
+
+export function mcpSyncStateFromJSON(
+  jsonString: string,
+): SafeParseResult<McpSyncState, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => McpSyncState$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'McpSyncState' from JSON`,
+  );
+}

package/src/models/components/mcptestresult.ts

@@ -0,0 +1,46 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import { McpTool, McpTool$inboundSchema } from "./mcptool.js";
+
+export type McpTestResult = {
+  ok?: boolean | undefined;
+  tools?: Array<McpTool> | undefined;
+  latencyMs?: number | undefined;
+  errorMessage?: string | undefined;
+  errors?: Array<string> | undefined;
+};
+
+/** @internal */
+export const McpTestResult$inboundSchema: z.ZodType<
+  McpTestResult,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  ok: z.boolean().optional(),
+  tools: z.array(McpTool$inboundSchema).optional(),
+  latency_ms: z.number().int().optional(),
+  error_message: z.string().optional(),
+  errors: z.array(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "latency_ms": "latencyMs",
+    "error_message": "errorMessage",
+  });
+});
+
+export function mcpTestResultFromJSON(
+  jsonString: string,
+): SafeParseResult<McpTestResult, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => McpTestResult$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'McpTestResult' from JSON`,
+  );
+}

package/src/models/components/mcptool.ts

@@ -0,0 +1,61 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type McpToolInputSchema = {};
+
+export type McpTool = {
+  name?: string | undefined;
+  description?: string | undefined;
+  inputSchema?: McpToolInputSchema | undefined;
+  readOnly?: boolean | undefined;
+  status?: string | undefined;
+};
+
+/** @internal */
+export const McpToolInputSchema$inboundSchema: z.ZodType<
+  McpToolInputSchema,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+export function mcpToolInputSchemaFromJSON(
+  jsonString: string,
+): SafeParseResult<McpToolInputSchema, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => McpToolInputSchema$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'McpToolInputSchema' from JSON`,
+  );
+}
+
+/** @internal */
+export const McpTool$inboundSchema: z.ZodType<McpTool, z.ZodTypeDef, unknown> =
+  z.object({
+    name: z.string().optional(),
+    description: z.string().optional(),
+    input_schema: z.lazy(() => McpToolInputSchema$inboundSchema).optional(),
+    read_only: z.boolean().optional(),
+    status: z.string().optional(),
+  }).transform((v) => {
+    return remap$(v, {
+      "input_schema": "inputSchema",
+      "read_only": "readOnly",
+    });
+  });
+
+export function mcpToolFromJSON(
+  jsonString: string,
+): SafeParseResult<McpTool, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => McpTool$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'McpTool' from JSON`,
+  );
+}

package/src/models/components/mcptoolexposure.ts

@@ -0,0 +1,73 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  McpToolExposureMode,
+  McpToolExposureMode$inboundSchema,
+  McpToolExposureMode$outboundSchema,
+} from "./mcptoolexposuremode.js";
+
+export type McpToolExposure = {
+  mode?: McpToolExposureMode | undefined;
+  readOnly?: boolean | undefined;
+  toolNames?: Array<string> | undefined;
+};
+
+/** @internal */
+export const McpToolExposure$inboundSchema: z.ZodType<
+  McpToolExposure,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  mode: McpToolExposureMode$inboundSchema.optional(),
+  read_only: z.boolean().optional(),
+  tool_names: z.array(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "read_only": "readOnly",
+    "tool_names": "toolNames",
+  });
+});
+/** @internal */
+export type McpToolExposure$Outbound = {
+  mode?: string | undefined;
+  read_only?: boolean | undefined;
+  tool_names?: Array<string> | undefined;
+};
+
+/** @internal */
+export const McpToolExposure$outboundSchema: z.ZodType<
+  McpToolExposure$Outbound,
+  z.ZodTypeDef,
+  McpToolExposure
+> = z.object({
+  mode: McpToolExposureMode$outboundSchema.optional(),
+  readOnly: z.boolean().optional(),
+  toolNames: z.array(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    readOnly: "read_only",
+    toolNames: "tool_names",
+  });
+});
+
+export function mcpToolExposureToJSON(
+  mcpToolExposure: McpToolExposure,
+): string {
+  return JSON.stringify(McpToolExposure$outboundSchema.parse(mcpToolExposure));
+}
+export function mcpToolExposureFromJSON(
+  jsonString: string,
+): SafeParseResult<McpToolExposure, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => McpToolExposure$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'McpToolExposure' from JSON`,
+  );
+}