/*
 * 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 { ClosedEnum } from "../../types/enums.js";
import { Result as SafeParseResult } from "../../types/fp.js";
import { SDKValidationError } from "../errors/sdkvalidationerror.js";
import {
  MCPToolFilter,
  MCPToolFilter$inboundSchema,
  MCPToolFilter$Outbound,
  MCPToolFilter$outboundSchema,
} from "./mcptoolfilter.js";

export type MCPToolDefinitionAllowedTools = Array<string> | MCPToolFilter;

export const ConnectorId = {
  ConnectorDropbox: "connector_dropbox",
  ConnectorGmail: "connector_gmail",
  ConnectorGooglecalendar: "connector_googlecalendar",
  ConnectorGoogledrive: "connector_googledrive",
  ConnectorMicrosoftteams: "connector_microsoftteams",
  ConnectorOutlookcalendar: "connector_outlookcalendar",
  ConnectorOutlookemail: "connector_outlookemail",
  ConnectorSharepoint: "connector_sharepoint",
} as const;
export type ConnectorId = ClosedEnum<typeof ConnectorId>;

/**
 * MCP tool definition: Connects to an MCP server and exposes its tools, with optional vault references, auth, headers, allow-lists, connector ID, and approval policy.
 */
export type MCPToolDefinition = {
  type: "mcp";
  serverLabel?: string | undefined;
  /**
   * Reference to a gateway-managed MCP server. When provided, server_url is resolved from the MCP vault.
   */
  mcpServerId?: string | undefined;
  /**
   * Optional reference to a gateway-managed MCP credential owned by the run caller.
   */
  mcpCredentialId?: string | undefined;
  allowedTools?: Array<string> | MCPToolFilter | undefined;
  authorization?: string | undefined;
  connectorId?: ConnectorId | undefined;
  headers?: { [k: string]: string } | undefined;
  requireApproval?: any | undefined;
  serverDescription?: string | undefined;
  serverUrl?: string | undefined;
};

/** @internal */
export const MCPToolDefinitionAllowedTools$inboundSchema: z.ZodType<
  MCPToolDefinitionAllowedTools,
  z.ZodTypeDef,
  unknown
> = z.union([z.array(z.string()), MCPToolFilter$inboundSchema]);
/** @internal */
export type MCPToolDefinitionAllowedTools$Outbound =
  | Array<string>
  | MCPToolFilter$Outbound;

/** @internal */
export const MCPToolDefinitionAllowedTools$outboundSchema: z.ZodType<
  MCPToolDefinitionAllowedTools$Outbound,
  z.ZodTypeDef,
  MCPToolDefinitionAllowedTools
> = z.union([z.array(z.string()), MCPToolFilter$outboundSchema]);

export function mcpToolDefinitionAllowedToolsToJSON(
  mcpToolDefinitionAllowedTools: MCPToolDefinitionAllowedTools,
): string {
  return JSON.stringify(
    MCPToolDefinitionAllowedTools$outboundSchema.parse(
      mcpToolDefinitionAllowedTools,
    ),
  );
}
export function mcpToolDefinitionAllowedToolsFromJSON(
  jsonString: string,
): SafeParseResult<MCPToolDefinitionAllowedTools, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => MCPToolDefinitionAllowedTools$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'MCPToolDefinitionAllowedTools' from JSON`,
  );
}

/** @internal */
export const ConnectorId$inboundSchema: z.ZodNativeEnum<typeof ConnectorId> = z
  .nativeEnum(ConnectorId);
/** @internal */
export const ConnectorId$outboundSchema: z.ZodNativeEnum<typeof ConnectorId> =
  ConnectorId$inboundSchema;

/** @internal */
export const MCPToolDefinition$inboundSchema: z.ZodType<
  MCPToolDefinition,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: z.literal("mcp"),
  server_label: z.string().optional(),
  mcp_server_id: z.string().optional(),
  mcp_credential_id: z.string().optional(),
  allowed_tools: z.union([z.array(z.string()), MCPToolFilter$inboundSchema])
    .optional(),
  authorization: z.string().optional(),
  connector_id: ConnectorId$inboundSchema.optional(),
  headers: z.record(z.string()).optional(),
  require_approval: z.any().optional(),
  server_description: z.string().optional(),
  server_url: z.string().optional(),
}).transform((v) => {
  return remap$(v, {
    "server_label": "serverLabel",
    "mcp_server_id": "mcpServerId",
    "mcp_credential_id": "mcpCredentialId",
    "allowed_tools": "allowedTools",
    "connector_id": "connectorId",
    "require_approval": "requireApproval",
    "server_description": "serverDescription",
    "server_url": "serverUrl",
  });
});
/** @internal */
export type MCPToolDefinition$Outbound = {
  type: "mcp";
  server_label?: string | undefined;
  mcp_server_id?: string | undefined;
  mcp_credential_id?: string | undefined;
  allowed_tools?: Array<string> | MCPToolFilter$Outbound | undefined;
  authorization?: string | undefined;
  connector_id?: string | undefined;
  headers?: { [k: string]: string } | undefined;
  require_approval?: any | undefined;
  server_description?: string | undefined;
  server_url?: string | undefined;
};

/** @internal */
export const MCPToolDefinition$outboundSchema: z.ZodType<
  MCPToolDefinition$Outbound,
  z.ZodTypeDef,
  MCPToolDefinition
> = z.object({
  type: z.literal("mcp"),
  serverLabel: z.string().optional(),
  mcpServerId: z.string().optional(),
  mcpCredentialId: z.string().optional(),
  allowedTools: z.union([z.array(z.string()), MCPToolFilter$outboundSchema])
    .optional(),
  authorization: z.string().optional(),
  connectorId: ConnectorId$outboundSchema.optional(),
  headers: z.record(z.string()).optional(),
  requireApproval: z.any().optional(),
  serverDescription: z.string().optional(),
  serverUrl: z.string().optional(),
}).transform((v) => {
  return remap$(v, {
    serverLabel: "server_label",
    mcpServerId: "mcp_server_id",
    mcpCredentialId: "mcp_credential_id",
    allowedTools: "allowed_tools",
    connectorId: "connector_id",
    requireApproval: "require_approval",
    serverDescription: "server_description",
    serverUrl: "server_url",
  });
});

export function mcpToolDefinitionToJSON(
  mcpToolDefinition: MCPToolDefinition,
): string {
  return JSON.stringify(
    MCPToolDefinition$outboundSchema.parse(mcpToolDefinition),
  );
}
export function mcpToolDefinitionFromJSON(
  jsonString: string,
): SafeParseResult<MCPToolDefinition, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => MCPToolDefinition$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'MCPToolDefinition' from JSON`,
  );
}