@orq-ai/node 3.6.0-rc.9 → 3.6.0

package/src/models/operations/deploymentgetconfig.ts

@@ -877,6 +877,290 @@ export type Thread = {
   tags?: Array<string> | undefined;
 };
 
+/**
+ * Exists
+ */
+export type OrExists = {
+  exists: boolean;
+};
+
+export type DeploymentGetConfigOrNin = string | number | boolean;
+
+/**
+ * Not in
+ */
+export type OrNin = {
+  nin: Array<string | number | boolean>;
+};
+
+export type DeploymentGetConfigOrIn = string | number | boolean;
+
+/**
+ * In
+ */
+export type OrIn = {
+  in: Array<string | number | boolean>;
+};
+
+/**
+ * Less than or equal to
+ */
+export type OrLte = {
+  lte: number;
+};
+
+/**
+ * Less than
+ */
+export type OrLt = {
+  lt: number;
+};
+
+/**
+ * Greater than or equal to
+ */
+export type OrGte = {
+  gte: number;
+};
+
+export type Or3 = {
+  gt: number;
+};
+
+export type DeploymentGetConfigOrNe = string | number | boolean;
+
+/**
+ * Not equal to
+ */
+export type OrNe = {
+  ne: string | number | boolean;
+};
+
+export type DeploymentGetConfigOrEq = string | number | boolean;
+
+/**
+ * Equal to
+ */
+export type OrEq = {
+  eq: string | number | boolean;
+};
+
+export type KnowledgeFilterOr =
+  | OrEq
+  | OrNe
+  | Or3
+  | OrGte
+  | OrLt
+  | OrLte
+  | OrIn
+  | OrNin
+  | OrExists;
+
+/**
+ * Or
+ */
+export type Or = {
+  or: Array<
+    {
+      [k: string]:
+        | OrEq
+        | OrNe
+        | Or3
+        | OrGte
+        | OrLt
+        | OrLte
+        | OrIn
+        | OrNin
+        | OrExists;
+    }
+  >;
+};
+
+/**
+ * Exists
+ */
+export type AndExists = {
+  exists: boolean;
+};
+
+export type DeploymentGetConfigAndNin = string | number | boolean;
+
+/**
+ * Not in
+ */
+export type AndNin = {
+  nin: Array<string | number | boolean>;
+};
+
+export type DeploymentGetConfigAndIn = string | number | boolean;
+
+/**
+ * In
+ */
+export type AndIn = {
+  in: Array<string | number | boolean>;
+};
+
+/**
+ * Less than or equal to
+ */
+export type AndLte = {
+  lte: number;
+};
+
+/**
+ * Less than
+ */
+export type AndLt = {
+  lt: number;
+};
+
+/**
+ * Greater than or equal to
+ */
+export type AndGte = {
+  gte: number;
+};
+
+export type And3 = {
+  gt: number;
+};
+
+export type DeploymentGetConfigAndNe = string | number | boolean;
+
+/**
+ * Not equal to
+ */
+export type AndNe = {
+  ne: string | number | boolean;
+};
+
+export type DeploymentGetConfigAndEq = string | number | boolean;
+
+/**
+ * Equal to
+ */
+export type AndEq = {
+  eq: string | number | boolean;
+};
+
+export type KnowledgeFilterAnd =
+  | AndEq
+  | AndNe
+  | And3
+  | AndGte
+  | AndLt
+  | AndLte
+  | AndIn
+  | AndNin
+  | AndExists;
+
+/**
+ * And
+ */
+export type And = {
+  and: Array<
+    {
+      [k: string]:
+        | AndEq
+        | AndNe
+        | And3
+        | AndGte
+        | AndLt
+        | AndLte
+        | AndIn
+        | AndNin
+        | AndExists;
+    }
+  >;
+};
+
+/**
+ * Exists
+ */
+export type Exists = {
+  exists: boolean;
+};
+
+export type OneNin = string | number | boolean;
+
+/**
+ * Not in
+ */
+export type Nin = {
+  nin: Array<string | number | boolean>;
+};
+
+export type OneIn = string | number | boolean;
+
+/**
+ * In
+ */
+export type In = {
+  in: Array<string | number | boolean>;
+};
+
+/**
+ * Less than or equal to
+ */
+export type Lte = {
+  lte: number;
+};
+
+/**
+ * Less than
+ */
+export type Lt = {
+  lt: number;
+};
+
+/**
+ * Greater than or equal to
+ */
+export type Gte = {
+  gte: number;
+};
+
+export type One3 = {
+  gt: number;
+};
+
+export type OneNe = string | number | boolean;
+
+/**
+ * Not equal to
+ */
+export type Ne = {
+  ne: string | number | boolean;
+};
+
+export type OneEq = string | number | boolean;
+
+/**
+ * Equal to
+ */
+export type Eq = {
+  eq: string | number | boolean;
+};
+
+export type KnowledgeFilter1 =
+  | Eq
+  | Ne
+  | One3
+  | Gte
+  | Lt
+  | Lte
+  | In
+  | Nin
+  | Exists;
+
+/**
+ * A filter to apply to the knowledge base chunk metadata when using  knowledge bases in the deployment.
+ */
+export type KnowledgeFilter = And | Or | {
+  [k: string]: Eq | Ne | One3 | Gte | Lt | Lte | In | Nin | Exists;
+};
+
 export type DeploymentGetConfigRequestBody = {
   /**
    * The deployment key to invoke
@@ -932,6 +1216,12 @@ export type DeploymentGetConfigRequestBody = {
   documents?: Array<Documents> | undefined;
   invokeOptions?: InvokeOptions | undefined;
   thread?: Thread | undefined;
+  /**
+   * A filter to apply to the knowledge base chunk metadata when using  knowledge bases in the deployment.
+   */
+  knowledgeFilter?: And | Or | {
+    [k: string]: Eq | Ne | One3 | Gte | Lt | Lte | In | Nin | Exists;
+  } | undefined;
 };
 
 /**
@@ -975,6 +1265,39 @@ export type DeploymentGetConfigRole = ClosedEnum<
   typeof DeploymentGetConfigRole
 >;
 
+/**
+ * The type of the content part. Always `file`.
+ */
+export const DeploymentGetConfig2DeploymentsResponse200ApplicationJSONType = {
+  File: "file",
+} as const;
+/**
+ * The type of the content part. Always `file`.
+ */
+export type DeploymentGetConfig2DeploymentsResponse200ApplicationJSONType =
+  ClosedEnum<
+    typeof DeploymentGetConfig2DeploymentsResponse200ApplicationJSONType
+  >;
+
+export type DeploymentGetConfig2File = {
+  /**
+   * The base64 encoded file data, used when passing the file to the model as a string.
+   */
+  fileData: string;
+  /**
+   * The name of the file, used when passing the file to the model as a string.
+   */
+  filename?: string | undefined;
+};
+
+export type DeploymentGetConfig23 = {
+  /**
+   * The type of the content part. Always `file`.
+   */
+  type: DeploymentGetConfig2DeploymentsResponse200ApplicationJSONType;
+  file: DeploymentGetConfig2File;
+};
+
 export const DeploymentGetConfig2DeploymentsResponse200Type = {
   ImageUrl: "image_url",
 } as const;
@@ -1022,14 +1345,19 @@ export type DeploymentGetConfig21 = {
 
 export type DeploymentGetConfigContentDeploymentsResponse2 =
   | DeploymentGetConfig21
-  | DeploymentGetConfig2Deployments2;
+  | DeploymentGetConfig2Deployments2
+  | DeploymentGetConfig23;
 
 /**
  * The contents of the user message. Either the text content of the message or an array of content parts with a defined type, each can be of type `text` or `image_url` when passing in images. You can pass multiple images by adding multiple `image_url` content parts.
  */
 export type DeploymentGetConfigContent =
   | string
-  | Array<DeploymentGetConfig21 | DeploymentGetConfig2Deployments2>;
+  | Array<
+    | DeploymentGetConfig21
+    | DeploymentGetConfig2Deployments2
+    | DeploymentGetConfig23
+  >;
 
 export const DeploymentGetConfigDeploymentsResponseType = {
   Function: "function",
@@ -1063,7 +1391,11 @@ export type DeploymentGetConfigMessages = {
    */
   content:
     | string
-    | Array<DeploymentGetConfig21 | DeploymentGetConfig2Deployments2>;
+    | Array<
+      | DeploymentGetConfig21
+      | DeploymentGetConfig2Deployments2
+      | DeploymentGetConfig23
+    >;
   toolCalls?: Array<DeploymentGetConfigToolCalls> | undefined;
   toolCallId?: string | undefined;
 };
@@ -5046,117 +5378,2423 @@ export function threadFromJSON(
 }
 
 /** @internal */
-export const DeploymentGetConfigRequestBody$inboundSchema: z.ZodType<
-  DeploymentGetConfigRequestBody,
+export const OrExists$inboundSchema: z.ZodType<
+  OrExists,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  key: z.string(),
-  inputs: z.record(z.union([z.string(), z.number(), z.boolean()])).optional(),
-  context: z.record(z.any()).optional(),
-  prefix_messages: z.array(
-    z.union([
-      z.lazy(() => DeveloperMessage$inboundSchema),
-      z.lazy(() => SystemMessage$inboundSchema),
-      z.lazy(() => UserMessage$inboundSchema),
-      z.lazy(() => ToolMessage$inboundSchema),
-      z.lazy(() => AssistantMessage$inboundSchema),
-    ]),
-  ).optional(),
-  messages: z.array(
-    z.union([
-      z.lazy(() => MessagesDeveloperMessage$inboundSchema),
-      z.lazy(() => MessagesSystemMessage$inboundSchema),
-      z.lazy(() => MessagesUserMessage$inboundSchema),
-      z.lazy(() => MessagesToolMessage$inboundSchema),
-      z.lazy(() => MessagesAssistantMessage$inboundSchema),
-    ]),
-  ).optional(),
-  file_ids: z.array(z.string()).optional(),
-  metadata: z.record(z.any()).optional(),
-  extra_params: z.record(z.any()).optional(),
-  documents: z.array(z.lazy(() => Documents$inboundSchema)).optional(),
-  invoke_options: z.lazy(() => InvokeOptions$inboundSchema).optional(),
-  thread: z.lazy(() => Thread$inboundSchema).optional(),
-}).transform((v) => {
-  return remap$(v, {
-    "prefix_messages": "prefixMessages",
-    "file_ids": "fileIds",
-    "extra_params": "extraParams",
-    "invoke_options": "invokeOptions",
-  });
+  exists: z.boolean(),
 });
 
 /** @internal */
-export type DeploymentGetConfigRequestBody$Outbound = {
-  key: string;
-  inputs?: { [k: string]: string | number | boolean } | undefined;
-  context?: { [k: string]: any } | undefined;
-  prefix_messages?:
-    | Array<
-      | DeveloperMessage$Outbound
-      | SystemMessage$Outbound
-      | UserMessage$Outbound
-      | ToolMessage$Outbound
-      | AssistantMessage$Outbound
-    >
-    | undefined;
-  messages?:
-    | Array<
-      | MessagesDeveloperMessage$Outbound
-      | MessagesSystemMessage$Outbound
-      | MessagesUserMessage$Outbound
-      | MessagesToolMessage$Outbound
-      | MessagesAssistantMessage$Outbound
-    >
-    | undefined;
-  file_ids?: Array<string> | undefined;
-  metadata?: { [k: string]: any } | undefined;
-  extra_params?: { [k: string]: any } | undefined;
-  documents?: Array<Documents$Outbound> | undefined;
-  invoke_options?: InvokeOptions$Outbound | undefined;
-  thread?: Thread$Outbound | undefined;
+export type OrExists$Outbound = {
+  exists: boolean;
 };
 
 /** @internal */
-export const DeploymentGetConfigRequestBody$outboundSchema: z.ZodType<
-  DeploymentGetConfigRequestBody$Outbound,
+export const OrExists$outboundSchema: z.ZodType<
+  OrExists$Outbound,
   z.ZodTypeDef,
-  DeploymentGetConfigRequestBody
+  OrExists
 > = z.object({
-  key: z.string(),
-  inputs: z.record(z.union([z.string(), z.number(), z.boolean()])).optional(),
-  context: z.record(z.any()).optional(),
-  prefixMessages: z.array(
-    z.union([
-      z.lazy(() => DeveloperMessage$outboundSchema),
-      z.lazy(() => SystemMessage$outboundSchema),
-      z.lazy(() => UserMessage$outboundSchema),
-      z.lazy(() => ToolMessage$outboundSchema),
-      z.lazy(() => AssistantMessage$outboundSchema),
-    ]),
-  ).optional(),
-  messages: z.array(
-    z.union([
-      z.lazy(() => MessagesDeveloperMessage$outboundSchema),
-      z.lazy(() => MessagesSystemMessage$outboundSchema),
-      z.lazy(() => MessagesUserMessage$outboundSchema),
-      z.lazy(() => MessagesToolMessage$outboundSchema),
-      z.lazy(() => MessagesAssistantMessage$outboundSchema),
-    ]),
-  ).optional(),
-  fileIds: z.array(z.string()).optional(),
-  metadata: z.record(z.any()).optional(),
-  extraParams: z.record(z.any()).optional(),
-  documents: z.array(z.lazy(() => Documents$outboundSchema)).optional(),
-  invokeOptions: z.lazy(() => InvokeOptions$outboundSchema).optional(),
-  thread: z.lazy(() => Thread$outboundSchema).optional(),
-}).transform((v) => {
-  return remap$(v, {
-    prefixMessages: "prefix_messages",
-    fileIds: "file_ids",
-    extraParams: "extra_params",
+  exists: z.boolean(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OrExists$ {
+  /** @deprecated use `OrExists$inboundSchema` instead. */
+  export const inboundSchema = OrExists$inboundSchema;
+  /** @deprecated use `OrExists$outboundSchema` instead. */
+  export const outboundSchema = OrExists$outboundSchema;
+  /** @deprecated use `OrExists$Outbound` instead. */
+  export type Outbound = OrExists$Outbound;
+}
+
+export function orExistsToJSON(orExists: OrExists): string {
+  return JSON.stringify(OrExists$outboundSchema.parse(orExists));
+}
+
+export function orExistsFromJSON(
+  jsonString: string,
+): SafeParseResult<OrExists, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => OrExists$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OrExists' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentGetConfigOrNin$inboundSchema: z.ZodType<
+  DeploymentGetConfigOrNin,
+  z.ZodTypeDef,
+  unknown
+> = z.union([z.string(), z.number(), z.boolean()]);
+
+/** @internal */
+export type DeploymentGetConfigOrNin$Outbound = string | number | boolean;
+
+/** @internal */
+export const DeploymentGetConfigOrNin$outboundSchema: z.ZodType<
+  DeploymentGetConfigOrNin$Outbound,
+  z.ZodTypeDef,
+  DeploymentGetConfigOrNin
+> = z.union([z.string(), z.number(), z.boolean()]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace DeploymentGetConfigOrNin$ {
+  /** @deprecated use `DeploymentGetConfigOrNin$inboundSchema` instead. */
+  export const inboundSchema = DeploymentGetConfigOrNin$inboundSchema;
+  /** @deprecated use `DeploymentGetConfigOrNin$outboundSchema` instead. */
+  export const outboundSchema = DeploymentGetConfigOrNin$outboundSchema;
+  /** @deprecated use `DeploymentGetConfigOrNin$Outbound` instead. */
+  export type Outbound = DeploymentGetConfigOrNin$Outbound;
+}
+
+export function deploymentGetConfigOrNinToJSON(
+  deploymentGetConfigOrNin: DeploymentGetConfigOrNin,
+): string {
+  return JSON.stringify(
+    DeploymentGetConfigOrNin$outboundSchema.parse(deploymentGetConfigOrNin),
+  );
+}
+
+export function deploymentGetConfigOrNinFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentGetConfigOrNin, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentGetConfigOrNin$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentGetConfigOrNin' from JSON`,
+  );
+}
+
+/** @internal */
+export const OrNin$inboundSchema: z.ZodType<OrNin, z.ZodTypeDef, unknown> = z
+  .object({
+    nin: z.array(z.union([z.string(), z.number(), z.boolean()])),
+  });
+
+/** @internal */
+export type OrNin$Outbound = {
+  nin: Array<string | number | boolean>;
+};
+
+/** @internal */
+export const OrNin$outboundSchema: z.ZodType<
+  OrNin$Outbound,
+  z.ZodTypeDef,
+  OrNin
+> = z.object({
+  nin: z.array(z.union([z.string(), z.number(), z.boolean()])),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OrNin$ {
+  /** @deprecated use `OrNin$inboundSchema` instead. */
+  export const inboundSchema = OrNin$inboundSchema;
+  /** @deprecated use `OrNin$outboundSchema` instead. */
+  export const outboundSchema = OrNin$outboundSchema;
+  /** @deprecated use `OrNin$Outbound` instead. */
+  export type Outbound = OrNin$Outbound;
+}
+
+export function orNinToJSON(orNin: OrNin): string {
+  return JSON.stringify(OrNin$outboundSchema.parse(orNin));
+}
+
+export function orNinFromJSON(
+  jsonString: string,
+): SafeParseResult<OrNin, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => OrNin$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OrNin' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentGetConfigOrIn$inboundSchema: z.ZodType<
+  DeploymentGetConfigOrIn,
+  z.ZodTypeDef,
+  unknown
+> = z.union([z.string(), z.number(), z.boolean()]);
+
+/** @internal */
+export type DeploymentGetConfigOrIn$Outbound = string | number | boolean;
+
+/** @internal */
+export const DeploymentGetConfigOrIn$outboundSchema: z.ZodType<
+  DeploymentGetConfigOrIn$Outbound,
+  z.ZodTypeDef,
+  DeploymentGetConfigOrIn
+> = z.union([z.string(), z.number(), z.boolean()]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace DeploymentGetConfigOrIn$ {
+  /** @deprecated use `DeploymentGetConfigOrIn$inboundSchema` instead. */
+  export const inboundSchema = DeploymentGetConfigOrIn$inboundSchema;
+  /** @deprecated use `DeploymentGetConfigOrIn$outboundSchema` instead. */
+  export const outboundSchema = DeploymentGetConfigOrIn$outboundSchema;
+  /** @deprecated use `DeploymentGetConfigOrIn$Outbound` instead. */
+  export type Outbound = DeploymentGetConfigOrIn$Outbound;
+}
+
+export function deploymentGetConfigOrInToJSON(
+  deploymentGetConfigOrIn: DeploymentGetConfigOrIn,
+): string {
+  return JSON.stringify(
+    DeploymentGetConfigOrIn$outboundSchema.parse(deploymentGetConfigOrIn),
+  );
+}
+
+export function deploymentGetConfigOrInFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentGetConfigOrIn, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentGetConfigOrIn$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentGetConfigOrIn' from JSON`,
+  );
+}
+
+/** @internal */
+export const OrIn$inboundSchema: z.ZodType<OrIn, z.ZodTypeDef, unknown> = z
+  .object({
+    in: z.array(z.union([z.string(), z.number(), z.boolean()])),
+  });
+
+/** @internal */
+export type OrIn$Outbound = {
+  in: Array<string | number | boolean>;
+};
+
+/** @internal */
+export const OrIn$outboundSchema: z.ZodType<OrIn$Outbound, z.ZodTypeDef, OrIn> =
+  z.object({
+    in: z.array(z.union([z.string(), z.number(), z.boolean()])),
+  });
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OrIn$ {
+  /** @deprecated use `OrIn$inboundSchema` instead. */
+  export const inboundSchema = OrIn$inboundSchema;
+  /** @deprecated use `OrIn$outboundSchema` instead. */
+  export const outboundSchema = OrIn$outboundSchema;
+  /** @deprecated use `OrIn$Outbound` instead. */
+  export type Outbound = OrIn$Outbound;
+}
+
+export function orInToJSON(orIn: OrIn): string {
+  return JSON.stringify(OrIn$outboundSchema.parse(orIn));
+}
+
+export function orInFromJSON(
+  jsonString: string,
+): SafeParseResult<OrIn, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => OrIn$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OrIn' from JSON`,
+  );
+}
+
+/** @internal */
+export const OrLte$inboundSchema: z.ZodType<OrLte, z.ZodTypeDef, unknown> = z
+  .object({
+    lte: z.number(),
+  });
+
+/** @internal */
+export type OrLte$Outbound = {
+  lte: number;
+};
+
+/** @internal */
+export const OrLte$outboundSchema: z.ZodType<
+  OrLte$Outbound,
+  z.ZodTypeDef,
+  OrLte
+> = z.object({
+  lte: z.number(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OrLte$ {
+  /** @deprecated use `OrLte$inboundSchema` instead. */
+  export const inboundSchema = OrLte$inboundSchema;
+  /** @deprecated use `OrLte$outboundSchema` instead. */
+  export const outboundSchema = OrLte$outboundSchema;
+  /** @deprecated use `OrLte$Outbound` instead. */
+  export type Outbound = OrLte$Outbound;
+}
+
+export function orLteToJSON(orLte: OrLte): string {
+  return JSON.stringify(OrLte$outboundSchema.parse(orLte));
+}
+
+export function orLteFromJSON(
+  jsonString: string,
+): SafeParseResult<OrLte, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => OrLte$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OrLte' from JSON`,
+  );
+}
+
+/** @internal */
+export const OrLt$inboundSchema: z.ZodType<OrLt, z.ZodTypeDef, unknown> = z
+  .object({
+    lt: z.number(),
+  });
+
+/** @internal */
+export type OrLt$Outbound = {
+  lt: number;
+};
+
+/** @internal */
+export const OrLt$outboundSchema: z.ZodType<OrLt$Outbound, z.ZodTypeDef, OrLt> =
+  z.object({
+    lt: z.number(),
+  });
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OrLt$ {
+  /** @deprecated use `OrLt$inboundSchema` instead. */
+  export const inboundSchema = OrLt$inboundSchema;
+  /** @deprecated use `OrLt$outboundSchema` instead. */
+  export const outboundSchema = OrLt$outboundSchema;
+  /** @deprecated use `OrLt$Outbound` instead. */
+  export type Outbound = OrLt$Outbound;
+}
+
+export function orLtToJSON(orLt: OrLt): string {
+  return JSON.stringify(OrLt$outboundSchema.parse(orLt));
+}
+
+export function orLtFromJSON(
+  jsonString: string,
+): SafeParseResult<OrLt, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => OrLt$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OrLt' from JSON`,
+  );
+}
+
+/** @internal */
+export const OrGte$inboundSchema: z.ZodType<OrGte, z.ZodTypeDef, unknown> = z
+  .object({
+    gte: z.number(),
+  });
+
+/** @internal */
+export type OrGte$Outbound = {
+  gte: number;
+};
+
+/** @internal */
+export const OrGte$outboundSchema: z.ZodType<
+  OrGte$Outbound,
+  z.ZodTypeDef,
+  OrGte
+> = z.object({
+  gte: z.number(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OrGte$ {
+  /** @deprecated use `OrGte$inboundSchema` instead. */
+  export const inboundSchema = OrGte$inboundSchema;
+  /** @deprecated use `OrGte$outboundSchema` instead. */
+  export const outboundSchema = OrGte$outboundSchema;
+  /** @deprecated use `OrGte$Outbound` instead. */
+  export type Outbound = OrGte$Outbound;
+}
+
+export function orGteToJSON(orGte: OrGte): string {
+  return JSON.stringify(OrGte$outboundSchema.parse(orGte));
+}
+
+export function orGteFromJSON(
+  jsonString: string,
+): SafeParseResult<OrGte, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => OrGte$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OrGte' from JSON`,
+  );
+}
+
+/** @internal */
+export const Or3$inboundSchema: z.ZodType<Or3, z.ZodTypeDef, unknown> = z
+  .object({
+    gt: z.number(),
+  });
+
+/** @internal */
+export type Or3$Outbound = {
+  gt: number;
+};
+
+/** @internal */
+export const Or3$outboundSchema: z.ZodType<Or3$Outbound, z.ZodTypeDef, Or3> = z
+  .object({
+    gt: z.number(),
+  });
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Or3$ {
+  /** @deprecated use `Or3$inboundSchema` instead. */
+  export const inboundSchema = Or3$inboundSchema;
+  /** @deprecated use `Or3$outboundSchema` instead. */
+  export const outboundSchema = Or3$outboundSchema;
+  /** @deprecated use `Or3$Outbound` instead. */
+  export type Outbound = Or3$Outbound;
+}
+
+export function or3ToJSON(or3: Or3): string {
+  return JSON.stringify(Or3$outboundSchema.parse(or3));
+}
+
+export function or3FromJSON(
+  jsonString: string,
+): SafeParseResult<Or3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Or3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Or3' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentGetConfigOrNe$inboundSchema: z.ZodType<
+  DeploymentGetConfigOrNe,
+  z.ZodTypeDef,
+  unknown
+> = z.union([z.string(), z.number(), z.boolean()]);
+
+/** @internal */
+export type DeploymentGetConfigOrNe$Outbound = string | number | boolean;
+
+/** @internal */
+export const DeploymentGetConfigOrNe$outboundSchema: z.ZodType<
+  DeploymentGetConfigOrNe$Outbound,
+  z.ZodTypeDef,
+  DeploymentGetConfigOrNe
+> = z.union([z.string(), z.number(), z.boolean()]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace DeploymentGetConfigOrNe$ {
+  /** @deprecated use `DeploymentGetConfigOrNe$inboundSchema` instead. */
+  export const inboundSchema = DeploymentGetConfigOrNe$inboundSchema;
+  /** @deprecated use `DeploymentGetConfigOrNe$outboundSchema` instead. */
+  export const outboundSchema = DeploymentGetConfigOrNe$outboundSchema;
+  /** @deprecated use `DeploymentGetConfigOrNe$Outbound` instead. */
+  export type Outbound = DeploymentGetConfigOrNe$Outbound;
+}
+
+export function deploymentGetConfigOrNeToJSON(
+  deploymentGetConfigOrNe: DeploymentGetConfigOrNe,
+): string {
+  return JSON.stringify(
+    DeploymentGetConfigOrNe$outboundSchema.parse(deploymentGetConfigOrNe),
+  );
+}
+
+export function deploymentGetConfigOrNeFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentGetConfigOrNe, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentGetConfigOrNe$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentGetConfigOrNe' from JSON`,
+  );
+}
+
+/** @internal */
+export const OrNe$inboundSchema: z.ZodType<OrNe, z.ZodTypeDef, unknown> = z
+  .object({
+    ne: z.union([z.string(), z.number(), z.boolean()]),
+  });
+
+/** @internal */
+export type OrNe$Outbound = {
+  ne: string | number | boolean;
+};
+
+/** @internal */
+export const OrNe$outboundSchema: z.ZodType<OrNe$Outbound, z.ZodTypeDef, OrNe> =
+  z.object({
+    ne: z.union([z.string(), z.number(), z.boolean()]),
+  });
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OrNe$ {
+  /** @deprecated use `OrNe$inboundSchema` instead. */
+  export const inboundSchema = OrNe$inboundSchema;
+  /** @deprecated use `OrNe$outboundSchema` instead. */
+  export const outboundSchema = OrNe$outboundSchema;
+  /** @deprecated use `OrNe$Outbound` instead. */
+  export type Outbound = OrNe$Outbound;
+}
+
+export function orNeToJSON(orNe: OrNe): string {
+  return JSON.stringify(OrNe$outboundSchema.parse(orNe));
+}
+
+export function orNeFromJSON(
+  jsonString: string,
+): SafeParseResult<OrNe, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => OrNe$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OrNe' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentGetConfigOrEq$inboundSchema: z.ZodType<
+  DeploymentGetConfigOrEq,
+  z.ZodTypeDef,
+  unknown
+> = z.union([z.string(), z.number(), z.boolean()]);
+
+/** @internal */
+export type DeploymentGetConfigOrEq$Outbound = string | number | boolean;
+
+/** @internal */
+export const DeploymentGetConfigOrEq$outboundSchema: z.ZodType<
+  DeploymentGetConfigOrEq$Outbound,
+  z.ZodTypeDef,
+  DeploymentGetConfigOrEq
+> = z.union([z.string(), z.number(), z.boolean()]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace DeploymentGetConfigOrEq$ {
+  /** @deprecated use `DeploymentGetConfigOrEq$inboundSchema` instead. */
+  export const inboundSchema = DeploymentGetConfigOrEq$inboundSchema;
+  /** @deprecated use `DeploymentGetConfigOrEq$outboundSchema` instead. */
+  export const outboundSchema = DeploymentGetConfigOrEq$outboundSchema;
+  /** @deprecated use `DeploymentGetConfigOrEq$Outbound` instead. */
+  export type Outbound = DeploymentGetConfigOrEq$Outbound;
+}
+
+export function deploymentGetConfigOrEqToJSON(
+  deploymentGetConfigOrEq: DeploymentGetConfigOrEq,
+): string {
+  return JSON.stringify(
+    DeploymentGetConfigOrEq$outboundSchema.parse(deploymentGetConfigOrEq),
+  );
+}
+
+export function deploymentGetConfigOrEqFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentGetConfigOrEq, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentGetConfigOrEq$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentGetConfigOrEq' from JSON`,
+  );
+}
+
+/** @internal */
+export const OrEq$inboundSchema: z.ZodType<OrEq, z.ZodTypeDef, unknown> = z
+  .object({
+    eq: z.union([z.string(), z.number(), z.boolean()]),
+  });
+
+/** @internal */
+export type OrEq$Outbound = {
+  eq: string | number | boolean;
+};
+
+/** @internal */
+export const OrEq$outboundSchema: z.ZodType<OrEq$Outbound, z.ZodTypeDef, OrEq> =
+  z.object({
+    eq: z.union([z.string(), z.number(), z.boolean()]),
+  });
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OrEq$ {
+  /** @deprecated use `OrEq$inboundSchema` instead. */
+  export const inboundSchema = OrEq$inboundSchema;
+  /** @deprecated use `OrEq$outboundSchema` instead. */
+  export const outboundSchema = OrEq$outboundSchema;
+  /** @deprecated use `OrEq$Outbound` instead. */
+  export type Outbound = OrEq$Outbound;
+}
+
+export function orEqToJSON(orEq: OrEq): string {
+  return JSON.stringify(OrEq$outboundSchema.parse(orEq));
+}
+
+export function orEqFromJSON(
+  jsonString: string,
+): SafeParseResult<OrEq, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => OrEq$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OrEq' from JSON`,
+  );
+}
+
+/** @internal */
+export const KnowledgeFilterOr$inboundSchema: z.ZodType<
+  KnowledgeFilterOr,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => OrEq$inboundSchema),
+  z.lazy(() => OrNe$inboundSchema),
+  z.lazy(() => Or3$inboundSchema),
+  z.lazy(() => OrGte$inboundSchema),
+  z.lazy(() => OrLt$inboundSchema),
+  z.lazy(() => OrLte$inboundSchema),
+  z.lazy(() => OrIn$inboundSchema),
+  z.lazy(() => OrNin$inboundSchema),
+  z.lazy(() => OrExists$inboundSchema),
+]);
+
+/** @internal */
+export type KnowledgeFilterOr$Outbound =
+  | OrEq$Outbound
+  | OrNe$Outbound
+  | Or3$Outbound
+  | OrGte$Outbound
+  | OrLt$Outbound
+  | OrLte$Outbound
+  | OrIn$Outbound
+  | OrNin$Outbound
+  | OrExists$Outbound;
+
+/** @internal */
+export const KnowledgeFilterOr$outboundSchema: z.ZodType<
+  KnowledgeFilterOr$Outbound,
+  z.ZodTypeDef,
+  KnowledgeFilterOr
+> = z.union([
+  z.lazy(() => OrEq$outboundSchema),
+  z.lazy(() => OrNe$outboundSchema),
+  z.lazy(() => Or3$outboundSchema),
+  z.lazy(() => OrGte$outboundSchema),
+  z.lazy(() => OrLt$outboundSchema),
+  z.lazy(() => OrLte$outboundSchema),
+  z.lazy(() => OrIn$outboundSchema),
+  z.lazy(() => OrNin$outboundSchema),
+  z.lazy(() => OrExists$outboundSchema),
+]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace KnowledgeFilterOr$ {
+  /** @deprecated use `KnowledgeFilterOr$inboundSchema` instead. */
+  export const inboundSchema = KnowledgeFilterOr$inboundSchema;
+  /** @deprecated use `KnowledgeFilterOr$outboundSchema` instead. */
+  export const outboundSchema = KnowledgeFilterOr$outboundSchema;
+  /** @deprecated use `KnowledgeFilterOr$Outbound` instead. */
+  export type Outbound = KnowledgeFilterOr$Outbound;
+}
+
+export function knowledgeFilterOrToJSON(
+  knowledgeFilterOr: KnowledgeFilterOr,
+): string {
+  return JSON.stringify(
+    KnowledgeFilterOr$outboundSchema.parse(knowledgeFilterOr),
+  );
+}
+
+export function knowledgeFilterOrFromJSON(
+  jsonString: string,
+): SafeParseResult<KnowledgeFilterOr, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => KnowledgeFilterOr$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'KnowledgeFilterOr' from JSON`,
+  );
+}
+
+/** @internal */
+export const Or$inboundSchema: z.ZodType<Or, z.ZodTypeDef, unknown> = z.object({
+  or: z.array(
+    z.record(z.union([
+      z.lazy(() => OrEq$inboundSchema),
+      z.lazy(() =>
+        OrNe$inboundSchema
+      ),
+      z.lazy(() => Or3$inboundSchema),
+      z.lazy(() => OrGte$inboundSchema),
+      z.lazy(() => OrLt$inboundSchema),
+      z.lazy(() => OrLte$inboundSchema),
+      z.lazy(() => OrIn$inboundSchema),
+      z.lazy(() => OrNin$inboundSchema),
+      z.lazy(() => OrExists$inboundSchema),
+    ])),
+  ),
+});
+
+/** @internal */
+export type Or$Outbound = {
+  or: Array<
+    {
+      [k: string]:
+        | OrEq$Outbound
+        | OrNe$Outbound
+        | Or3$Outbound
+        | OrGte$Outbound
+        | OrLt$Outbound
+        | OrLte$Outbound
+        | OrIn$Outbound
+        | OrNin$Outbound
+        | OrExists$Outbound;
+    }
+  >;
+};
+
+/** @internal */
+export const Or$outboundSchema: z.ZodType<Or$Outbound, z.ZodTypeDef, Or> = z
+  .object({
+    or: z.array(
+      z.record(z.union([
+        z.lazy(() => OrEq$outboundSchema),
+        z.lazy(() =>
+          OrNe$outboundSchema
+        ),
+        z.lazy(() => Or3$outboundSchema),
+        z.lazy(() => OrGte$outboundSchema),
+        z.lazy(() => OrLt$outboundSchema),
+        z.lazy(() => OrLte$outboundSchema),
+        z.lazy(() => OrIn$outboundSchema),
+        z.lazy(() => OrNin$outboundSchema),
+        z.lazy(() => OrExists$outboundSchema),
+      ])),
+    ),
+  });
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Or$ {
+  /** @deprecated use `Or$inboundSchema` instead. */
+  export const inboundSchema = Or$inboundSchema;
+  /** @deprecated use `Or$outboundSchema` instead. */
+  export const outboundSchema = Or$outboundSchema;
+  /** @deprecated use `Or$Outbound` instead. */
+  export type Outbound = Or$Outbound;
+}
+
+export function orToJSON(or: Or): string {
+  return JSON.stringify(Or$outboundSchema.parse(or));
+}
+
+export function orFromJSON(
+  jsonString: string,
+): SafeParseResult<Or, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Or$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Or' from JSON`,
+  );
+}
+
+/** @internal */
+export const AndExists$inboundSchema: z.ZodType<
+  AndExists,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  exists: z.boolean(),
+});
+
+/** @internal */
+export type AndExists$Outbound = {
+  exists: boolean;
+};
+
+/** @internal */
+export const AndExists$outboundSchema: z.ZodType<
+  AndExists$Outbound,
+  z.ZodTypeDef,
+  AndExists
+> = z.object({
+  exists: z.boolean(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AndExists$ {
+  /** @deprecated use `AndExists$inboundSchema` instead. */
+  export const inboundSchema = AndExists$inboundSchema;
+  /** @deprecated use `AndExists$outboundSchema` instead. */
+  export const outboundSchema = AndExists$outboundSchema;
+  /** @deprecated use `AndExists$Outbound` instead. */
+  export type Outbound = AndExists$Outbound;
+}
+
+export function andExistsToJSON(andExists: AndExists): string {
+  return JSON.stringify(AndExists$outboundSchema.parse(andExists));
+}
+
+export function andExistsFromJSON(
+  jsonString: string,
+): SafeParseResult<AndExists, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AndExists$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AndExists' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentGetConfigAndNin$inboundSchema: z.ZodType<
+  DeploymentGetConfigAndNin,
+  z.ZodTypeDef,
+  unknown
+> = z.union([z.string(), z.number(), z.boolean()]);
+
+/** @internal */
+export type DeploymentGetConfigAndNin$Outbound = string | number | boolean;
+
+/** @internal */
+export const DeploymentGetConfigAndNin$outboundSchema: z.ZodType<
+  DeploymentGetConfigAndNin$Outbound,
+  z.ZodTypeDef,
+  DeploymentGetConfigAndNin
+> = z.union([z.string(), z.number(), z.boolean()]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace DeploymentGetConfigAndNin$ {
+  /** @deprecated use `DeploymentGetConfigAndNin$inboundSchema` instead. */
+  export const inboundSchema = DeploymentGetConfigAndNin$inboundSchema;
+  /** @deprecated use `DeploymentGetConfigAndNin$outboundSchema` instead. */
+  export const outboundSchema = DeploymentGetConfigAndNin$outboundSchema;
+  /** @deprecated use `DeploymentGetConfigAndNin$Outbound` instead. */
+  export type Outbound = DeploymentGetConfigAndNin$Outbound;
+}
+
+export function deploymentGetConfigAndNinToJSON(
+  deploymentGetConfigAndNin: DeploymentGetConfigAndNin,
+): string {
+  return JSON.stringify(
+    DeploymentGetConfigAndNin$outboundSchema.parse(deploymentGetConfigAndNin),
+  );
+}
+
+export function deploymentGetConfigAndNinFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentGetConfigAndNin, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentGetConfigAndNin$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentGetConfigAndNin' from JSON`,
+  );
+}
+
+/** @internal */
+export const AndNin$inboundSchema: z.ZodType<AndNin, z.ZodTypeDef, unknown> = z
+  .object({
+    nin: z.array(z.union([z.string(), z.number(), z.boolean()])),
+  });
+
+/** @internal */
+export type AndNin$Outbound = {
+  nin: Array<string | number | boolean>;
+};
+
+/** @internal */
+export const AndNin$outboundSchema: z.ZodType<
+  AndNin$Outbound,
+  z.ZodTypeDef,
+  AndNin
+> = z.object({
+  nin: z.array(z.union([z.string(), z.number(), z.boolean()])),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AndNin$ {
+  /** @deprecated use `AndNin$inboundSchema` instead. */
+  export const inboundSchema = AndNin$inboundSchema;
+  /** @deprecated use `AndNin$outboundSchema` instead. */
+  export const outboundSchema = AndNin$outboundSchema;
+  /** @deprecated use `AndNin$Outbound` instead. */
+  export type Outbound = AndNin$Outbound;
+}
+
+export function andNinToJSON(andNin: AndNin): string {
+  return JSON.stringify(AndNin$outboundSchema.parse(andNin));
+}
+
+export function andNinFromJSON(
+  jsonString: string,
+): SafeParseResult<AndNin, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AndNin$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AndNin' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentGetConfigAndIn$inboundSchema: z.ZodType<
+  DeploymentGetConfigAndIn,
+  z.ZodTypeDef,
+  unknown
+> = z.union([z.string(), z.number(), z.boolean()]);
+
+/** @internal */
+export type DeploymentGetConfigAndIn$Outbound = string | number | boolean;
+
+/** @internal */
+export const DeploymentGetConfigAndIn$outboundSchema: z.ZodType<
+  DeploymentGetConfigAndIn$Outbound,
+  z.ZodTypeDef,
+  DeploymentGetConfigAndIn
+> = z.union([z.string(), z.number(), z.boolean()]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace DeploymentGetConfigAndIn$ {
+  /** @deprecated use `DeploymentGetConfigAndIn$inboundSchema` instead. */
+  export const inboundSchema = DeploymentGetConfigAndIn$inboundSchema;
+  /** @deprecated use `DeploymentGetConfigAndIn$outboundSchema` instead. */
+  export const outboundSchema = DeploymentGetConfigAndIn$outboundSchema;
+  /** @deprecated use `DeploymentGetConfigAndIn$Outbound` instead. */
+  export type Outbound = DeploymentGetConfigAndIn$Outbound;
+}
+
+export function deploymentGetConfigAndInToJSON(
+  deploymentGetConfigAndIn: DeploymentGetConfigAndIn,
+): string {
+  return JSON.stringify(
+    DeploymentGetConfigAndIn$outboundSchema.parse(deploymentGetConfigAndIn),
+  );
+}
+
+export function deploymentGetConfigAndInFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentGetConfigAndIn, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentGetConfigAndIn$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentGetConfigAndIn' from JSON`,
+  );
+}
+
+/** @internal */
+export const AndIn$inboundSchema: z.ZodType<AndIn, z.ZodTypeDef, unknown> = z
+  .object({
+    in: z.array(z.union([z.string(), z.number(), z.boolean()])),
+  });
+
+/** @internal */
+export type AndIn$Outbound = {
+  in: Array<string | number | boolean>;
+};
+
+/** @internal */
+export const AndIn$outboundSchema: z.ZodType<
+  AndIn$Outbound,
+  z.ZodTypeDef,
+  AndIn
+> = z.object({
+  in: z.array(z.union([z.string(), z.number(), z.boolean()])),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AndIn$ {
+  /** @deprecated use `AndIn$inboundSchema` instead. */
+  export const inboundSchema = AndIn$inboundSchema;
+  /** @deprecated use `AndIn$outboundSchema` instead. */
+  export const outboundSchema = AndIn$outboundSchema;
+  /** @deprecated use `AndIn$Outbound` instead. */
+  export type Outbound = AndIn$Outbound;
+}
+
+export function andInToJSON(andIn: AndIn): string {
+  return JSON.stringify(AndIn$outboundSchema.parse(andIn));
+}
+
+export function andInFromJSON(
+  jsonString: string,
+): SafeParseResult<AndIn, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AndIn$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AndIn' from JSON`,
+  );
+}
+
+/** @internal */
+export const AndLte$inboundSchema: z.ZodType<AndLte, z.ZodTypeDef, unknown> = z
+  .object({
+    lte: z.number(),
+  });
+
+/** @internal */
+export type AndLte$Outbound = {
+  lte: number;
+};
+
+/** @internal */
+export const AndLte$outboundSchema: z.ZodType<
+  AndLte$Outbound,
+  z.ZodTypeDef,
+  AndLte
+> = z.object({
+  lte: z.number(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AndLte$ {
+  /** @deprecated use `AndLte$inboundSchema` instead. */
+  export const inboundSchema = AndLte$inboundSchema;
+  /** @deprecated use `AndLte$outboundSchema` instead. */
+  export const outboundSchema = AndLte$outboundSchema;
+  /** @deprecated use `AndLte$Outbound` instead. */
+  export type Outbound = AndLte$Outbound;
+}
+
+export function andLteToJSON(andLte: AndLte): string {
+  return JSON.stringify(AndLte$outboundSchema.parse(andLte));
+}
+
+export function andLteFromJSON(
+  jsonString: string,
+): SafeParseResult<AndLte, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AndLte$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AndLte' from JSON`,
+  );
+}
+
+/** @internal */
+export const AndLt$inboundSchema: z.ZodType<AndLt, z.ZodTypeDef, unknown> = z
+  .object({
+    lt: z.number(),
+  });
+
+/** @internal */
+export type AndLt$Outbound = {
+  lt: number;
+};
+
+/** @internal */
+export const AndLt$outboundSchema: z.ZodType<
+  AndLt$Outbound,
+  z.ZodTypeDef,
+  AndLt
+> = z.object({
+  lt: z.number(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AndLt$ {
+  /** @deprecated use `AndLt$inboundSchema` instead. */
+  export const inboundSchema = AndLt$inboundSchema;
+  /** @deprecated use `AndLt$outboundSchema` instead. */
+  export const outboundSchema = AndLt$outboundSchema;
+  /** @deprecated use `AndLt$Outbound` instead. */
+  export type Outbound = AndLt$Outbound;
+}
+
+export function andLtToJSON(andLt: AndLt): string {
+  return JSON.stringify(AndLt$outboundSchema.parse(andLt));
+}
+
+export function andLtFromJSON(
+  jsonString: string,
+): SafeParseResult<AndLt, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AndLt$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AndLt' from JSON`,
+  );
+}
+
+/** @internal */
+export const AndGte$inboundSchema: z.ZodType<AndGte, z.ZodTypeDef, unknown> = z
+  .object({
+    gte: z.number(),
+  });
+
+/** @internal */
+export type AndGte$Outbound = {
+  gte: number;
+};
+
+/** @internal */
+export const AndGte$outboundSchema: z.ZodType<
+  AndGte$Outbound,
+  z.ZodTypeDef,
+  AndGte
+> = z.object({
+  gte: z.number(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AndGte$ {
+  /** @deprecated use `AndGte$inboundSchema` instead. */
+  export const inboundSchema = AndGte$inboundSchema;
+  /** @deprecated use `AndGte$outboundSchema` instead. */
+  export const outboundSchema = AndGte$outboundSchema;
+  /** @deprecated use `AndGte$Outbound` instead. */
+  export type Outbound = AndGte$Outbound;
+}
+
+export function andGteToJSON(andGte: AndGte): string {
+  return JSON.stringify(AndGte$outboundSchema.parse(andGte));
+}
+
+export function andGteFromJSON(
+  jsonString: string,
+): SafeParseResult<AndGte, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AndGte$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AndGte' from JSON`,
+  );
+}
+
+/** @internal */
+export const And3$inboundSchema: z.ZodType<And3, z.ZodTypeDef, unknown> = z
+  .object({
+    gt: z.number(),
+  });
+
+/** @internal */
+export type And3$Outbound = {
+  gt: number;
+};
+
+/** @internal */
+export const And3$outboundSchema: z.ZodType<And3$Outbound, z.ZodTypeDef, And3> =
+  z.object({
+    gt: z.number(),
+  });
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace And3$ {
+  /** @deprecated use `And3$inboundSchema` instead. */
+  export const inboundSchema = And3$inboundSchema;
+  /** @deprecated use `And3$outboundSchema` instead. */
+  export const outboundSchema = And3$outboundSchema;
+  /** @deprecated use `And3$Outbound` instead. */
+  export type Outbound = And3$Outbound;
+}
+
+export function and3ToJSON(and3: And3): string {
+  return JSON.stringify(And3$outboundSchema.parse(and3));
+}
+
+export function and3FromJSON(
+  jsonString: string,
+): SafeParseResult<And3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => And3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'And3' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentGetConfigAndNe$inboundSchema: z.ZodType<
+  DeploymentGetConfigAndNe,
+  z.ZodTypeDef,
+  unknown
+> = z.union([z.string(), z.number(), z.boolean()]);
+
+/** @internal */
+export type DeploymentGetConfigAndNe$Outbound = string | number | boolean;
+
+/** @internal */
+export const DeploymentGetConfigAndNe$outboundSchema: z.ZodType<
+  DeploymentGetConfigAndNe$Outbound,
+  z.ZodTypeDef,
+  DeploymentGetConfigAndNe
+> = z.union([z.string(), z.number(), z.boolean()]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace DeploymentGetConfigAndNe$ {
+  /** @deprecated use `DeploymentGetConfigAndNe$inboundSchema` instead. */
+  export const inboundSchema = DeploymentGetConfigAndNe$inboundSchema;
+  /** @deprecated use `DeploymentGetConfigAndNe$outboundSchema` instead. */
+  export const outboundSchema = DeploymentGetConfigAndNe$outboundSchema;
+  /** @deprecated use `DeploymentGetConfigAndNe$Outbound` instead. */
+  export type Outbound = DeploymentGetConfigAndNe$Outbound;
+}
+
+export function deploymentGetConfigAndNeToJSON(
+  deploymentGetConfigAndNe: DeploymentGetConfigAndNe,
+): string {
+  return JSON.stringify(
+    DeploymentGetConfigAndNe$outboundSchema.parse(deploymentGetConfigAndNe),
+  );
+}
+
+export function deploymentGetConfigAndNeFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentGetConfigAndNe, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentGetConfigAndNe$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentGetConfigAndNe' from JSON`,
+  );
+}
+
+/** @internal */
+export const AndNe$inboundSchema: z.ZodType<AndNe, z.ZodTypeDef, unknown> = z
+  .object({
+    ne: z.union([z.string(), z.number(), z.boolean()]),
+  });
+
+/** @internal */
+export type AndNe$Outbound = {
+  ne: string | number | boolean;
+};
+
+/** @internal */
+export const AndNe$outboundSchema: z.ZodType<
+  AndNe$Outbound,
+  z.ZodTypeDef,
+  AndNe
+> = z.object({
+  ne: z.union([z.string(), z.number(), z.boolean()]),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AndNe$ {
+  /** @deprecated use `AndNe$inboundSchema` instead. */
+  export const inboundSchema = AndNe$inboundSchema;
+  /** @deprecated use `AndNe$outboundSchema` instead. */
+  export const outboundSchema = AndNe$outboundSchema;
+  /** @deprecated use `AndNe$Outbound` instead. */
+  export type Outbound = AndNe$Outbound;
+}
+
+export function andNeToJSON(andNe: AndNe): string {
+  return JSON.stringify(AndNe$outboundSchema.parse(andNe));
+}
+
+export function andNeFromJSON(
+  jsonString: string,
+): SafeParseResult<AndNe, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AndNe$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AndNe' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentGetConfigAndEq$inboundSchema: z.ZodType<
+  DeploymentGetConfigAndEq,
+  z.ZodTypeDef,
+  unknown
+> = z.union([z.string(), z.number(), z.boolean()]);
+
+/** @internal */
+export type DeploymentGetConfigAndEq$Outbound = string | number | boolean;
+
+/** @internal */
+export const DeploymentGetConfigAndEq$outboundSchema: z.ZodType<
+  DeploymentGetConfigAndEq$Outbound,
+  z.ZodTypeDef,
+  DeploymentGetConfigAndEq
+> = z.union([z.string(), z.number(), z.boolean()]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace DeploymentGetConfigAndEq$ {
+  /** @deprecated use `DeploymentGetConfigAndEq$inboundSchema` instead. */
+  export const inboundSchema = DeploymentGetConfigAndEq$inboundSchema;
+  /** @deprecated use `DeploymentGetConfigAndEq$outboundSchema` instead. */
+  export const outboundSchema = DeploymentGetConfigAndEq$outboundSchema;
+  /** @deprecated use `DeploymentGetConfigAndEq$Outbound` instead. */
+  export type Outbound = DeploymentGetConfigAndEq$Outbound;
+}
+
+export function deploymentGetConfigAndEqToJSON(
+  deploymentGetConfigAndEq: DeploymentGetConfigAndEq,
+): string {
+  return JSON.stringify(
+    DeploymentGetConfigAndEq$outboundSchema.parse(deploymentGetConfigAndEq),
+  );
+}
+
+export function deploymentGetConfigAndEqFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentGetConfigAndEq, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentGetConfigAndEq$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentGetConfigAndEq' from JSON`,
+  );
+}
+
+/** @internal */
+export const AndEq$inboundSchema: z.ZodType<AndEq, z.ZodTypeDef, unknown> = z
+  .object({
+    eq: z.union([z.string(), z.number(), z.boolean()]),
+  });
+
+/** @internal */
+export type AndEq$Outbound = {
+  eq: string | number | boolean;
+};
+
+/** @internal */
+export const AndEq$outboundSchema: z.ZodType<
+  AndEq$Outbound,
+  z.ZodTypeDef,
+  AndEq
+> = z.object({
+  eq: z.union([z.string(), z.number(), z.boolean()]),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AndEq$ {
+  /** @deprecated use `AndEq$inboundSchema` instead. */
+  export const inboundSchema = AndEq$inboundSchema;
+  /** @deprecated use `AndEq$outboundSchema` instead. */
+  export const outboundSchema = AndEq$outboundSchema;
+  /** @deprecated use `AndEq$Outbound` instead. */
+  export type Outbound = AndEq$Outbound;
+}
+
+export function andEqToJSON(andEq: AndEq): string {
+  return JSON.stringify(AndEq$outboundSchema.parse(andEq));
+}
+
+export function andEqFromJSON(
+  jsonString: string,
+): SafeParseResult<AndEq, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AndEq$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AndEq' from JSON`,
+  );
+}
+
+/** @internal */
+export const KnowledgeFilterAnd$inboundSchema: z.ZodType<
+  KnowledgeFilterAnd,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => AndEq$inboundSchema),
+  z.lazy(() => AndNe$inboundSchema),
+  z.lazy(() => And3$inboundSchema),
+  z.lazy(() => AndGte$inboundSchema),
+  z.lazy(() => AndLt$inboundSchema),
+  z.lazy(() => AndLte$inboundSchema),
+  z.lazy(() => AndIn$inboundSchema),
+  z.lazy(() => AndNin$inboundSchema),
+  z.lazy(() => AndExists$inboundSchema),
+]);
+
+/** @internal */
+export type KnowledgeFilterAnd$Outbound =
+  | AndEq$Outbound
+  | AndNe$Outbound
+  | And3$Outbound
+  | AndGte$Outbound
+  | AndLt$Outbound
+  | AndLte$Outbound
+  | AndIn$Outbound
+  | AndNin$Outbound
+  | AndExists$Outbound;
+
+/** @internal */
+export const KnowledgeFilterAnd$outboundSchema: z.ZodType<
+  KnowledgeFilterAnd$Outbound,
+  z.ZodTypeDef,
+  KnowledgeFilterAnd
+> = z.union([
+  z.lazy(() => AndEq$outboundSchema),
+  z.lazy(() => AndNe$outboundSchema),
+  z.lazy(() => And3$outboundSchema),
+  z.lazy(() => AndGte$outboundSchema),
+  z.lazy(() => AndLt$outboundSchema),
+  z.lazy(() => AndLte$outboundSchema),
+  z.lazy(() => AndIn$outboundSchema),
+  z.lazy(() => AndNin$outboundSchema),
+  z.lazy(() => AndExists$outboundSchema),
+]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace KnowledgeFilterAnd$ {
+  /** @deprecated use `KnowledgeFilterAnd$inboundSchema` instead. */
+  export const inboundSchema = KnowledgeFilterAnd$inboundSchema;
+  /** @deprecated use `KnowledgeFilterAnd$outboundSchema` instead. */
+  export const outboundSchema = KnowledgeFilterAnd$outboundSchema;
+  /** @deprecated use `KnowledgeFilterAnd$Outbound` instead. */
+  export type Outbound = KnowledgeFilterAnd$Outbound;
+}
+
+export function knowledgeFilterAndToJSON(
+  knowledgeFilterAnd: KnowledgeFilterAnd,
+): string {
+  return JSON.stringify(
+    KnowledgeFilterAnd$outboundSchema.parse(knowledgeFilterAnd),
+  );
+}
+
+export function knowledgeFilterAndFromJSON(
+  jsonString: string,
+): SafeParseResult<KnowledgeFilterAnd, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => KnowledgeFilterAnd$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'KnowledgeFilterAnd' from JSON`,
+  );
+}
+
+/** @internal */
+export const And$inboundSchema: z.ZodType<And, z.ZodTypeDef, unknown> = z
+  .object({
+    and: z.array(
+      z.record(z.union([
+        z.lazy(() => AndEq$inboundSchema),
+        z.lazy(() =>
+          AndNe$inboundSchema
+        ),
+        z.lazy(() => And3$inboundSchema),
+        z.lazy(() => AndGte$inboundSchema),
+        z.lazy(() => AndLt$inboundSchema),
+        z.lazy(() => AndLte$inboundSchema),
+        z.lazy(() => AndIn$inboundSchema),
+        z.lazy(() => AndNin$inboundSchema),
+        z.lazy(() => AndExists$inboundSchema),
+      ])),
+    ),
+  });
+
+/** @internal */
+export type And$Outbound = {
+  and: Array<
+    {
+      [k: string]:
+        | AndEq$Outbound
+        | AndNe$Outbound
+        | And3$Outbound
+        | AndGte$Outbound
+        | AndLt$Outbound
+        | AndLte$Outbound
+        | AndIn$Outbound
+        | AndNin$Outbound
+        | AndExists$Outbound;
+    }
+  >;
+};
+
+/** @internal */
+export const And$outboundSchema: z.ZodType<And$Outbound, z.ZodTypeDef, And> = z
+  .object({
+    and: z.array(
+      z.record(z.union([
+        z.lazy(() => AndEq$outboundSchema),
+        z.lazy(() =>
+          AndNe$outboundSchema
+        ),
+        z.lazy(() => And3$outboundSchema),
+        z.lazy(() => AndGte$outboundSchema),
+        z.lazy(() => AndLt$outboundSchema),
+        z.lazy(() => AndLte$outboundSchema),
+        z.lazy(() => AndIn$outboundSchema),
+        z.lazy(() => AndNin$outboundSchema),
+        z.lazy(() => AndExists$outboundSchema),
+      ])),
+    ),
+  });
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace And$ {
+  /** @deprecated use `And$inboundSchema` instead. */
+  export const inboundSchema = And$inboundSchema;
+  /** @deprecated use `And$outboundSchema` instead. */
+  export const outboundSchema = And$outboundSchema;
+  /** @deprecated use `And$Outbound` instead. */
+  export type Outbound = And$Outbound;
+}
+
+export function andToJSON(and: And): string {
+  return JSON.stringify(And$outboundSchema.parse(and));
+}
+
+export function andFromJSON(
+  jsonString: string,
+): SafeParseResult<And, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => And$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'And' from JSON`,
+  );
+}
+
+/** @internal */
+export const Exists$inboundSchema: z.ZodType<Exists, z.ZodTypeDef, unknown> = z
+  .object({
+    exists: z.boolean(),
+  });
+
+/** @internal */
+export type Exists$Outbound = {
+  exists: boolean;
+};
+
+/** @internal */
+export const Exists$outboundSchema: z.ZodType<
+  Exists$Outbound,
+  z.ZodTypeDef,
+  Exists
+> = z.object({
+  exists: z.boolean(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Exists$ {
+  /** @deprecated use `Exists$inboundSchema` instead. */
+  export const inboundSchema = Exists$inboundSchema;
+  /** @deprecated use `Exists$outboundSchema` instead. */
+  export const outboundSchema = Exists$outboundSchema;
+  /** @deprecated use `Exists$Outbound` instead. */
+  export type Outbound = Exists$Outbound;
+}
+
+export function existsToJSON(exists: Exists): string {
+  return JSON.stringify(Exists$outboundSchema.parse(exists));
+}
+
+export function existsFromJSON(
+  jsonString: string,
+): SafeParseResult<Exists, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Exists$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Exists' from JSON`,
+  );
+}
+
+/** @internal */
+export const OneNin$inboundSchema: z.ZodType<OneNin, z.ZodTypeDef, unknown> = z
+  .union([z.string(), z.number(), z.boolean()]);
+
+/** @internal */
+export type OneNin$Outbound = string | number | boolean;
+
+/** @internal */
+export const OneNin$outboundSchema: z.ZodType<
+  OneNin$Outbound,
+  z.ZodTypeDef,
+  OneNin
+> = z.union([z.string(), z.number(), z.boolean()]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OneNin$ {
+  /** @deprecated use `OneNin$inboundSchema` instead. */
+  export const inboundSchema = OneNin$inboundSchema;
+  /** @deprecated use `OneNin$outboundSchema` instead. */
+  export const outboundSchema = OneNin$outboundSchema;
+  /** @deprecated use `OneNin$Outbound` instead. */
+  export type Outbound = OneNin$Outbound;
+}
+
+export function oneNinToJSON(oneNin: OneNin): string {
+  return JSON.stringify(OneNin$outboundSchema.parse(oneNin));
+}
+
+export function oneNinFromJSON(
+  jsonString: string,
+): SafeParseResult<OneNin, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => OneNin$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OneNin' from JSON`,
+  );
+}
+
+/** @internal */
+export const Nin$inboundSchema: z.ZodType<Nin, z.ZodTypeDef, unknown> = z
+  .object({
+    nin: z.array(z.union([z.string(), z.number(), z.boolean()])),
+  });
+
+/** @internal */
+export type Nin$Outbound = {
+  nin: Array<string | number | boolean>;
+};
+
+/** @internal */
+export const Nin$outboundSchema: z.ZodType<Nin$Outbound, z.ZodTypeDef, Nin> = z
+  .object({
+    nin: z.array(z.union([z.string(), z.number(), z.boolean()])),
+  });
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Nin$ {
+  /** @deprecated use `Nin$inboundSchema` instead. */
+  export const inboundSchema = Nin$inboundSchema;
+  /** @deprecated use `Nin$outboundSchema` instead. */
+  export const outboundSchema = Nin$outboundSchema;
+  /** @deprecated use `Nin$Outbound` instead. */
+  export type Outbound = Nin$Outbound;
+}
+
+export function ninToJSON(nin: Nin): string {
+  return JSON.stringify(Nin$outboundSchema.parse(nin));
+}
+
+export function ninFromJSON(
+  jsonString: string,
+): SafeParseResult<Nin, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Nin$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Nin' from JSON`,
+  );
+}
+
+/** @internal */
+export const OneIn$inboundSchema: z.ZodType<OneIn, z.ZodTypeDef, unknown> = z
+  .union([z.string(), z.number(), z.boolean()]);
+
+/** @internal */
+export type OneIn$Outbound = string | number | boolean;
+
+/** @internal */
+export const OneIn$outboundSchema: z.ZodType<
+  OneIn$Outbound,
+  z.ZodTypeDef,
+  OneIn
+> = z.union([z.string(), z.number(), z.boolean()]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OneIn$ {
+  /** @deprecated use `OneIn$inboundSchema` instead. */
+  export const inboundSchema = OneIn$inboundSchema;
+  /** @deprecated use `OneIn$outboundSchema` instead. */
+  export const outboundSchema = OneIn$outboundSchema;
+  /** @deprecated use `OneIn$Outbound` instead. */
+  export type Outbound = OneIn$Outbound;
+}
+
+export function oneInToJSON(oneIn: OneIn): string {
+  return JSON.stringify(OneIn$outboundSchema.parse(oneIn));
+}
+
+export function oneInFromJSON(
+  jsonString: string,
+): SafeParseResult<OneIn, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => OneIn$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OneIn' from JSON`,
+  );
+}
+
+/** @internal */
+export const In$inboundSchema: z.ZodType<In, z.ZodTypeDef, unknown> = z.object({
+  in: z.array(z.union([z.string(), z.number(), z.boolean()])),
+});
+
+/** @internal */
+export type In$Outbound = {
+  in: Array<string | number | boolean>;
+};
+
+/** @internal */
+export const In$outboundSchema: z.ZodType<In$Outbound, z.ZodTypeDef, In> = z
+  .object({
+    in: z.array(z.union([z.string(), z.number(), z.boolean()])),
+  });
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace In$ {
+  /** @deprecated use `In$inboundSchema` instead. */
+  export const inboundSchema = In$inboundSchema;
+  /** @deprecated use `In$outboundSchema` instead. */
+  export const outboundSchema = In$outboundSchema;
+  /** @deprecated use `In$Outbound` instead. */
+  export type Outbound = In$Outbound;
+}
+
+export function inToJSON(value: In): string {
+  return JSON.stringify(In$outboundSchema.parse(value));
+}
+
+export function inFromJSON(
+  jsonString: string,
+): SafeParseResult<In, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => In$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'In' from JSON`,
+  );
+}
+
+/** @internal */
+export const Lte$inboundSchema: z.ZodType<Lte, z.ZodTypeDef, unknown> = z
+  .object({
+    lte: z.number(),
+  });
+
+/** @internal */
+export type Lte$Outbound = {
+  lte: number;
+};
+
+/** @internal */
+export const Lte$outboundSchema: z.ZodType<Lte$Outbound, z.ZodTypeDef, Lte> = z
+  .object({
+    lte: z.number(),
+  });
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Lte$ {
+  /** @deprecated use `Lte$inboundSchema` instead. */
+  export const inboundSchema = Lte$inboundSchema;
+  /** @deprecated use `Lte$outboundSchema` instead. */
+  export const outboundSchema = Lte$outboundSchema;
+  /** @deprecated use `Lte$Outbound` instead. */
+  export type Outbound = Lte$Outbound;
+}
+
+export function lteToJSON(lte: Lte): string {
+  return JSON.stringify(Lte$outboundSchema.parse(lte));
+}
+
+export function lteFromJSON(
+  jsonString: string,
+): SafeParseResult<Lte, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Lte$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Lte' from JSON`,
+  );
+}
+
+/** @internal */
+export const Lt$inboundSchema: z.ZodType<Lt, z.ZodTypeDef, unknown> = z.object({
+  lt: z.number(),
+});
+
+/** @internal */
+export type Lt$Outbound = {
+  lt: number;
+};
+
+/** @internal */
+export const Lt$outboundSchema: z.ZodType<Lt$Outbound, z.ZodTypeDef, Lt> = z
+  .object({
+    lt: z.number(),
+  });
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Lt$ {
+  /** @deprecated use `Lt$inboundSchema` instead. */
+  export const inboundSchema = Lt$inboundSchema;
+  /** @deprecated use `Lt$outboundSchema` instead. */
+  export const outboundSchema = Lt$outboundSchema;
+  /** @deprecated use `Lt$Outbound` instead. */
+  export type Outbound = Lt$Outbound;
+}
+
+export function ltToJSON(lt: Lt): string {
+  return JSON.stringify(Lt$outboundSchema.parse(lt));
+}
+
+export function ltFromJSON(
+  jsonString: string,
+): SafeParseResult<Lt, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Lt$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Lt' from JSON`,
+  );
+}
+
+/** @internal */
+export const Gte$inboundSchema: z.ZodType<Gte, z.ZodTypeDef, unknown> = z
+  .object({
+    gte: z.number(),
+  });
+
+/** @internal */
+export type Gte$Outbound = {
+  gte: number;
+};
+
+/** @internal */
+export const Gte$outboundSchema: z.ZodType<Gte$Outbound, z.ZodTypeDef, Gte> = z
+  .object({
+    gte: z.number(),
+  });
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Gte$ {
+  /** @deprecated use `Gte$inboundSchema` instead. */
+  export const inboundSchema = Gte$inboundSchema;
+  /** @deprecated use `Gte$outboundSchema` instead. */
+  export const outboundSchema = Gte$outboundSchema;
+  /** @deprecated use `Gte$Outbound` instead. */
+  export type Outbound = Gte$Outbound;
+}
+
+export function gteToJSON(gte: Gte): string {
+  return JSON.stringify(Gte$outboundSchema.parse(gte));
+}
+
+export function gteFromJSON(
+  jsonString: string,
+): SafeParseResult<Gte, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Gte$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Gte' from JSON`,
+  );
+}
+
+/** @internal */
+export const One3$inboundSchema: z.ZodType<One3, z.ZodTypeDef, unknown> = z
+  .object({
+    gt: z.number(),
+  });
+
+/** @internal */
+export type One3$Outbound = {
+  gt: number;
+};
+
+/** @internal */
+export const One3$outboundSchema: z.ZodType<One3$Outbound, z.ZodTypeDef, One3> =
+  z.object({
+    gt: z.number(),
+  });
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace One3$ {
+  /** @deprecated use `One3$inboundSchema` instead. */
+  export const inboundSchema = One3$inboundSchema;
+  /** @deprecated use `One3$outboundSchema` instead. */
+  export const outboundSchema = One3$outboundSchema;
+  /** @deprecated use `One3$Outbound` instead. */
+  export type Outbound = One3$Outbound;
+}
+
+export function one3ToJSON(one3: One3): string {
+  return JSON.stringify(One3$outboundSchema.parse(one3));
+}
+
+export function one3FromJSON(
+  jsonString: string,
+): SafeParseResult<One3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => One3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'One3' from JSON`,
+  );
+}
+
+/** @internal */
+export const OneNe$inboundSchema: z.ZodType<OneNe, z.ZodTypeDef, unknown> = z
+  .union([z.string(), z.number(), z.boolean()]);
+
+/** @internal */
+export type OneNe$Outbound = string | number | boolean;
+
+/** @internal */
+export const OneNe$outboundSchema: z.ZodType<
+  OneNe$Outbound,
+  z.ZodTypeDef,
+  OneNe
+> = z.union([z.string(), z.number(), z.boolean()]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OneNe$ {
+  /** @deprecated use `OneNe$inboundSchema` instead. */
+  export const inboundSchema = OneNe$inboundSchema;
+  /** @deprecated use `OneNe$outboundSchema` instead. */
+  export const outboundSchema = OneNe$outboundSchema;
+  /** @deprecated use `OneNe$Outbound` instead. */
+  export type Outbound = OneNe$Outbound;
+}
+
+export function oneNeToJSON(oneNe: OneNe): string {
+  return JSON.stringify(OneNe$outboundSchema.parse(oneNe));
+}
+
+export function oneNeFromJSON(
+  jsonString: string,
+): SafeParseResult<OneNe, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => OneNe$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OneNe' from JSON`,
+  );
+}
+
+/** @internal */
+export const Ne$inboundSchema: z.ZodType<Ne, z.ZodTypeDef, unknown> = z.object({
+  ne: z.union([z.string(), z.number(), z.boolean()]),
+});
+
+/** @internal */
+export type Ne$Outbound = {
+  ne: string | number | boolean;
+};
+
+/** @internal */
+export const Ne$outboundSchema: z.ZodType<Ne$Outbound, z.ZodTypeDef, Ne> = z
+  .object({
+    ne: z.union([z.string(), z.number(), z.boolean()]),
+  });
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Ne$ {
+  /** @deprecated use `Ne$inboundSchema` instead. */
+  export const inboundSchema = Ne$inboundSchema;
+  /** @deprecated use `Ne$outboundSchema` instead. */
+  export const outboundSchema = Ne$outboundSchema;
+  /** @deprecated use `Ne$Outbound` instead. */
+  export type Outbound = Ne$Outbound;
+}
+
+export function neToJSON(ne: Ne): string {
+  return JSON.stringify(Ne$outboundSchema.parse(ne));
+}
+
+export function neFromJSON(
+  jsonString: string,
+): SafeParseResult<Ne, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Ne$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Ne' from JSON`,
+  );
+}
+
+/** @internal */
+export const OneEq$inboundSchema: z.ZodType<OneEq, z.ZodTypeDef, unknown> = z
+  .union([z.string(), z.number(), z.boolean()]);
+
+/** @internal */
+export type OneEq$Outbound = string | number | boolean;
+
+/** @internal */
+export const OneEq$outboundSchema: z.ZodType<
+  OneEq$Outbound,
+  z.ZodTypeDef,
+  OneEq
+> = z.union([z.string(), z.number(), z.boolean()]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OneEq$ {
+  /** @deprecated use `OneEq$inboundSchema` instead. */
+  export const inboundSchema = OneEq$inboundSchema;
+  /** @deprecated use `OneEq$outboundSchema` instead. */
+  export const outboundSchema = OneEq$outboundSchema;
+  /** @deprecated use `OneEq$Outbound` instead. */
+  export type Outbound = OneEq$Outbound;
+}
+
+export function oneEqToJSON(oneEq: OneEq): string {
+  return JSON.stringify(OneEq$outboundSchema.parse(oneEq));
+}
+
+export function oneEqFromJSON(
+  jsonString: string,
+): SafeParseResult<OneEq, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => OneEq$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OneEq' from JSON`,
+  );
+}
+
+/** @internal */
+export const Eq$inboundSchema: z.ZodType<Eq, z.ZodTypeDef, unknown> = z.object({
+  eq: z.union([z.string(), z.number(), z.boolean()]),
+});
+
+/** @internal */
+export type Eq$Outbound = {
+  eq: string | number | boolean;
+};
+
+/** @internal */
+export const Eq$outboundSchema: z.ZodType<Eq$Outbound, z.ZodTypeDef, Eq> = z
+  .object({
+    eq: z.union([z.string(), z.number(), z.boolean()]),
+  });
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Eq$ {
+  /** @deprecated use `Eq$inboundSchema` instead. */
+  export const inboundSchema = Eq$inboundSchema;
+  /** @deprecated use `Eq$outboundSchema` instead. */
+  export const outboundSchema = Eq$outboundSchema;
+  /** @deprecated use `Eq$Outbound` instead. */
+  export type Outbound = Eq$Outbound;
+}
+
+export function eqToJSON(eq: Eq): string {
+  return JSON.stringify(Eq$outboundSchema.parse(eq));
+}
+
+export function eqFromJSON(
+  jsonString: string,
+): SafeParseResult<Eq, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Eq$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Eq' from JSON`,
+  );
+}
+
+/** @internal */
+export const KnowledgeFilter1$inboundSchema: z.ZodType<
+  KnowledgeFilter1,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => Eq$inboundSchema),
+  z.lazy(() => Ne$inboundSchema),
+  z.lazy(() => One3$inboundSchema),
+  z.lazy(() => Gte$inboundSchema),
+  z.lazy(() => Lt$inboundSchema),
+  z.lazy(() => Lte$inboundSchema),
+  z.lazy(() => In$inboundSchema),
+  z.lazy(() => Nin$inboundSchema),
+  z.lazy(() => Exists$inboundSchema),
+]);
+
+/** @internal */
+export type KnowledgeFilter1$Outbound =
+  | Eq$Outbound
+  | Ne$Outbound
+  | One3$Outbound
+  | Gte$Outbound
+  | Lt$Outbound
+  | Lte$Outbound
+  | In$Outbound
+  | Nin$Outbound
+  | Exists$Outbound;
+
+/** @internal */
+export const KnowledgeFilter1$outboundSchema: z.ZodType<
+  KnowledgeFilter1$Outbound,
+  z.ZodTypeDef,
+  KnowledgeFilter1
+> = z.union([
+  z.lazy(() => Eq$outboundSchema),
+  z.lazy(() => Ne$outboundSchema),
+  z.lazy(() => One3$outboundSchema),
+  z.lazy(() => Gte$outboundSchema),
+  z.lazy(() => Lt$outboundSchema),
+  z.lazy(() => Lte$outboundSchema),
+  z.lazy(() => In$outboundSchema),
+  z.lazy(() => Nin$outboundSchema),
+  z.lazy(() => Exists$outboundSchema),
+]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace KnowledgeFilter1$ {
+  /** @deprecated use `KnowledgeFilter1$inboundSchema` instead. */
+  export const inboundSchema = KnowledgeFilter1$inboundSchema;
+  /** @deprecated use `KnowledgeFilter1$outboundSchema` instead. */
+  export const outboundSchema = KnowledgeFilter1$outboundSchema;
+  /** @deprecated use `KnowledgeFilter1$Outbound` instead. */
+  export type Outbound = KnowledgeFilter1$Outbound;
+}
+
+export function knowledgeFilter1ToJSON(
+  knowledgeFilter1: KnowledgeFilter1,
+): string {
+  return JSON.stringify(
+    KnowledgeFilter1$outboundSchema.parse(knowledgeFilter1),
+  );
+}
+
+export function knowledgeFilter1FromJSON(
+  jsonString: string,
+): SafeParseResult<KnowledgeFilter1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => KnowledgeFilter1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'KnowledgeFilter1' from JSON`,
+  );
+}
+
+/** @internal */
+export const KnowledgeFilter$inboundSchema: z.ZodType<
+  KnowledgeFilter,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => And$inboundSchema),
+  z.lazy(() => Or$inboundSchema),
+  z.record(z.union([
+    z.lazy(() => Eq$inboundSchema),
+    z.lazy(() => Ne$inboundSchema),
+    z.lazy(() => One3$inboundSchema),
+    z.lazy(() => Gte$inboundSchema),
+    z.lazy(() => Lt$inboundSchema),
+    z.lazy(() => Lte$inboundSchema),
+    z.lazy(() => In$inboundSchema),
+    z.lazy(() => Nin$inboundSchema),
+    z.lazy(() => Exists$inboundSchema),
+  ])),
+]);
+
+/** @internal */
+export type KnowledgeFilter$Outbound = And$Outbound | Or$Outbound | {
+  [k: string]:
+    | Eq$Outbound
+    | Ne$Outbound
+    | One3$Outbound
+    | Gte$Outbound
+    | Lt$Outbound
+    | Lte$Outbound
+    | In$Outbound
+    | Nin$Outbound
+    | Exists$Outbound;
+};
+
+/** @internal */
+export const KnowledgeFilter$outboundSchema: z.ZodType<
+  KnowledgeFilter$Outbound,
+  z.ZodTypeDef,
+  KnowledgeFilter
+> = z.union([
+  z.lazy(() => And$outboundSchema),
+  z.lazy(() => Or$outboundSchema),
+  z.record(z.union([
+    z.lazy(() => Eq$outboundSchema),
+    z.lazy(() => Ne$outboundSchema),
+    z.lazy(() => One3$outboundSchema),
+    z.lazy(() => Gte$outboundSchema),
+    z.lazy(() => Lt$outboundSchema),
+    z.lazy(() => Lte$outboundSchema),
+    z.lazy(() => In$outboundSchema),
+    z.lazy(() => Nin$outboundSchema),
+    z.lazy(() => Exists$outboundSchema),
+  ])),
+]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace KnowledgeFilter$ {
+  /** @deprecated use `KnowledgeFilter$inboundSchema` instead. */
+  export const inboundSchema = KnowledgeFilter$inboundSchema;
+  /** @deprecated use `KnowledgeFilter$outboundSchema` instead. */
+  export const outboundSchema = KnowledgeFilter$outboundSchema;
+  /** @deprecated use `KnowledgeFilter$Outbound` instead. */
+  export type Outbound = KnowledgeFilter$Outbound;
+}
+
+export function knowledgeFilterToJSON(
+  knowledgeFilter: KnowledgeFilter,
+): string {
+  return JSON.stringify(KnowledgeFilter$outboundSchema.parse(knowledgeFilter));
+}
+
+export function knowledgeFilterFromJSON(
+  jsonString: string,
+): SafeParseResult<KnowledgeFilter, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => KnowledgeFilter$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'KnowledgeFilter' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentGetConfigRequestBody$inboundSchema: z.ZodType<
+  DeploymentGetConfigRequestBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  key: z.string(),
+  inputs: z.record(z.union([z.string(), z.number(), z.boolean()])).optional(),
+  context: z.record(z.any()).optional(),
+  prefix_messages: z.array(
+    z.union([
+      z.lazy(() => DeveloperMessage$inboundSchema),
+      z.lazy(() => SystemMessage$inboundSchema),
+      z.lazy(() => UserMessage$inboundSchema),
+      z.lazy(() => ToolMessage$inboundSchema),
+      z.lazy(() => AssistantMessage$inboundSchema),
+    ]),
+  ).optional(),
+  messages: z.array(
+    z.union([
+      z.lazy(() => MessagesDeveloperMessage$inboundSchema),
+      z.lazy(() => MessagesSystemMessage$inboundSchema),
+      z.lazy(() => MessagesUserMessage$inboundSchema),
+      z.lazy(() => MessagesToolMessage$inboundSchema),
+      z.lazy(() => MessagesAssistantMessage$inboundSchema),
+    ]),
+  ).optional(),
+  file_ids: z.array(z.string()).optional(),
+  metadata: z.record(z.any()).optional(),
+  extra_params: z.record(z.any()).optional(),
+  documents: z.array(z.lazy(() => Documents$inboundSchema)).optional(),
+  invoke_options: z.lazy(() => InvokeOptions$inboundSchema).optional(),
+  thread: z.lazy(() => Thread$inboundSchema).optional(),
+  knowledge_filter: z.union([
+    z.lazy(() => And$inboundSchema),
+    z.lazy(() => Or$inboundSchema),
+    z.record(z.union([
+      z.lazy(() => Eq$inboundSchema),
+      z.lazy(() => Ne$inboundSchema),
+      z.lazy(() => One3$inboundSchema),
+      z.lazy(() => Gte$inboundSchema),
+      z.lazy(() => Lt$inboundSchema),
+      z.lazy(() => Lte$inboundSchema),
+      z.lazy(() => In$inboundSchema),
+      z.lazy(() => Nin$inboundSchema),
+      z.lazy(() => Exists$inboundSchema),
+    ])),
+  ]).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "prefix_messages": "prefixMessages",
+    "file_ids": "fileIds",
+    "extra_params": "extraParams",
+    "invoke_options": "invokeOptions",
+    "knowledge_filter": "knowledgeFilter",
+  });
+});
+
+/** @internal */
+export type DeploymentGetConfigRequestBody$Outbound = {
+  key: string;
+  inputs?: { [k: string]: string | number | boolean } | undefined;
+  context?: { [k: string]: any } | undefined;
+  prefix_messages?:
+    | Array<
+      | DeveloperMessage$Outbound
+      | SystemMessage$Outbound
+      | UserMessage$Outbound
+      | ToolMessage$Outbound
+      | AssistantMessage$Outbound
+    >
+    | undefined;
+  messages?:
+    | Array<
+      | MessagesDeveloperMessage$Outbound
+      | MessagesSystemMessage$Outbound
+      | MessagesUserMessage$Outbound
+      | MessagesToolMessage$Outbound
+      | MessagesAssistantMessage$Outbound
+    >
+    | undefined;
+  file_ids?: Array<string> | undefined;
+  metadata?: { [k: string]: any } | undefined;
+  extra_params?: { [k: string]: any } | undefined;
+  documents?: Array<Documents$Outbound> | undefined;
+  invoke_options?: InvokeOptions$Outbound | undefined;
+  thread?: Thread$Outbound | undefined;
+  knowledge_filter?: And$Outbound | Or$Outbound | {
+    [k: string]:
+      | Eq$Outbound
+      | Ne$Outbound
+      | One3$Outbound
+      | Gte$Outbound
+      | Lt$Outbound
+      | Lte$Outbound
+      | In$Outbound
+      | Nin$Outbound
+      | Exists$Outbound;
+  } | undefined;
+};
+
+/** @internal */
+export const DeploymentGetConfigRequestBody$outboundSchema: z.ZodType<
+  DeploymentGetConfigRequestBody$Outbound,
+  z.ZodTypeDef,
+  DeploymentGetConfigRequestBody
+> = z.object({
+  key: z.string(),
+  inputs: z.record(z.union([z.string(), z.number(), z.boolean()])).optional(),
+  context: z.record(z.any()).optional(),
+  prefixMessages: z.array(
+    z.union([
+      z.lazy(() => DeveloperMessage$outboundSchema),
+      z.lazy(() => SystemMessage$outboundSchema),
+      z.lazy(() => UserMessage$outboundSchema),
+      z.lazy(() => ToolMessage$outboundSchema),
+      z.lazy(() => AssistantMessage$outboundSchema),
+    ]),
+  ).optional(),
+  messages: z.array(
+    z.union([
+      z.lazy(() => MessagesDeveloperMessage$outboundSchema),
+      z.lazy(() => MessagesSystemMessage$outboundSchema),
+      z.lazy(() => MessagesUserMessage$outboundSchema),
+      z.lazy(() => MessagesToolMessage$outboundSchema),
+      z.lazy(() => MessagesAssistantMessage$outboundSchema),
+    ]),
+  ).optional(),
+  fileIds: z.array(z.string()).optional(),
+  metadata: z.record(z.any()).optional(),
+  extraParams: z.record(z.any()).optional(),
+  documents: z.array(z.lazy(() => Documents$outboundSchema)).optional(),
+  invokeOptions: z.lazy(() => InvokeOptions$outboundSchema).optional(),
+  thread: z.lazy(() => Thread$outboundSchema).optional(),
+  knowledgeFilter: z.union([
+    z.lazy(() => And$outboundSchema),
+    z.lazy(() => Or$outboundSchema),
+    z.record(z.union([
+      z.lazy(() => Eq$outboundSchema),
+      z.lazy(() => Ne$outboundSchema),
+      z.lazy(() => One3$outboundSchema),
+      z.lazy(() => Gte$outboundSchema),
+      z.lazy(() => Lt$outboundSchema),
+      z.lazy(() => Lte$outboundSchema),
+      z.lazy(() => In$outboundSchema),
+      z.lazy(() => Nin$outboundSchema),
+      z.lazy(() => Exists$outboundSchema),
+    ])),
+  ]).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    prefixMessages: "prefix_messages",
+    fileIds: "file_ids",
+    extraParams: "extra_params",
     invokeOptions: "invoke_options",
+    knowledgeFilter: "knowledge_filter",
   });
 });
 
@@ -5235,6 +7873,158 @@ export namespace DeploymentGetConfigRole$ {
   export const outboundSchema = DeploymentGetConfigRole$outboundSchema;
 }
 
+/** @internal */
+export const DeploymentGetConfig2DeploymentsResponse200ApplicationJSONType$inboundSchema:
+  z.ZodNativeEnum<
+    typeof DeploymentGetConfig2DeploymentsResponse200ApplicationJSONType
+  > = z.nativeEnum(
+    DeploymentGetConfig2DeploymentsResponse200ApplicationJSONType,
+  );
+
+/** @internal */
+export const DeploymentGetConfig2DeploymentsResponse200ApplicationJSONType$outboundSchema:
+  z.ZodNativeEnum<
+    typeof DeploymentGetConfig2DeploymentsResponse200ApplicationJSONType
+  > =
+    DeploymentGetConfig2DeploymentsResponse200ApplicationJSONType$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace DeploymentGetConfig2DeploymentsResponse200ApplicationJSONType$ {
+  /** @deprecated use `DeploymentGetConfig2DeploymentsResponse200ApplicationJSONType$inboundSchema` instead. */
+  export const inboundSchema =
+    DeploymentGetConfig2DeploymentsResponse200ApplicationJSONType$inboundSchema;
+  /** @deprecated use `DeploymentGetConfig2DeploymentsResponse200ApplicationJSONType$outboundSchema` instead. */
+  export const outboundSchema =
+    DeploymentGetConfig2DeploymentsResponse200ApplicationJSONType$outboundSchema;
+}
+
+/** @internal */
+export const DeploymentGetConfig2File$inboundSchema: z.ZodType<
+  DeploymentGetConfig2File,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  file_data: z.string(),
+  filename: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "file_data": "fileData",
+  });
+});
+
+/** @internal */
+export type DeploymentGetConfig2File$Outbound = {
+  file_data: string;
+  filename?: string | undefined;
+};
+
+/** @internal */
+export const DeploymentGetConfig2File$outboundSchema: z.ZodType<
+  DeploymentGetConfig2File$Outbound,
+  z.ZodTypeDef,
+  DeploymentGetConfig2File
+> = z.object({
+  fileData: z.string(),
+  filename: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    fileData: "file_data",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace DeploymentGetConfig2File$ {
+  /** @deprecated use `DeploymentGetConfig2File$inboundSchema` instead. */
+  export const inboundSchema = DeploymentGetConfig2File$inboundSchema;
+  /** @deprecated use `DeploymentGetConfig2File$outboundSchema` instead. */
+  export const outboundSchema = DeploymentGetConfig2File$outboundSchema;
+  /** @deprecated use `DeploymentGetConfig2File$Outbound` instead. */
+  export type Outbound = DeploymentGetConfig2File$Outbound;
+}
+
+export function deploymentGetConfig2FileToJSON(
+  deploymentGetConfig2File: DeploymentGetConfig2File,
+): string {
+  return JSON.stringify(
+    DeploymentGetConfig2File$outboundSchema.parse(deploymentGetConfig2File),
+  );
+}
+
+export function deploymentGetConfig2FileFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentGetConfig2File, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentGetConfig2File$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentGetConfig2File' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeploymentGetConfig23$inboundSchema: z.ZodType<
+  DeploymentGetConfig23,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type:
+    DeploymentGetConfig2DeploymentsResponse200ApplicationJSONType$inboundSchema,
+  file: z.lazy(() => DeploymentGetConfig2File$inboundSchema),
+});
+
+/** @internal */
+export type DeploymentGetConfig23$Outbound = {
+  type: string;
+  file: DeploymentGetConfig2File$Outbound;
+};
+
+/** @internal */
+export const DeploymentGetConfig23$outboundSchema: z.ZodType<
+  DeploymentGetConfig23$Outbound,
+  z.ZodTypeDef,
+  DeploymentGetConfig23
+> = z.object({
+  type:
+    DeploymentGetConfig2DeploymentsResponse200ApplicationJSONType$outboundSchema,
+  file: z.lazy(() => DeploymentGetConfig2File$outboundSchema),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace DeploymentGetConfig23$ {
+  /** @deprecated use `DeploymentGetConfig23$inboundSchema` instead. */
+  export const inboundSchema = DeploymentGetConfig23$inboundSchema;
+  /** @deprecated use `DeploymentGetConfig23$outboundSchema` instead. */
+  export const outboundSchema = DeploymentGetConfig23$outboundSchema;
+  /** @deprecated use `DeploymentGetConfig23$Outbound` instead. */
+  export type Outbound = DeploymentGetConfig23$Outbound;
+}
+
+export function deploymentGetConfig23ToJSON(
+  deploymentGetConfig23: DeploymentGetConfig23,
+): string {
+  return JSON.stringify(
+    DeploymentGetConfig23$outboundSchema.parse(deploymentGetConfig23),
+  );
+}
+
+export function deploymentGetConfig23FromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentGetConfig23, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentGetConfig23$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentGetConfig23' from JSON`,
+  );
+}
+
 /** @internal */
 export const DeploymentGetConfig2DeploymentsResponse200Type$inboundSchema:
   z.ZodNativeEnum<typeof DeploymentGetConfig2DeploymentsResponse200Type> = z
@@ -5476,12 +8266,14 @@ export const DeploymentGetConfigContentDeploymentsResponse2$inboundSchema:
   > = z.union([
     z.lazy(() => DeploymentGetConfig21$inboundSchema),
     z.lazy(() => DeploymentGetConfig2Deployments2$inboundSchema),
+    z.lazy(() => DeploymentGetConfig23$inboundSchema),
   ]);
 
 /** @internal */
 export type DeploymentGetConfigContentDeploymentsResponse2$Outbound =
   | DeploymentGetConfig21$Outbound
-  | DeploymentGetConfig2Deployments2$Outbound;
+  | DeploymentGetConfig2Deployments2$Outbound
+  | DeploymentGetConfig23$Outbound;
 
 /** @internal */
 export const DeploymentGetConfigContentDeploymentsResponse2$outboundSchema:
@@ -5492,6 +8284,7 @@ export const DeploymentGetConfigContentDeploymentsResponse2$outboundSchema:
   > = z.union([
     z.lazy(() => DeploymentGetConfig21$outboundSchema),
     z.lazy(() => DeploymentGetConfig2Deployments2$outboundSchema),
+    z.lazy(() => DeploymentGetConfig23$outboundSchema),
   ]);
 
 /**
@@ -5547,6 +8340,7 @@ export const DeploymentGetConfigContent$inboundSchema: z.ZodType<
   z.array(z.union([
     z.lazy(() => DeploymentGetConfig21$inboundSchema),
     z.lazy(() => DeploymentGetConfig2Deployments2$inboundSchema),
+    z.lazy(() => DeploymentGetConfig23$inboundSchema),
   ])),
 ]);
 
@@ -5554,7 +8348,9 @@ export const DeploymentGetConfigContent$inboundSchema: z.ZodType<
 export type DeploymentGetConfigContent$Outbound =
   | string
   | Array<
-    DeploymentGetConfig21$Outbound | DeploymentGetConfig2Deployments2$Outbound
+    | DeploymentGetConfig21$Outbound
+    | DeploymentGetConfig2Deployments2$Outbound
+    | DeploymentGetConfig23$Outbound
   >;
 
 /** @internal */
@@ -5567,6 +8363,7 @@ export const DeploymentGetConfigContent$outboundSchema: z.ZodType<
   z.array(z.union([
     z.lazy(() => DeploymentGetConfig21$outboundSchema),
     z.lazy(() => DeploymentGetConfig2Deployments2$outboundSchema),
+    z.lazy(() => DeploymentGetConfig23$outboundSchema),
   ])),
 ]);
 
@@ -5764,6 +8561,7 @@ export const DeploymentGetConfigMessages$inboundSchema: z.ZodType<
     z.array(z.union([
       z.lazy(() => DeploymentGetConfig21$inboundSchema),
       z.lazy(() => DeploymentGetConfig2Deployments2$inboundSchema),
+      z.lazy(() => DeploymentGetConfig23$inboundSchema),
     ])),
   ]),
   tool_calls: z.array(z.lazy(() => DeploymentGetConfigToolCalls$inboundSchema))
@@ -5782,7 +8580,9 @@ export type DeploymentGetConfigMessages$Outbound = {
   content:
     | string
     | Array<
-      DeploymentGetConfig21$Outbound | DeploymentGetConfig2Deployments2$Outbound
+      | DeploymentGetConfig21$Outbound
+      | DeploymentGetConfig2Deployments2$Outbound
+      | DeploymentGetConfig23$Outbound
     >;
   tool_calls?: Array<DeploymentGetConfigToolCalls$Outbound> | undefined;
   tool_call_id?: string | undefined;
@@ -5800,6 +8600,7 @@ export const DeploymentGetConfigMessages$outboundSchema: z.ZodType<
     z.array(z.union([
       z.lazy(() => DeploymentGetConfig21$outboundSchema),
       z.lazy(() => DeploymentGetConfig2Deployments2$outboundSchema),
+      z.lazy(() => DeploymentGetConfig23$outboundSchema),
     ])),
   ]),
   toolCalls: z.array(z.lazy(() => DeploymentGetConfigToolCalls$outboundSchema))