/*
 * 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 {
  CodeInterpreterToolDefinition,
  CodeInterpreterToolDefinition$inboundSchema,
  CodeInterpreterToolDefinition$Outbound,
  CodeInterpreterToolDefinition$outboundSchema,
} from "./codeinterpretertooldefinition.js";
import {
  CompactionContextManagement,
  CompactionContextManagement$inboundSchema,
  CompactionContextManagement$Outbound,
  CompactionContextManagement$outboundSchema,
} from "./compactioncontextmanagement.js";
import {
  ComparisonFilter,
  ComparisonFilter$inboundSchema,
  ComparisonFilter$Outbound,
  ComparisonFilter$outboundSchema,
} from "./comparisonfilter.js";
import {
  ComputerUseToolDefinition,
  ComputerUseToolDefinition$inboundSchema,
  ComputerUseToolDefinition$Outbound,
  ComputerUseToolDefinition$outboundSchema,
} from "./computerusetooldefinition.js";
import {
  Conversation,
  Conversation$inboundSchema,
  Conversation$Outbound,
  Conversation$outboundSchema,
} from "./conversation.js";
import {
  CustomToolDefinition,
  CustomToolDefinition$inboundSchema,
  CustomToolDefinition$Outbound,
  CustomToolDefinition$outboundSchema,
} from "./customtooldefinition.js";
import {
  ErrorT,
  ErrorT$inboundSchema,
  ErrorT$Outbound,
  ErrorT$outboundSchema,
} from "./error.js";
import {
  FunctionToolDefinition,
  FunctionToolDefinition$inboundSchema,
  FunctionToolDefinition$Outbound,
  FunctionToolDefinition$outboundSchema,
} from "./functiontooldefinition.js";
import {
  HistoryToolDefinition,
  HistoryToolDefinition$inboundSchema,
  HistoryToolDefinition$Outbound,
  HistoryToolDefinition$outboundSchema,
} from "./historytooldefinition.js";
import {
  HostedToolDefinition,
  HostedToolDefinition$inboundSchema,
  HostedToolDefinition$Outbound,
  HostedToolDefinition$outboundSchema,
} from "./hostedtooldefinition.js";
import {
  ImageGenerationToolDefinition,
  ImageGenerationToolDefinition$inboundSchema,
  ImageGenerationToolDefinition$Outbound,
  ImageGenerationToolDefinition$outboundSchema,
} from "./imagegenerationtooldefinition.js";
import {
  IncompleteDetails,
  IncompleteDetails$inboundSchema,
  IncompleteDetails$Outbound,
  IncompleteDetails$outboundSchema,
} from "./incompletedetails.js";
import {
  Item,
  Item$inboundSchema,
  Item$Outbound,
  Item$outboundSchema,
} from "./item.js";
import {
  LocalShellToolDefinition,
  LocalShellToolDefinition$inboundSchema,
  LocalShellToolDefinition$Outbound,
  LocalShellToolDefinition$outboundSchema,
} from "./localshelltooldefinition.js";
import {
  PromptTemplate,
  PromptTemplate$inboundSchema,
  PromptTemplate$Outbound,
  PromptTemplate$outboundSchema,
} from "./prompttemplate.js";
import {
  RankingOptions,
  RankingOptions$inboundSchema,
  RankingOptions$Outbound,
  RankingOptions$outboundSchema,
} from "./rankingoptions.js";
import {
  ReasoningConfiguration,
  ReasoningConfiguration$inboundSchema,
  ReasoningConfiguration$Outbound,
  ReasoningConfiguration$outboundSchema,
} from "./reasoningconfiguration.js";
import {
  ResponseStatus,
  ResponseStatus$inboundSchema,
  ResponseStatus$outboundSchema,
} from "./responsestatus.js";
import {
  ShellToolDefinition,
  ShellToolDefinition$inboundSchema,
  ShellToolDefinition$Outbound,
  ShellToolDefinition$outboundSchema,
} from "./shelltooldefinition.js";
import {
  SleepToolDefinition,
  SleepToolDefinition$inboundSchema,
  SleepToolDefinition$Outbound,
  SleepToolDefinition$outboundSchema,
} from "./sleeptooldefinition.js";
import {
  TextConfiguration,
  TextConfiguration$inboundSchema,
  TextConfiguration$Outbound,
  TextConfiguration$outboundSchema,
} from "./textconfiguration.js";
import {
  ToolChoice,
  ToolChoice$inboundSchema,
  ToolChoice$Outbound,
  ToolChoice$outboundSchema,
} from "./toolchoice.js";
import {
  Usage,
  Usage$inboundSchema,
  Usage$Outbound,
  Usage$outboundSchema,
} from "./usage.js";
import {
  WebSearchPreviewToolDefinition,
  WebSearchPreviewToolDefinition$inboundSchema,
  WebSearchPreviewToolDefinition$Outbound,
  WebSearchPreviewToolDefinition$outboundSchema,
} from "./websearchpreviewtooldefinition.js";
import {
  WebSearchToolDefinition,
  WebSearchToolDefinition$inboundSchema,
  WebSearchToolDefinition$Outbound,
  WebSearchToolDefinition$outboundSchema,
} from "./websearchtooldefinition.js";

export type Instructions = string | Array<Item>;

export const ResponseObjectServiceTier = {
  Auto: "auto",
  Default: "default",
  Flex: "flex",
  Priority: "priority",
} as const;
export type ResponseObjectServiceTier = ClosedEnum<
  typeof ResponseObjectServiceTier
>;

export const FiltersType = {
  And: "and",
  Or: "or",
} as const;
export type FiltersType = ClosedEnum<typeof FiltersType>;

export const ResponseObjectFiltersType = {
  And: "and",
  Or: "or",
} as const;
export type ResponseObjectFiltersType = ClosedEnum<
  typeof ResponseObjectFiltersType
>;

export type ResponseObjectFilters2 = {
  type: ResponseObjectFiltersType;
  filters: Array<any | null>;
};

export type FiltersFilters =
  | (ComparisonFilter & { type: "eq" })
  | (ComparisonFilter & { type: "ne" })
  | (ComparisonFilter & { type: "gt" })
  | (ComparisonFilter & { type: "gte" })
  | (ComparisonFilter & { type: "lt" })
  | (ComparisonFilter & { type: "lte" })
  | (ResponseObjectFilters2 & { type: "and" })
  | (ResponseObjectFilters2 & { type: "or" });

export type Filters2 = {
  type: FiltersType;
  filters: Array<
    | (ComparisonFilter & { type: "eq" })
    | (ComparisonFilter & { type: "ne" })
    | (ComparisonFilter & { type: "gt" })
    | (ComparisonFilter & { type: "gte" })
    | (ComparisonFilter & { type: "lt" })
    | (ComparisonFilter & { type: "lte" })
    | (ResponseObjectFilters2 & { type: "and" })
    | (ResponseObjectFilters2 & { type: "or" })
  >;
};

export type ToolsFilters =
  | (ComparisonFilter & { type: "eq" })
  | (ComparisonFilter & { type: "ne" })
  | (ComparisonFilter & { type: "gt" })
  | (ComparisonFilter & { type: "gte" })
  | (ComparisonFilter & { type: "lt" })
  | (ComparisonFilter & { type: "lte" })
  | (Filters2 & { type: "and" })
  | (Filters2 & { type: "or" });

/**
 * File search tool definition: Configures semantic search over one or more vector stores, with optional filters, ranking options, and result limits.
 */
export type ToolsFileSearchToolDefinition = {
  type: "file_search";
  vectorStoreIds: Array<string>;
  filters?:
    | (ComparisonFilter & { type: "eq" })
    | (ComparisonFilter & { type: "ne" })
    | (ComparisonFilter & { type: "gt" })
    | (ComparisonFilter & { type: "gte" })
    | (ComparisonFilter & { type: "lt" })
    | (ComparisonFilter & { type: "lte" })
    | (Filters2 & { type: "and" })
    | (Filters2 & { type: "or" })
    | undefined;
  maxNumResults?: number | undefined;
  rankingOptions?: RankingOptions | undefined;
};

export type ResponseObjectTools =
  | FunctionToolDefinition
  | ComputerUseToolDefinition
  | ToolsFileSearchToolDefinition
  | CodeInterpreterToolDefinition
  | CustomToolDefinition
  | WebSearchToolDefinition
  | ImageGenerationToolDefinition
  | LocalShellToolDefinition
  | ShellToolDefinition
  | WebSearchPreviewToolDefinition
  | HostedToolDefinition
  | SleepToolDefinition
  | HistoryToolDefinition
  | any;

export const ResponseObjectTruncation = {
  Auto: "auto",
  Disabled: "disabled",
} as const;
export type ResponseObjectTruncation = ClosedEnum<
  typeof ResponseObjectTruncation
>;

export type ResponseObject = {
  id: string;
  object: "response";
  createdAt: number;
  completedAt: number | null;
  /**
   * The overall status of the response generation. 'completed' means successfully finished, 'failed' means error occurred, 'in_progress' means currently processing, 'cancelled' means user-cancelled, 'queued' means waiting to start, 'incomplete' means partial completion.
   */
  status: ResponseStatus;
  error: ErrorT | null;
  incompleteDetails: IncompleteDetails | null;
  background: boolean;
  conversation?: Conversation | undefined;
  instructions: string | Array<Item> | null;
  maxOutputTokens: number | null;
  maxToolCalls: number | null;
  metadata: { [k: string]: string };
  model: string;
  output: Array<Item>;
  outputText?: string | undefined;
  parallelToolCalls: boolean;
  previousResponseId: string | null;
  prompt?: PromptTemplate | undefined;
  promptCacheKey?: string | undefined;
  reasoning?: ReasoningConfiguration | undefined;
  safetyIdentifier?: string | undefined;
  serviceTier?: ResponseObjectServiceTier | undefined;
  store: boolean;
  temperature?: number | undefined;
  presencePenalty?: number | undefined;
  frequencyPenalty?: number | undefined;
  text: TextConfiguration;
  toolChoice: ToolChoice;
  tools: Array<
    | FunctionToolDefinition
    | ComputerUseToolDefinition
    | ToolsFileSearchToolDefinition
    | CodeInterpreterToolDefinition
    | CustomToolDefinition
    | WebSearchToolDefinition
    | ImageGenerationToolDefinition
    | LocalShellToolDefinition
    | ShellToolDefinition
    | WebSearchPreviewToolDefinition
    | HostedToolDefinition
    | SleepToolDefinition
    | HistoryToolDefinition
    | any
    | null
  >;
  topLogprobs?: number | undefined;
  topP?: number | undefined;
  truncation: ResponseObjectTruncation;
  contextManagement?: Array<CompactionContextManagement> | undefined;
  usage: Usage;
  user: string | null;
};

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

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

export function instructionsToJSON(instructions: Instructions): string {
  return JSON.stringify(Instructions$outboundSchema.parse(instructions));
}
export function instructionsFromJSON(
  jsonString: string,
): SafeParseResult<Instructions, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => Instructions$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'Instructions' from JSON`,
  );
}

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

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

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

/** @internal */
export const ResponseObjectFilters2$inboundSchema: z.ZodType<
  ResponseObjectFilters2,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: ResponseObjectFiltersType$inboundSchema,
  filters: z.array(z.nullable(z.any())),
});
/** @internal */
export type ResponseObjectFilters2$Outbound = {
  type: string;
  filters: Array<any | null>;
};

/** @internal */
export const ResponseObjectFilters2$outboundSchema: z.ZodType<
  ResponseObjectFilters2$Outbound,
  z.ZodTypeDef,
  ResponseObjectFilters2
> = z.object({
  type: ResponseObjectFiltersType$outboundSchema,
  filters: z.array(z.nullable(z.any())),
});

export function responseObjectFilters2ToJSON(
  responseObjectFilters2: ResponseObjectFilters2,
): string {
  return JSON.stringify(
    ResponseObjectFilters2$outboundSchema.parse(responseObjectFilters2),
  );
}
export function responseObjectFilters2FromJSON(
  jsonString: string,
): SafeParseResult<ResponseObjectFilters2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ResponseObjectFilters2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ResponseObjectFilters2' from JSON`,
  );
}

/** @internal */
export const FiltersFilters$inboundSchema: z.ZodType<
  FiltersFilters,
  z.ZodTypeDef,
  unknown
> = z.union([
  ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("eq") })),
  ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("ne") })),
  ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("gt") })),
  ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("gte") })),
  ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("lt") })),
  ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("lte") })),
  z.lazy(() => ResponseObjectFilters2$inboundSchema).and(
    z.object({ type: z.literal("and") }),
  ),
  z.lazy(() => ResponseObjectFilters2$inboundSchema).and(
    z.object({ type: z.literal("or") }),
  ),
]);
/** @internal */
export type FiltersFilters$Outbound =
  | (ComparisonFilter$Outbound & { type: "eq" })
  | (ComparisonFilter$Outbound & { type: "ne" })
  | (ComparisonFilter$Outbound & { type: "gt" })
  | (ComparisonFilter$Outbound & { type: "gte" })
  | (ComparisonFilter$Outbound & { type: "lt" })
  | (ComparisonFilter$Outbound & { type: "lte" })
  | (ResponseObjectFilters2$Outbound & { type: "and" })
  | (ResponseObjectFilters2$Outbound & { type: "or" });

/** @internal */
export const FiltersFilters$outboundSchema: z.ZodType<
  FiltersFilters$Outbound,
  z.ZodTypeDef,
  FiltersFilters
> = z.union([
  ComparisonFilter$outboundSchema.and(z.object({ type: z.literal("eq") })),
  ComparisonFilter$outboundSchema.and(z.object({ type: z.literal("ne") })),
  ComparisonFilter$outboundSchema.and(z.object({ type: z.literal("gt") })),
  ComparisonFilter$outboundSchema.and(z.object({ type: z.literal("gte") })),
  ComparisonFilter$outboundSchema.and(z.object({ type: z.literal("lt") })),
  ComparisonFilter$outboundSchema.and(z.object({ type: z.literal("lte") })),
  z.lazy(() => ResponseObjectFilters2$outboundSchema).and(
    z.object({ type: z.literal("and") }),
  ),
  z.lazy(() => ResponseObjectFilters2$outboundSchema).and(
    z.object({ type: z.literal("or") }),
  ),
]);

export function filtersFiltersToJSON(filtersFilters: FiltersFilters): string {
  return JSON.stringify(FiltersFilters$outboundSchema.parse(filtersFilters));
}
export function filtersFiltersFromJSON(
  jsonString: string,
): SafeParseResult<FiltersFilters, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => FiltersFilters$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'FiltersFilters' from JSON`,
  );
}

/** @internal */
export const Filters2$inboundSchema: z.ZodType<
  Filters2,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: FiltersType$inboundSchema,
  filters: z.array(
    z.union([
      ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("eq") })),
      ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("ne") })),
      ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("gt") })),
      ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("gte") })),
      ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("lt") })),
      ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("lte") })),
      z.lazy(() => ResponseObjectFilters2$inboundSchema).and(
        z.object({ type: z.literal("and") }),
      ),
      z.lazy(() => ResponseObjectFilters2$inboundSchema).and(
        z.object({ type: z.literal("or") }),
      ),
    ]),
  ),
});
/** @internal */
export type Filters2$Outbound = {
  type: string;
  filters: Array<
    | (ComparisonFilter$Outbound & { type: "eq" })
    | (ComparisonFilter$Outbound & { type: "ne" })
    | (ComparisonFilter$Outbound & { type: "gt" })
    | (ComparisonFilter$Outbound & { type: "gte" })
    | (ComparisonFilter$Outbound & { type: "lt" })
    | (ComparisonFilter$Outbound & { type: "lte" })
    | (ResponseObjectFilters2$Outbound & { type: "and" })
    | (ResponseObjectFilters2$Outbound & { type: "or" })
  >;
};

/** @internal */
export const Filters2$outboundSchema: z.ZodType<
  Filters2$Outbound,
  z.ZodTypeDef,
  Filters2
> = z.object({
  type: FiltersType$outboundSchema,
  filters: z.array(
    z.union([
      ComparisonFilter$outboundSchema.and(z.object({ type: z.literal("eq") })),
      ComparisonFilter$outboundSchema.and(z.object({ type: z.literal("ne") })),
      ComparisonFilter$outboundSchema.and(z.object({ type: z.literal("gt") })),
      ComparisonFilter$outboundSchema.and(z.object({ type: z.literal("gte") })),
      ComparisonFilter$outboundSchema.and(z.object({ type: z.literal("lt") })),
      ComparisonFilter$outboundSchema.and(z.object({ type: z.literal("lte") })),
      z.lazy(() => ResponseObjectFilters2$outboundSchema).and(
        z.object({ type: z.literal("and") }),
      ),
      z.lazy(() => ResponseObjectFilters2$outboundSchema).and(
        z.object({ type: z.literal("or") }),
      ),
    ]),
  ),
});

export function filters2ToJSON(filters2: Filters2): string {
  return JSON.stringify(Filters2$outboundSchema.parse(filters2));
}
export function filters2FromJSON(
  jsonString: string,
): SafeParseResult<Filters2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => Filters2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'Filters2' from JSON`,
  );
}

/** @internal */
export const ToolsFilters$inboundSchema: z.ZodType<
  ToolsFilters,
  z.ZodTypeDef,
  unknown
> = z.union([
  ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("eq") })),
  ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("ne") })),
  ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("gt") })),
  ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("gte") })),
  ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("lt") })),
  ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("lte") })),
  z.lazy(() => Filters2$inboundSchema).and(
    z.object({ type: z.literal("and") }),
  ),
  z.lazy(() => Filters2$inboundSchema).and(z.object({ type: z.literal("or") })),
]);
/** @internal */
export type ToolsFilters$Outbound =
  | (ComparisonFilter$Outbound & { type: "eq" })
  | (ComparisonFilter$Outbound & { type: "ne" })
  | (ComparisonFilter$Outbound & { type: "gt" })
  | (ComparisonFilter$Outbound & { type: "gte" })
  | (ComparisonFilter$Outbound & { type: "lt" })
  | (ComparisonFilter$Outbound & { type: "lte" })
  | (Filters2$Outbound & { type: "and" })
  | (Filters2$Outbound & { type: "or" });

/** @internal */
export const ToolsFilters$outboundSchema: z.ZodType<
  ToolsFilters$Outbound,
  z.ZodTypeDef,
  ToolsFilters
> = z.union([
  ComparisonFilter$outboundSchema.and(z.object({ type: z.literal("eq") })),
  ComparisonFilter$outboundSchema.and(z.object({ type: z.literal("ne") })),
  ComparisonFilter$outboundSchema.and(z.object({ type: z.literal("gt") })),
  ComparisonFilter$outboundSchema.and(z.object({ type: z.literal("gte") })),
  ComparisonFilter$outboundSchema.and(z.object({ type: z.literal("lt") })),
  ComparisonFilter$outboundSchema.and(z.object({ type: z.literal("lte") })),
  z.lazy(() => Filters2$outboundSchema).and(
    z.object({ type: z.literal("and") }),
  ),
  z.lazy(() => Filters2$outboundSchema).and(
    z.object({ type: z.literal("or") }),
  ),
]);

export function toolsFiltersToJSON(toolsFilters: ToolsFilters): string {
  return JSON.stringify(ToolsFilters$outboundSchema.parse(toolsFilters));
}
export function toolsFiltersFromJSON(
  jsonString: string,
): SafeParseResult<ToolsFilters, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ToolsFilters$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ToolsFilters' from JSON`,
  );
}

/** @internal */
export const ToolsFileSearchToolDefinition$inboundSchema: z.ZodType<
  ToolsFileSearchToolDefinition,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: z.literal("file_search"),
  vector_store_ids: z.array(z.string()),
  filters: z.union([
    ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("eq") })),
    ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("ne") })),
    ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("gt") })),
    ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("gte") })),
    ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("lt") })),
    ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("lte") })),
    z.lazy(() => Filters2$inboundSchema).and(
      z.object({ type: z.literal("and") }),
    ),
    z.lazy(() => Filters2$inboundSchema).and(
      z.object({ type: z.literal("or") }),
    ),
  ]).optional(),
  max_num_results: z.number().int().optional(),
  ranking_options: RankingOptions$inboundSchema.optional(),
}).transform((v) => {
  return remap$(v, {
    "vector_store_ids": "vectorStoreIds",
    "max_num_results": "maxNumResults",
    "ranking_options": "rankingOptions",
  });
});
/** @internal */
export type ToolsFileSearchToolDefinition$Outbound = {
  type: "file_search";
  vector_store_ids: Array<string>;
  filters?:
    | (ComparisonFilter$Outbound & { type: "eq" })
    | (ComparisonFilter$Outbound & { type: "ne" })
    | (ComparisonFilter$Outbound & { type: "gt" })
    | (ComparisonFilter$Outbound & { type: "gte" })
    | (ComparisonFilter$Outbound & { type: "lt" })
    | (ComparisonFilter$Outbound & { type: "lte" })
    | (Filters2$Outbound & { type: "and" })
    | (Filters2$Outbound & { type: "or" })
    | undefined;
  max_num_results?: number | undefined;
  ranking_options?: RankingOptions$Outbound | undefined;
};

/** @internal */
export const ToolsFileSearchToolDefinition$outboundSchema: z.ZodType<
  ToolsFileSearchToolDefinition$Outbound,
  z.ZodTypeDef,
  ToolsFileSearchToolDefinition
> = z.object({
  type: z.literal("file_search"),
  vectorStoreIds: z.array(z.string()),
  filters: z.union([
    ComparisonFilter$outboundSchema.and(z.object({ type: z.literal("eq") })),
    ComparisonFilter$outboundSchema.and(z.object({ type: z.literal("ne") })),
    ComparisonFilter$outboundSchema.and(z.object({ type: z.literal("gt") })),
    ComparisonFilter$outboundSchema.and(z.object({ type: z.literal("gte") })),
    ComparisonFilter$outboundSchema.and(z.object({ type: z.literal("lt") })),
    ComparisonFilter$outboundSchema.and(z.object({ type: z.literal("lte") })),
    z.lazy(() => Filters2$outboundSchema).and(
      z.object({ type: z.literal("and") }),
    ),
    z.lazy(() => Filters2$outboundSchema).and(
      z.object({ type: z.literal("or") }),
    ),
  ]).optional(),
  maxNumResults: z.number().int().optional(),
  rankingOptions: RankingOptions$outboundSchema.optional(),
}).transform((v) => {
  return remap$(v, {
    vectorStoreIds: "vector_store_ids",
    maxNumResults: "max_num_results",
    rankingOptions: "ranking_options",
  });
});

export function toolsFileSearchToolDefinitionToJSON(
  toolsFileSearchToolDefinition: ToolsFileSearchToolDefinition,
): string {
  return JSON.stringify(
    ToolsFileSearchToolDefinition$outboundSchema.parse(
      toolsFileSearchToolDefinition,
    ),
  );
}
export function toolsFileSearchToolDefinitionFromJSON(
  jsonString: string,
): SafeParseResult<ToolsFileSearchToolDefinition, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ToolsFileSearchToolDefinition$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ToolsFileSearchToolDefinition' from JSON`,
  );
}

/** @internal */
export const ResponseObjectTools$inboundSchema: z.ZodType<
  ResponseObjectTools,
  z.ZodTypeDef,
  unknown
> = z.union([
  FunctionToolDefinition$inboundSchema,
  ComputerUseToolDefinition$inboundSchema,
  z.lazy(() => ToolsFileSearchToolDefinition$inboundSchema),
  CodeInterpreterToolDefinition$inboundSchema,
  CustomToolDefinition$inboundSchema,
  WebSearchToolDefinition$inboundSchema,
  ImageGenerationToolDefinition$inboundSchema,
  LocalShellToolDefinition$inboundSchema,
  ShellToolDefinition$inboundSchema,
  WebSearchPreviewToolDefinition$inboundSchema,
  HostedToolDefinition$inboundSchema,
  SleepToolDefinition$inboundSchema,
  HistoryToolDefinition$inboundSchema,
  z.any(),
]);
/** @internal */
export type ResponseObjectTools$Outbound =
  | FunctionToolDefinition$Outbound
  | ComputerUseToolDefinition$Outbound
  | ToolsFileSearchToolDefinition$Outbound
  | CodeInterpreterToolDefinition$Outbound
  | CustomToolDefinition$Outbound
  | WebSearchToolDefinition$Outbound
  | ImageGenerationToolDefinition$Outbound
  | LocalShellToolDefinition$Outbound
  | ShellToolDefinition$Outbound
  | WebSearchPreviewToolDefinition$Outbound
  | HostedToolDefinition$Outbound
  | SleepToolDefinition$Outbound
  | HistoryToolDefinition$Outbound
  | any;

/** @internal */
export const ResponseObjectTools$outboundSchema: z.ZodType<
  ResponseObjectTools$Outbound,
  z.ZodTypeDef,
  ResponseObjectTools
> = z.union([
  FunctionToolDefinition$outboundSchema,
  ComputerUseToolDefinition$outboundSchema,
  z.lazy(() => ToolsFileSearchToolDefinition$outboundSchema),
  CodeInterpreterToolDefinition$outboundSchema,
  CustomToolDefinition$outboundSchema,
  WebSearchToolDefinition$outboundSchema,
  ImageGenerationToolDefinition$outboundSchema,
  LocalShellToolDefinition$outboundSchema,
  ShellToolDefinition$outboundSchema,
  WebSearchPreviewToolDefinition$outboundSchema,
  HostedToolDefinition$outboundSchema,
  SleepToolDefinition$outboundSchema,
  HistoryToolDefinition$outboundSchema,
  z.any(),
]);

export function responseObjectToolsToJSON(
  responseObjectTools: ResponseObjectTools,
): string {
  return JSON.stringify(
    ResponseObjectTools$outboundSchema.parse(responseObjectTools),
  );
}
export function responseObjectToolsFromJSON(
  jsonString: string,
): SafeParseResult<ResponseObjectTools, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ResponseObjectTools$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ResponseObjectTools' from JSON`,
  );
}

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

/** @internal */
export const ResponseObject$inboundSchema: z.ZodType<
  ResponseObject,
  z.ZodTypeDef,
  unknown
> = z.object({
  id: z.string(),
  object: z.literal("response"),
  created_at: z.number(),
  completed_at: z.nullable(z.number()),
  status: ResponseStatus$inboundSchema,
  error: z.nullable(ErrorT$inboundSchema),
  incomplete_details: z.nullable(IncompleteDetails$inboundSchema),
  background: z.boolean(),
  conversation: Conversation$inboundSchema.optional(),
  instructions: z.nullable(z.union([z.string(), z.array(Item$inboundSchema)])),
  max_output_tokens: z.nullable(z.number().int()),
  max_tool_calls: z.nullable(z.number().int()),
  metadata: z.record(z.string()),
  model: z.string(),
  output: z.array(Item$inboundSchema),
  output_text: z.string().optional(),
  parallel_tool_calls: z.boolean(),
  previous_response_id: z.nullable(z.string()),
  prompt: PromptTemplate$inboundSchema.optional(),
  prompt_cache_key: z.string().optional(),
  reasoning: ReasoningConfiguration$inboundSchema.optional(),
  safety_identifier: z.string().optional(),
  service_tier: ResponseObjectServiceTier$inboundSchema.optional(),
  store: z.boolean(),
  temperature: z.number().optional(),
  presence_penalty: z.number().optional(),
  frequency_penalty: z.number().optional(),
  text: TextConfiguration$inboundSchema,
  tool_choice: ToolChoice$inboundSchema,
  tools: z.array(
    z.nullable(
      z.union([
        FunctionToolDefinition$inboundSchema,
        ComputerUseToolDefinition$inboundSchema,
        z.lazy(() => ToolsFileSearchToolDefinition$inboundSchema),
        CodeInterpreterToolDefinition$inboundSchema,
        CustomToolDefinition$inboundSchema,
        WebSearchToolDefinition$inboundSchema,
        ImageGenerationToolDefinition$inboundSchema,
        LocalShellToolDefinition$inboundSchema,
        ShellToolDefinition$inboundSchema,
        WebSearchPreviewToolDefinition$inboundSchema,
        HostedToolDefinition$inboundSchema,
        SleepToolDefinition$inboundSchema,
        HistoryToolDefinition$inboundSchema,
        z.any(),
      ]),
    ),
  ),
  top_logprobs: z.number().int().optional(),
  top_p: z.number().optional(),
  truncation: ResponseObjectTruncation$inboundSchema,
  context_management: z.array(CompactionContextManagement$inboundSchema)
    .optional(),
  usage: Usage$inboundSchema,
  user: z.nullable(z.string()),
}).transform((v) => {
  return remap$(v, {
    "created_at": "createdAt",
    "completed_at": "completedAt",
    "incomplete_details": "incompleteDetails",
    "max_output_tokens": "maxOutputTokens",
    "max_tool_calls": "maxToolCalls",
    "output_text": "outputText",
    "parallel_tool_calls": "parallelToolCalls",
    "previous_response_id": "previousResponseId",
    "prompt_cache_key": "promptCacheKey",
    "safety_identifier": "safetyIdentifier",
    "service_tier": "serviceTier",
    "presence_penalty": "presencePenalty",
    "frequency_penalty": "frequencyPenalty",
    "tool_choice": "toolChoice",
    "top_logprobs": "topLogprobs",
    "top_p": "topP",
    "context_management": "contextManagement",
  });
});
/** @internal */
export type ResponseObject$Outbound = {
  id: string;
  object: "response";
  created_at: number;
  completed_at: number | null;
  status: string;
  error: ErrorT$Outbound | null;
  incomplete_details: IncompleteDetails$Outbound | null;
  background: boolean;
  conversation?: Conversation$Outbound | undefined;
  instructions: string | Array<Item$Outbound> | null;
  max_output_tokens: number | null;
  max_tool_calls: number | null;
  metadata: { [k: string]: string };
  model: string;
  output: Array<Item$Outbound>;
  output_text?: string | undefined;
  parallel_tool_calls: boolean;
  previous_response_id: string | null;
  prompt?: PromptTemplate$Outbound | undefined;
  prompt_cache_key?: string | undefined;
  reasoning?: ReasoningConfiguration$Outbound | undefined;
  safety_identifier?: string | undefined;
  service_tier?: string | undefined;
  store: boolean;
  temperature?: number | undefined;
  presence_penalty?: number | undefined;
  frequency_penalty?: number | undefined;
  text: TextConfiguration$Outbound;
  tool_choice: ToolChoice$Outbound;
  tools: Array<
    | FunctionToolDefinition$Outbound
    | ComputerUseToolDefinition$Outbound
    | ToolsFileSearchToolDefinition$Outbound
    | CodeInterpreterToolDefinition$Outbound
    | CustomToolDefinition$Outbound
    | WebSearchToolDefinition$Outbound
    | ImageGenerationToolDefinition$Outbound
    | LocalShellToolDefinition$Outbound
    | ShellToolDefinition$Outbound
    | WebSearchPreviewToolDefinition$Outbound
    | HostedToolDefinition$Outbound
    | SleepToolDefinition$Outbound
    | HistoryToolDefinition$Outbound
    | any
    | null
  >;
  top_logprobs?: number | undefined;
  top_p?: number | undefined;
  truncation: string;
  context_management?: Array<CompactionContextManagement$Outbound> | undefined;
  usage: Usage$Outbound;
  user: string | null;
};

/** @internal */
export const ResponseObject$outboundSchema: z.ZodType<
  ResponseObject$Outbound,
  z.ZodTypeDef,
  ResponseObject
> = z.object({
  id: z.string(),
  object: z.literal("response"),
  createdAt: z.number(),
  completedAt: z.nullable(z.number()),
  status: ResponseStatus$outboundSchema,
  error: z.nullable(ErrorT$outboundSchema),
  incompleteDetails: z.nullable(IncompleteDetails$outboundSchema),
  background: z.boolean(),
  conversation: Conversation$outboundSchema.optional(),
  instructions: z.nullable(z.union([z.string(), z.array(Item$outboundSchema)])),
  maxOutputTokens: z.nullable(z.number().int()),
  maxToolCalls: z.nullable(z.number().int()),
  metadata: z.record(z.string()),
  model: z.string(),
  output: z.array(Item$outboundSchema),
  outputText: z.string().optional(),
  parallelToolCalls: z.boolean(),
  previousResponseId: z.nullable(z.string()),
  prompt: PromptTemplate$outboundSchema.optional(),
  promptCacheKey: z.string().optional(),
  reasoning: ReasoningConfiguration$outboundSchema.optional(),
  safetyIdentifier: z.string().optional(),
  serviceTier: ResponseObjectServiceTier$outboundSchema.optional(),
  store: z.boolean(),
  temperature: z.number().optional(),
  presencePenalty: z.number().optional(),
  frequencyPenalty: z.number().optional(),
  text: TextConfiguration$outboundSchema,
  toolChoice: ToolChoice$outboundSchema,
  tools: z.array(
    z.nullable(
      z.union([
        FunctionToolDefinition$outboundSchema,
        ComputerUseToolDefinition$outboundSchema,
        z.lazy(() => ToolsFileSearchToolDefinition$outboundSchema),
        CodeInterpreterToolDefinition$outboundSchema,
        CustomToolDefinition$outboundSchema,
        WebSearchToolDefinition$outboundSchema,
        ImageGenerationToolDefinition$outboundSchema,
        LocalShellToolDefinition$outboundSchema,
        ShellToolDefinition$outboundSchema,
        WebSearchPreviewToolDefinition$outboundSchema,
        HostedToolDefinition$outboundSchema,
        SleepToolDefinition$outboundSchema,
        HistoryToolDefinition$outboundSchema,
        z.any(),
      ]),
    ),
  ),
  topLogprobs: z.number().int().optional(),
  topP: z.number().optional(),
  truncation: ResponseObjectTruncation$outboundSchema,
  contextManagement: z.array(CompactionContextManagement$outboundSchema)
    .optional(),
  usage: Usage$outboundSchema,
  user: z.nullable(z.string()),
}).transform((v) => {
  return remap$(v, {
    createdAt: "created_at",
    completedAt: "completed_at",
    incompleteDetails: "incomplete_details",
    maxOutputTokens: "max_output_tokens",
    maxToolCalls: "max_tool_calls",
    outputText: "output_text",
    parallelToolCalls: "parallel_tool_calls",
    previousResponseId: "previous_response_id",
    promptCacheKey: "prompt_cache_key",
    safetyIdentifier: "safety_identifier",
    serviceTier: "service_tier",
    presencePenalty: "presence_penalty",
    frequencyPenalty: "frequency_penalty",
    toolChoice: "tool_choice",
    topLogprobs: "top_logprobs",
    topP: "top_p",
    contextManagement: "context_management",
  });
});

export function responseObjectToJSON(responseObject: ResponseObject): string {
  return JSON.stringify(ResponseObject$outboundSchema.parse(responseObject));
}
export function responseObjectFromJSON(
  jsonString: string,
): SafeParseResult<ResponseObject, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ResponseObject$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ResponseObject' from JSON`,
  );
}