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

package/src/models/components/logpattern.ts

@@ -0,0 +1,84 @@
+/*
+ * 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 { FacetValue, FacetValue$inboundSchema } from "./facetvalue.js";
+
+export type LogPattern = {
+  /**
+   * Stable hash of the normalized template.
+   */
+  id: string;
+  template: string;
+  /**
+   * Number of sampled records assigned to this pattern. This is exact when
+   *
+   * @remarks
+   *  meta.truncated is false.
+   */
+  count: string;
+  /**
+   * Percentage of sampled records assigned to this pattern, from 0 to 100.
+   */
+  percentage: number;
+  firstSeen: Date;
+  lastSeen: Date;
+  /**
+   * A bounded set of example record identifiers; raw bodies are not repeated.
+   */
+  sampleLogIds: Array<string>;
+  /**
+   * Top severity and service values observed inside this pattern.
+   */
+  severitySummary: Array<FacetValue>;
+  serviceSummary: Array<FacetValue>;
+  /**
+   * Bounded literal fragment that can be sent through SearchLogs to find
+   *
+   * @remarks
+   *  representative raw records for this normalized pattern.
+   */
+  suggestedQuery?: string | undefined;
+};
+
+/** @internal */
+export const LogPattern$inboundSchema: z.ZodType<
+  LogPattern,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  template: z.string(),
+  count: z.string(),
+  percentage: z.number(),
+  first_seen: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  last_seen: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  sample_log_ids: z.array(z.string()),
+  severity_summary: z.array(FacetValue$inboundSchema),
+  service_summary: z.array(FacetValue$inboundSchema),
+  suggested_query: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "first_seen": "firstSeen",
+    "last_seen": "lastSeen",
+    "sample_log_ids": "sampleLogIds",
+    "severity_summary": "severitySummary",
+    "service_summary": "serviceSummary",
+    "suggested_query": "suggestedQuery",
+  });
+});
+
+export function logPatternFromJSON(
+  jsonString: string,
+): SafeParseResult<LogPattern, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LogPattern$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LogPattern' from JSON`,
+  );
+}

package/src/models/components/mcpaccess.ts

@@ -0,0 +1,108 @@
+/*
+ * 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";
+
+/**
+ * McpAccess optionally restricts which MCP gateways an API key may
+ *
+ * @remarks
+ *  reach at the data plane. It is orthogonal to permission_mode /
+ *  access: the key must still hold the `mcp_gateway.execute` verb and
+ *  project membership; McpAccess only narrows the reachable gateway set
+ *  within that grant. Human sessions and keys without an McpAccess are
+ *  unaffected.
+ *
+ *  Semantics:
+ *    - absent, or deny_all=false with an empty allowed_mcp_gateway_ids:
+ *      no restriction — every gateway in the key's project scope is
+ *      reachable.
+ *    - deny_all=true: zero gateways are reachable. Wins over
+ *      allowed_mcp_gateway_ids.
+ *    - non-empty allowed_mcp_gateway_ids: only the listed gateway ids
+ *      are reachable. Each id must look like `mcp_gateway_<ULID>`.
+ */
+export type McpAccess = {
+  /**
+   * When true, the key is denied every MCP gateway regardless of
+   *
+   * @remarks
+   *  allowed_mcp_gateway_ids.
+   */
+  denyAll?: boolean | undefined;
+  /**
+   * Allow-list of MCP gateway ids (`mcp_gateway_<ULID>`) the key may
+   *
+   * @remarks
+   *  reach. Ignored when deny_all is true. Empty (with deny_all=false)
+   *  means no restriction.
+   */
+  allowedMcpGatewayIds?: Array<string> | undefined;
+  /**
+   * Allow-list of MCP toolset ids (`mcp_toolset_<ULID>`) the key is
+   *
+   * @remarks
+   *  bound to. When non-empty, the key sees and may call only the tools
+   *  that are both exposed by the target gateway and members of the
+   *  union of these toolsets. Empty means no toolset restriction.
+   */
+  toolsetIds?: Array<string> | undefined;
+};
+
+/** @internal */
+export const McpAccess$inboundSchema: z.ZodType<
+  McpAccess,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  deny_all: z.boolean().optional(),
+  allowed_mcp_gateway_ids: z.array(z.string()).optional(),
+  toolset_ids: z.array(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "deny_all": "denyAll",
+    "allowed_mcp_gateway_ids": "allowedMcpGatewayIds",
+    "toolset_ids": "toolsetIds",
+  });
+});
+/** @internal */
+export type McpAccess$Outbound = {
+  deny_all?: boolean | undefined;
+  allowed_mcp_gateway_ids?: Array<string> | undefined;
+  toolset_ids?: Array<string> | undefined;
+};
+
+/** @internal */
+export const McpAccess$outboundSchema: z.ZodType<
+  McpAccess$Outbound,
+  z.ZodTypeDef,
+  McpAccess
+> = z.object({
+  denyAll: z.boolean().optional(),
+  allowedMcpGatewayIds: z.array(z.string()).optional(),
+  toolsetIds: z.array(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    denyAll: "deny_all",
+    allowedMcpGatewayIds: "allowed_mcp_gateway_ids",
+    toolsetIds: "toolset_ids",
+  });
+});
+
+export function mcpAccessToJSON(mcpAccess: McpAccess): string {
+  return JSON.stringify(McpAccess$outboundSchema.parse(mcpAccess));
+}
+export function mcpAccessFromJSON(
+  jsonString: string,
+): SafeParseResult<McpAccess, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => McpAccess$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'McpAccess' from JSON`,
+  );
+}

package/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/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/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/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/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/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/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/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;