@orq-ai/node 4.12.4 → 4.12.6

package/packages/orq-rc/src/models/components/mcpauthconfig.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 {
+  McpAuthType,
+  McpAuthType$inboundSchema,
+  McpAuthType$outboundSchema,
+} from "./mcpauthtype.js";
+import {
+  McpHeaderSecret,
+  McpHeaderSecret$inboundSchema,
+  McpHeaderSecret$Outbound,
+  McpHeaderSecret$outboundSchema,
+} from "./mcpheadersecret.js";
+import {
+  McpOAuthConfig,
+  McpOAuthConfig$inboundSchema,
+  McpOAuthConfig$Outbound,
+  McpOAuthConfig$outboundSchema,
+} from "./mcpoauthconfig.js";
+
+export type McpAuthConfig = {
+  type?: McpAuthType | undefined;
+  staticHeaders?: Array<McpHeaderSecret> | undefined;
+  oauth?: McpOAuthConfig | undefined;
+};
+
+/** @internal */
+export const McpAuthConfig$inboundSchema: z.ZodType<
+  McpAuthConfig,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: McpAuthType$inboundSchema.optional(),
+  static_headers: z.array(McpHeaderSecret$inboundSchema).optional(),
+  oauth: McpOAuthConfig$inboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "static_headers": "staticHeaders",
+  });
+});
+/** @internal */
+export type McpAuthConfig$Outbound = {
+  type?: string | undefined;
+  static_headers?: Array<McpHeaderSecret$Outbound> | undefined;
+  oauth?: McpOAuthConfig$Outbound | undefined;
+};
+
+/** @internal */
+export const McpAuthConfig$outboundSchema: z.ZodType<
+  McpAuthConfig$Outbound,
+  z.ZodTypeDef,
+  McpAuthConfig
+> = z.object({
+  type: McpAuthType$outboundSchema.optional(),
+  staticHeaders: z.array(McpHeaderSecret$outboundSchema).optional(),
+  oauth: McpOAuthConfig$outboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    staticHeaders: "static_headers",
+  });
+});
+
+export function mcpAuthConfigToJSON(mcpAuthConfig: McpAuthConfig): string {
+  return JSON.stringify(McpAuthConfig$outboundSchema.parse(mcpAuthConfig));
+}
+export function mcpAuthConfigFromJSON(
+  jsonString: string,
+): SafeParseResult<McpAuthConfig, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => McpAuthConfig$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'McpAuthConfig' from JSON`,
+  );
+}

package/packages/orq-rc/src/models/components/mcpauthtype.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 McpAuthType = {
+  McpAuthTypeUnspecified: "MCP_AUTH_TYPE_UNSPECIFIED",
+  McpAuthTypeNone: "MCP_AUTH_TYPE_NONE",
+  McpAuthTypeStaticHeaders: "MCP_AUTH_TYPE_STATIC_HEADERS",
+  McpAuthTypeOauthClientCredentials: "MCP_AUTH_TYPE_OAUTH_CLIENT_CREDENTIALS",
+  McpAuthTypePerUserOauth: "MCP_AUTH_TYPE_PER_USER_OAUTH",
+} as const;
+export type McpAuthType = ClosedEnum<typeof McpAuthType>;
+
+/** @internal */
+export const McpAuthType$inboundSchema: z.ZodNativeEnum<typeof McpAuthType> = z
+  .nativeEnum(McpAuthType);
+/** @internal */
+export const McpAuthType$outboundSchema: z.ZodNativeEnum<typeof McpAuthType> =
+  McpAuthType$inboundSchema;

package/packages/orq-rc/src/models/components/mcpconnection.ts

@@ -0,0 +1,56 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  McpConnectionType,
+  McpConnectionType$inboundSchema,
+  McpConnectionType$outboundSchema,
+} from "./mcpconnectiontype.js";
+
+export type McpConnection = {
+  type?: McpConnectionType | undefined;
+  url?: string | undefined;
+};
+
+/** @internal */
+export const McpConnection$inboundSchema: z.ZodType<
+  McpConnection,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: McpConnectionType$inboundSchema.optional(),
+  url: z.string().optional(),
+});
+/** @internal */
+export type McpConnection$Outbound = {
+  type?: string | undefined;
+  url?: string | undefined;
+};
+
+/** @internal */
+export const McpConnection$outboundSchema: z.ZodType<
+  McpConnection$Outbound,
+  z.ZodTypeDef,
+  McpConnection
+> = z.object({
+  type: McpConnectionType$outboundSchema.optional(),
+  url: z.string().optional(),
+});
+
+export function mcpConnectionToJSON(mcpConnection: McpConnection): string {
+  return JSON.stringify(McpConnection$outboundSchema.parse(mcpConnection));
+}
+export function mcpConnectionFromJSON(
+  jsonString: string,
+): SafeParseResult<McpConnection, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => McpConnection$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'McpConnection' from JSON`,
+  );
+}

package/packages/orq-rc/src/models/components/mcpconnectiontype.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 McpConnectionType = {
+  McpConnectionTypeUnspecified: "MCP_CONNECTION_TYPE_UNSPECIFIED",
+  McpConnectionTypeHttp: "MCP_CONNECTION_TYPE_HTTP",
+  McpConnectionTypeSse: "MCP_CONNECTION_TYPE_SSE",
+  McpConnectionTypeStdio: "MCP_CONNECTION_TYPE_STDIO",
+} as const;
+export type McpConnectionType = ClosedEnum<typeof McpConnectionType>;
+
+/** @internal */
+export const McpConnectionType$inboundSchema: z.ZodNativeEnum<
+  typeof McpConnectionType
+> = z.nativeEnum(McpConnectionType);
+/** @internal */
+export const McpConnectionType$outboundSchema: z.ZodNativeEnum<
+  typeof McpConnectionType
+> = McpConnectionType$inboundSchema;

package/packages/orq-rc/src/models/components/mcpegresspolicy.ts

@@ -0,0 +1,76 @@
+/*
+ * 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 McpEgressPolicy = {
+  allowPrivateNetwork?: boolean | undefined;
+  allowedDomains?: Array<string> | undefined;
+  blockedDomains?: Array<string> | undefined;
+  allowPublicInternet?: boolean | undefined;
+};
+
+/** @internal */
+export const McpEgressPolicy$inboundSchema: z.ZodType<
+  McpEgressPolicy,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  allow_private_network: z.boolean().optional(),
+  allowed_domains: z.array(z.string()).optional(),
+  blocked_domains: z.array(z.string()).optional(),
+  allow_public_internet: z.boolean().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "allow_private_network": "allowPrivateNetwork",
+    "allowed_domains": "allowedDomains",
+    "blocked_domains": "blockedDomains",
+    "allow_public_internet": "allowPublicInternet",
+  });
+});
+/** @internal */
+export type McpEgressPolicy$Outbound = {
+  allow_private_network?: boolean | undefined;
+  allowed_domains?: Array<string> | undefined;
+  blocked_domains?: Array<string> | undefined;
+  allow_public_internet?: boolean | undefined;
+};
+
+/** @internal */
+export const McpEgressPolicy$outboundSchema: z.ZodType<
+  McpEgressPolicy$Outbound,
+  z.ZodTypeDef,
+  McpEgressPolicy
+> = z.object({
+  allowPrivateNetwork: z.boolean().optional(),
+  allowedDomains: z.array(z.string()).optional(),
+  blockedDomains: z.array(z.string()).optional(),
+  allowPublicInternet: z.boolean().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    allowPrivateNetwork: "allow_private_network",
+    allowedDomains: "allowed_domains",
+    blockedDomains: "blocked_domains",
+    allowPublicInternet: "allow_public_internet",
+  });
+});
+
+export function mcpEgressPolicyToJSON(
+  mcpEgressPolicy: McpEgressPolicy,
+): string {
+  return JSON.stringify(McpEgressPolicy$outboundSchema.parse(mcpEgressPolicy));
+}
+export function mcpEgressPolicyFromJSON(
+  jsonString: string,
+): SafeParseResult<McpEgressPolicy, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => McpEgressPolicy$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'McpEgressPolicy' from JSON`,
+  );
+}

package/packages/orq-rc/src/models/components/mcpgateway.ts

@@ -0,0 +1,86 @@
+/*
+ * 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 {
+  McpEgressPolicy,
+  McpEgressPolicy$inboundSchema,
+} from "./mcpegresspolicy.js";
+import {
+  McpGatewayServerLink,
+  McpGatewayServerLink$inboundSchema,
+} from "./mcpgatewayserverlink.js";
+import {
+  McpGatewayStatus,
+  McpGatewayStatus$inboundSchema,
+} from "./mcpgatewaystatus.js";
+import {
+  McpRuntimeLimits,
+  McpRuntimeLimits$inboundSchema,
+} from "./mcpruntimelimits.js";
+import { McpToolNaming, McpToolNaming$inboundSchema } from "./mcptoolnaming.js";
+
+export type McpGateway = {
+  id?: string | undefined;
+  key?: string | undefined;
+  displayName?: string | undefined;
+  description?: string | undefined;
+  projectId?: string | undefined;
+  serverLinks?: Array<McpGatewayServerLink> | undefined;
+  toolNaming?: McpToolNaming | undefined;
+  runtimeLimits?: McpRuntimeLimits | undefined;
+  egressPolicy?: McpEgressPolicy | undefined;
+  status?: McpGatewayStatus | undefined;
+  publicUrl?: string | undefined;
+  created?: string | undefined;
+  updated?: string | undefined;
+  exposedToolsCount?: number | undefined;
+};
+
+/** @internal */
+export const McpGateway$inboundSchema: z.ZodType<
+  McpGateway,
+  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(),
+  server_links: z.array(McpGatewayServerLink$inboundSchema).optional(),
+  tool_naming: McpToolNaming$inboundSchema.optional(),
+  runtime_limits: McpRuntimeLimits$inboundSchema.optional(),
+  egress_policy: McpEgressPolicy$inboundSchema.optional(),
+  status: McpGatewayStatus$inboundSchema.optional(),
+  public_url: z.string().optional(),
+  created: z.string().optional(),
+  updated: z.string().optional(),
+  exposed_tools_count: z.number().int().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "display_name": "displayName",
+    "project_id": "projectId",
+    "server_links": "serverLinks",
+    "tool_naming": "toolNaming",
+    "runtime_limits": "runtimeLimits",
+    "egress_policy": "egressPolicy",
+    "public_url": "publicUrl",
+    "exposed_tools_count": "exposedToolsCount",
+  });
+});
+
+export function mcpGatewayFromJSON(
+  jsonString: string,
+): SafeParseResult<McpGateway, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => McpGateway$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'McpGateway' from JSON`,
+  );
+}

package/packages/orq-rc/src/models/components/mcpgatewaycall.ts

@@ -0,0 +1,70 @@
+/*
+ * 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 {
+  McpGatewayCallStatus,
+  McpGatewayCallStatus$inboundSchema,
+} from "./mcpgatewaycallstatus.js";
+
+export type McpGatewayCall = {
+  id?: string | undefined;
+  mcpGatewayId?: string | undefined;
+  mcpServerId?: string | undefined;
+  exposedToolName?: string | undefined;
+  upstreamToolName?: string | undefined;
+  status?: McpGatewayCallStatus | undefined;
+  latencyMs?: number | undefined;
+  errorCode?: string | undefined;
+  errorMessage?: string | undefined;
+  accountId?: string | undefined;
+  tokenId?: string | undefined;
+  timestamp?: string | undefined;
+};
+
+/** @internal */
+export const McpGatewayCall$inboundSchema: z.ZodType<
+  McpGatewayCall,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string().optional(),
+  mcp_gateway_id: z.string().optional(),
+  mcp_server_id: z.string().optional(),
+  exposed_tool_name: z.string().optional(),
+  upstream_tool_name: z.string().optional(),
+  status: McpGatewayCallStatus$inboundSchema.optional(),
+  latency_ms: z.number().int().optional(),
+  error_code: z.string().optional(),
+  error_message: z.string().optional(),
+  account_id: z.string().optional(),
+  token_id: z.string().optional(),
+  timestamp: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "mcp_gateway_id": "mcpGatewayId",
+    "mcp_server_id": "mcpServerId",
+    "exposed_tool_name": "exposedToolName",
+    "upstream_tool_name": "upstreamToolName",
+    "latency_ms": "latencyMs",
+    "error_code": "errorCode",
+    "error_message": "errorMessage",
+    "account_id": "accountId",
+    "token_id": "tokenId",
+  });
+});
+
+export function mcpGatewayCallFromJSON(
+  jsonString: string,
+): SafeParseResult<McpGatewayCall, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => McpGatewayCall$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'McpGatewayCall' from JSON`,
+  );
+}

package/packages/orq-rc/src/models/components/mcpgatewaycallstatus.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 McpGatewayCallStatus = {
+  McpGatewayCallStatusUnspecified: "MCP_GATEWAY_CALL_STATUS_UNSPECIFIED",
+  McpGatewayCallStatusSucceeded: "MCP_GATEWAY_CALL_STATUS_SUCCEEDED",
+  McpGatewayCallStatusFailed: "MCP_GATEWAY_CALL_STATUS_FAILED",
+  McpGatewayCallStatusDenied: "MCP_GATEWAY_CALL_STATUS_DENIED",
+  McpGatewayCallStatusTimedOut: "MCP_GATEWAY_CALL_STATUS_TIMED_OUT",
+} as const;
+export type McpGatewayCallStatus = ClosedEnum<typeof McpGatewayCallStatus>;
+
+/** @internal */
+export const McpGatewayCallStatus$inboundSchema: z.ZodNativeEnum<
+  typeof McpGatewayCallStatus
+> = z.nativeEnum(McpGatewayCallStatus);
+/** @internal */
+export const McpGatewayCallStatus$outboundSchema: z.ZodNativeEnum<
+  typeof McpGatewayCallStatus
+> = McpGatewayCallStatus$inboundSchema;

package/packages/orq-rc/src/models/components/mcpgatewayserverlink.ts

@@ -0,0 +1,80 @@
+/*
+ * 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 {
+  McpToolExposure,
+  McpToolExposure$inboundSchema,
+  McpToolExposure$Outbound,
+  McpToolExposure$outboundSchema,
+} from "./mcptoolexposure.js";
+
+export type McpGatewayServerLink = {
+  mcpServerId?: string | undefined;
+  alias?: string | undefined;
+  enabled?: boolean | undefined;
+  toolExposure?: McpToolExposure | undefined;
+};
+
+/** @internal */
+export const McpGatewayServerLink$inboundSchema: z.ZodType<
+  McpGatewayServerLink,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  mcp_server_id: z.string().optional(),
+  alias: z.string().optional(),
+  enabled: z.boolean().optional(),
+  tool_exposure: McpToolExposure$inboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "mcp_server_id": "mcpServerId",
+    "tool_exposure": "toolExposure",
+  });
+});
+/** @internal */
+export type McpGatewayServerLink$Outbound = {
+  mcp_server_id?: string | undefined;
+  alias?: string | undefined;
+  enabled?: boolean | undefined;
+  tool_exposure?: McpToolExposure$Outbound | undefined;
+};
+
+/** @internal */
+export const McpGatewayServerLink$outboundSchema: z.ZodType<
+  McpGatewayServerLink$Outbound,
+  z.ZodTypeDef,
+  McpGatewayServerLink
+> = z.object({
+  mcpServerId: z.string().optional(),
+  alias: z.string().optional(),
+  enabled: z.boolean().optional(),
+  toolExposure: McpToolExposure$outboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    mcpServerId: "mcp_server_id",
+    toolExposure: "tool_exposure",
+  });
+});
+
+export function mcpGatewayServerLinkToJSON(
+  mcpGatewayServerLink: McpGatewayServerLink,
+): string {
+  return JSON.stringify(
+    McpGatewayServerLink$outboundSchema.parse(mcpGatewayServerLink),
+  );
+}
+export function mcpGatewayServerLinkFromJSON(
+  jsonString: string,
+): SafeParseResult<McpGatewayServerLink, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => McpGatewayServerLink$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'McpGatewayServerLink' from JSON`,
+  );
+}

package/packages/orq-rc/src/models/components/mcpgatewaystatus.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 McpGatewayStatus = {
+  McpGatewayStatusUnspecified: "MCP_GATEWAY_STATUS_UNSPECIFIED",
+  McpGatewayStatusActive: "MCP_GATEWAY_STATUS_ACTIVE",
+  McpGatewayStatusDisabled: "MCP_GATEWAY_STATUS_DISABLED",
+} as const;
+export type McpGatewayStatus = ClosedEnum<typeof McpGatewayStatus>;
+
+/** @internal */
+export const McpGatewayStatus$inboundSchema: z.ZodNativeEnum<
+  typeof McpGatewayStatus
+> = z.nativeEnum(McpGatewayStatus);
+/** @internal */
+export const McpGatewayStatus$outboundSchema: z.ZodNativeEnum<
+  typeof McpGatewayStatus
+> = McpGatewayStatus$inboundSchema;

package/packages/orq-rc/src/models/components/mcpgatewaytool.ts

@@ -0,0 +1,68 @@
+/*
+ * 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 InputSchema = {};
+
+export type McpGatewayTool = {
+  serverKey?: string | undefined;
+  alias?: string | undefined;
+  exposedName?: string | undefined;
+  description?: string | undefined;
+  inputSchema?: InputSchema | undefined;
+  readOnly?: boolean | undefined;
+};
+
+/** @internal */
+export const InputSchema$inboundSchema: z.ZodType<
+  InputSchema,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+export function inputSchemaFromJSON(
+  jsonString: string,
+): SafeParseResult<InputSchema, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => InputSchema$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'InputSchema' from JSON`,
+  );
+}
+
+/** @internal */
+export const McpGatewayTool$inboundSchema: z.ZodType<
+  McpGatewayTool,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  server_key: z.string().optional(),
+  alias: z.string().optional(),
+  exposed_name: z.string().optional(),
+  description: z.string().optional(),
+  input_schema: z.lazy(() => InputSchema$inboundSchema).optional(),
+  read_only: z.boolean().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "server_key": "serverKey",
+    "exposed_name": "exposedName",
+    "input_schema": "inputSchema",
+    "read_only": "readOnly",
+  });
+});
+
+export function mcpGatewayToolFromJSON(
+  jsonString: string,
+): SafeParseResult<McpGatewayTool, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => McpGatewayTool$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'McpGatewayTool' from JSON`,
+  );
+}

package/packages/orq-rc/src/models/components/mcpgatewaytooltestresult.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 Result = {};
+
+export type McpGatewayToolTestResult = {
+  ok?: boolean | undefined;
+  result?: Result | undefined;
+  latencyMs?: number | undefined;
+  errorMessage?: string | undefined;
+  errors?: Array<string> | undefined;
+};
+
+/** @internal */
+export const Result$inboundSchema: z.ZodType<Result, z.ZodTypeDef, unknown> = z
+  .object({});
+
+export function resultFromJSON(
+  jsonString: string,
+): SafeParseResult<Result, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Result$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Result' from JSON`,
+  );
+}
+
+/** @internal */
+export const McpGatewayToolTestResult$inboundSchema: z.ZodType<
+  McpGatewayToolTestResult,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  ok: z.boolean().optional(),
+  result: z.lazy(() => Result$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 mcpGatewayToolTestResultFromJSON(
+  jsonString: string,
+): SafeParseResult<McpGatewayToolTestResult, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => McpGatewayToolTestResult$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'McpGatewayToolTestResult' from JSON`,
+  );
+}