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

package/src/models/components/deployments.ts

@@ -274,7 +274,7 @@ export type InputAudio = {
   format: Format;
 };
 
-export type Three = {
+export type Deployments23 = {
   type: Deployments2Type;
   inputAudio: InputAudio;
 };
@@ -320,17 +320,19 @@ export type Deployments2PrefixMessages3Type = ClosedEnum<
   typeof Deployments2PrefixMessages3Type
 >;
 
-export type One = {
+export type Deployments21 = {
   type: Deployments2PrefixMessages3Type;
   text: string;
 };
 
-export type Two = One | Two2 | Three | Four;
+export type Two = Deployments21 | Two2 | Deployments23 | Four;
 
 /**
  * The contents of the user message.
  */
-export type Content = string | Array<One | Two2 | Three | Four>;
+export type Content =
+  | string
+  | Array<Deployments21 | Two2 | Deployments23 | Four>;
 
 export type UserMessage = {
   /**
@@ -344,7 +346,7 @@ export type UserMessage = {
   /**
    * The contents of the user message.
    */
-  content: string | Array<One | Two2 | Three | Four>;
+  content: string | Array<Deployments21 | Two2 | Deployments23 | Four>;
 };
 
 /**
@@ -862,6 +864,290 @@ export type Thread = {
   tags?: Array<string> | undefined;
 };
 
+/**
+ * Exists
+ */
+export type OrExists = {
+  exists: boolean;
+};
+
+export type OrNin = string | number | boolean;
+
+/**
+ * Not in
+ */
+export type DeploymentsOrNin = {
+  nin: Array<string | number | boolean>;
+};
+
+export type OrIn = string | number | boolean;
+
+/**
+ * In
+ */
+export type DeploymentsOrIn = {
+  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 OrNe = string | number | boolean;
+
+/**
+ * Not equal to
+ */
+export type DeploymentsOrNe = {
+  ne: string | number | boolean;
+};
+
+export type OrEq = string | number | boolean;
+
+/**
+ * Equal to
+ */
+export type DeploymentsOrEq = {
+  eq: string | number | boolean;
+};
+
+export type Or =
+  | DeploymentsOrEq
+  | DeploymentsOrNe
+  | Or3
+  | OrGte
+  | OrLt
+  | OrLte
+  | DeploymentsOrIn
+  | DeploymentsOrNin
+  | OrExists;
+
+/**
+ * Or
+ */
+export type KnowledgeFilterOr = {
+  or: Array<
+    {
+      [k: string]:
+        | DeploymentsOrEq
+        | DeploymentsOrNe
+        | Or3
+        | OrGte
+        | OrLt
+        | OrLte
+        | DeploymentsOrIn
+        | DeploymentsOrNin
+        | OrExists;
+    }
+  >;
+};
+
+/**
+ * Exists
+ */
+export type AndExists = {
+  exists: boolean;
+};
+
+export type AndNin = string | number | boolean;
+
+/**
+ * Not in
+ */
+export type DeploymentsAndNin = {
+  nin: Array<string | number | boolean>;
+};
+
+export type AndIn = string | number | boolean;
+
+/**
+ * In
+ */
+export type DeploymentsAndIn = {
+  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 AndNe = string | number | boolean;
+
+/**
+ * Not equal to
+ */
+export type DeploymentsAndNe = {
+  ne: string | number | boolean;
+};
+
+export type AndEq = string | number | boolean;
+
+/**
+ * Equal to
+ */
+export type DeploymentsAndEq = {
+  eq: string | number | boolean;
+};
+
+export type And =
+  | DeploymentsAndEq
+  | DeploymentsAndNe
+  | And3
+  | AndGte
+  | AndLt
+  | AndLte
+  | DeploymentsAndIn
+  | DeploymentsAndNin
+  | AndExists;
+
+/**
+ * And
+ */
+export type KnowledgeFilterAnd = {
+  and: Array<
+    {
+      [k: string]:
+        | DeploymentsAndEq
+        | DeploymentsAndNe
+        | And3
+        | AndGte
+        | AndLt
+        | AndLte
+        | DeploymentsAndIn
+        | DeploymentsAndNin
+        | AndExists;
+    }
+  >;
+};
+
+/**
+ * Exists
+ */
+export type Exists = {
+  exists: boolean;
+};
+
+export type Nin = string | number | boolean;
+
+/**
+ * Not in
+ */
+export type OneNin = {
+  nin: Array<string | number | boolean>;
+};
+
+export type In = string | number | boolean;
+
+/**
+ * In
+ */
+export type OneIn = {
+  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 Three = {
+  gt: number;
+};
+
+export type Ne = string | number | boolean;
+
+/**
+ * Not equal to
+ */
+export type OneNe = {
+  ne: string | number | boolean;
+};
+
+export type Eq = string | number | boolean;
+
+/**
+ * Equal to
+ */
+export type OneEq = {
+  eq: string | number | boolean;
+};
+
+export type One =
+  | OneEq
+  | OneNe
+  | Three
+  | Gte
+  | Lt
+  | Lte
+  | OneIn
+  | OneNin
+  | Exists;
+
+/**
+ * A filter to apply to the knowledge base chunk metadata when using  knowledge bases in the deployment.
+ */
+export type KnowledgeFilter = KnowledgeFilterAnd | KnowledgeFilterOr | {
+  [k: string]: OneEq | OneNe | Three | Gte | Lt | Lte | OneIn | OneNin | Exists;
+};
+
 /**
  * The deployment request payload
  */
@@ -920,6 +1206,21 @@ export type Deployments = {
   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?: KnowledgeFilterAnd | KnowledgeFilterOr | {
+    [k: string]:
+      | OneEq
+      | OneNe
+      | Three
+      | Gte
+      | Lt
+      | Lte
+      | OneIn
+      | OneNin
+      | Exists;
+  } | undefined;
 };
 
 /** @internal */
@@ -1919,27 +2220,30 @@ export function inputAudioFromJSON(
 }
 
 /** @internal */
-export const Three$inboundSchema: z.ZodType<Three, z.ZodTypeDef, unknown> = z
-  .object({
-    type: Deployments2Type$inboundSchema,
-    input_audio: z.lazy(() => InputAudio$inboundSchema),
-  }).transform((v) => {
-    return remap$(v, {
-      "input_audio": "inputAudio",
-    });
+export const Deployments23$inboundSchema: z.ZodType<
+  Deployments23,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: Deployments2Type$inboundSchema,
+  input_audio: z.lazy(() => InputAudio$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "input_audio": "inputAudio",
   });
+});
 
 /** @internal */
-export type Three$Outbound = {
+export type Deployments23$Outbound = {
   type: string;
   input_audio: InputAudio$Outbound;
 };
 
 /** @internal */
-export const Three$outboundSchema: z.ZodType<
-  Three$Outbound,
+export const Deployments23$outboundSchema: z.ZodType<
+  Deployments23$Outbound,
   z.ZodTypeDef,
-  Three
+  Deployments23
 > = z.object({
   type: Deployments2Type$outboundSchema,
   inputAudio: z.lazy(() => InputAudio$outboundSchema),
@@ -1953,26 +2257,26 @@ export const Three$outboundSchema: z.ZodType<
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace Three$ {
-  /** @deprecated use `Three$inboundSchema` instead. */
-  export const inboundSchema = Three$inboundSchema;
-  /** @deprecated use `Three$outboundSchema` instead. */
-  export const outboundSchema = Three$outboundSchema;
-  /** @deprecated use `Three$Outbound` instead. */
-  export type Outbound = Three$Outbound;
+export namespace Deployments23$ {
+  /** @deprecated use `Deployments23$inboundSchema` instead. */
+  export const inboundSchema = Deployments23$inboundSchema;
+  /** @deprecated use `Deployments23$outboundSchema` instead. */
+  export const outboundSchema = Deployments23$outboundSchema;
+  /** @deprecated use `Deployments23$Outbound` instead. */
+  export type Outbound = Deployments23$Outbound;
 }
 
-export function threeToJSON(three: Three): string {
-  return JSON.stringify(Three$outboundSchema.parse(three));
+export function deployments23ToJSON(deployments23: Deployments23): string {
+  return JSON.stringify(Deployments23$outboundSchema.parse(deployments23));
 }
 
-export function threeFromJSON(
+export function deployments23FromJSON(
   jsonString: string,
-): SafeParseResult<Three, SDKValidationError> {
+): SafeParseResult<Deployments23, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => Three$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Three' from JSON`,
+    (x) => Deployments23$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Deployments23' from JSON`,
   );
 }
 
@@ -2144,75 +2448,81 @@ export namespace Deployments2PrefixMessages3Type$ {
 }
 
 /** @internal */
-export const One$inboundSchema: z.ZodType<One, z.ZodTypeDef, unknown> = z
-  .object({
-    type: Deployments2PrefixMessages3Type$inboundSchema,
-    text: z.string(),
-  });
+export const Deployments21$inboundSchema: z.ZodType<
+  Deployments21,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: Deployments2PrefixMessages3Type$inboundSchema,
+  text: z.string(),
+});
 
 /** @internal */
-export type One$Outbound = {
+export type Deployments21$Outbound = {
   type: string;
   text: string;
 };
 
 /** @internal */
-export const One$outboundSchema: z.ZodType<One$Outbound, z.ZodTypeDef, One> = z
-  .object({
-    type: Deployments2PrefixMessages3Type$outboundSchema,
-    text: z.string(),
-  });
+export const Deployments21$outboundSchema: z.ZodType<
+  Deployments21$Outbound,
+  z.ZodTypeDef,
+  Deployments21
+> = z.object({
+  type: Deployments2PrefixMessages3Type$outboundSchema,
+  text: z.string(),
+});
 
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace One$ {
-  /** @deprecated use `One$inboundSchema` instead. */
-  export const inboundSchema = One$inboundSchema;
-  /** @deprecated use `One$outboundSchema` instead. */
-  export const outboundSchema = One$outboundSchema;
-  /** @deprecated use `One$Outbound` instead. */
-  export type Outbound = One$Outbound;
+export namespace Deployments21$ {
+  /** @deprecated use `Deployments21$inboundSchema` instead. */
+  export const inboundSchema = Deployments21$inboundSchema;
+  /** @deprecated use `Deployments21$outboundSchema` instead. */
+  export const outboundSchema = Deployments21$outboundSchema;
+  /** @deprecated use `Deployments21$Outbound` instead. */
+  export type Outbound = Deployments21$Outbound;
 }
 
-export function oneToJSON(one: One): string {
-  return JSON.stringify(One$outboundSchema.parse(one));
+export function deployments21ToJSON(deployments21: Deployments21): string {
+  return JSON.stringify(Deployments21$outboundSchema.parse(deployments21));
 }
 
-export function oneFromJSON(
+export function deployments21FromJSON(
   jsonString: string,
-): SafeParseResult<One, SDKValidationError> {
+): SafeParseResult<Deployments21, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => One$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'One' from JSON`,
+    (x) => Deployments21$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Deployments21' from JSON`,
   );
 }
 
 /** @internal */
 export const Two$inboundSchema: z.ZodType<Two, z.ZodTypeDef, unknown> = z.union(
   [
-    z.lazy(() => One$inboundSchema),
+    z.lazy(() => Deployments21$inboundSchema),
     z.lazy(() => Two2$inboundSchema),
-    z.lazy(() => Three$inboundSchema),
+    z.lazy(() => Deployments23$inboundSchema),
     z.lazy(() => Four$inboundSchema),
   ],
 );
 
 /** @internal */
 export type Two$Outbound =
-  | One$Outbound
+  | Deployments21$Outbound
   | Two2$Outbound
-  | Three$Outbound
+  | Deployments23$Outbound
   | Four$Outbound;
 
 /** @internal */
 export const Two$outboundSchema: z.ZodType<Two$Outbound, z.ZodTypeDef, Two> = z
   .union([
-    z.lazy(() => One$outboundSchema),
+    z.lazy(() => Deployments21$outboundSchema),
     z.lazy(() => Two2$outboundSchema),
-    z.lazy(() => Three$outboundSchema),
+    z.lazy(() => Deployments23$outboundSchema),
     z.lazy(() => Four$outboundSchema),
   ]);
 
@@ -2248,9 +2558,9 @@ export const Content$inboundSchema: z.ZodType<Content, z.ZodTypeDef, unknown> =
   z.union([
     z.string(),
     z.array(z.union([
-      z.lazy(() => One$inboundSchema),
+      z.lazy(() => Deployments21$inboundSchema),
       z.lazy(() => Two2$inboundSchema),
-      z.lazy(() => Three$inboundSchema),
+      z.lazy(() => Deployments23$inboundSchema),
       z.lazy(() => Four$inboundSchema),
     ])),
   ]);
@@ -2258,7 +2568,12 @@ export const Content$inboundSchema: z.ZodType<Content, z.ZodTypeDef, unknown> =
 /** @internal */
 export type Content$Outbound =
   | string
-  | Array<One$Outbound | Two2$Outbound | Three$Outbound | Four$Outbound>;
+  | Array<
+    | Deployments21$Outbound
+    | Two2$Outbound
+    | Deployments23$Outbound
+    | Four$Outbound
+  >;
 
 /** @internal */
 export const Content$outboundSchema: z.ZodType<
@@ -2268,9 +2583,9 @@ export const Content$outboundSchema: z.ZodType<
 > = z.union([
   z.string(),
   z.array(z.union([
-    z.lazy(() => One$outboundSchema),
+    z.lazy(() => Deployments21$outboundSchema),
     z.lazy(() => Two2$outboundSchema),
-    z.lazy(() => Three$outboundSchema),
+    z.lazy(() => Deployments23$outboundSchema),
     z.lazy(() => Four$outboundSchema),
   ])),
 ]);
@@ -2313,9 +2628,9 @@ export const UserMessage$inboundSchema: z.ZodType<
   content: z.union([
     z.string(),
     z.array(z.union([
-      z.lazy(() => One$inboundSchema),
+      z.lazy(() => Deployments21$inboundSchema),
       z.lazy(() => Two2$inboundSchema),
-      z.lazy(() => Three$inboundSchema),
+      z.lazy(() => Deployments23$inboundSchema),
       z.lazy(() => Four$inboundSchema),
     ])),
   ]),
@@ -2327,7 +2642,12 @@ export type UserMessage$Outbound = {
   name?: string | undefined;
   content:
     | string
-    | Array<One$Outbound | Two2$Outbound | Three$Outbound | Four$Outbound>;
+    | Array<
+      | Deployments21$Outbound
+      | Two2$Outbound
+      | Deployments23$Outbound
+      | Four$Outbound
+    >;
 };
 
 /** @internal */
@@ -2341,9 +2661,9 @@ export const UserMessage$outboundSchema: z.ZodType<
   content: z.union([
     z.string(),
     z.array(z.union([
-      z.lazy(() => One$outboundSchema),
+      z.lazy(() => Deployments21$outboundSchema),
       z.lazy(() => Two2$outboundSchema),
-      z.lazy(() => Three$outboundSchema),
+      z.lazy(() => Deployments23$outboundSchema),
       z.lazy(() => Four$outboundSchema),
     ])),
   ]),
@@ -4512,69 +4832,2352 @@ export function threadFromJSON(
 }
 
 /** @internal */
-export const Deployments$inboundSchema: z.ZodType<
-  Deployments,
+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 Deployments$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
-    >
+export type OrExists$Outbound = {
+  exists: boolean;
+};
+
+/** @internal */
+export const OrExists$outboundSchema: z.ZodType<
+  OrExists$Outbound,
+  z.ZodTypeDef,
+  OrExists
+> = 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 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 OrNin$inboundSchema: z.ZodType<OrNin, z.ZodTypeDef, unknown> = z
+  .union([z.string(), z.number(), z.boolean()]);
+
+/** @internal */
+export type OrNin$Outbound = string | number | boolean;
+
+/** @internal */
+export const OrNin$outboundSchema: z.ZodType<
+  OrNin$Outbound,
+  z.ZodTypeDef,
+  OrNin
+> = 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 DeploymentsOrNin$inboundSchema: z.ZodType<
+  DeploymentsOrNin,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  nin: z.array(z.union([z.string(), z.number(), z.boolean()])),
+});
+
+/** @internal */
+export type DeploymentsOrNin$Outbound = {
+  nin: Array<string | number | boolean>;
+};
+
+/** @internal */
+export const DeploymentsOrNin$outboundSchema: z.ZodType<
+  DeploymentsOrNin$Outbound,
+  z.ZodTypeDef,
+  DeploymentsOrNin
+> = 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 DeploymentsOrNin$ {
+  /** @deprecated use `DeploymentsOrNin$inboundSchema` instead. */
+  export const inboundSchema = DeploymentsOrNin$inboundSchema;
+  /** @deprecated use `DeploymentsOrNin$outboundSchema` instead. */
+  export const outboundSchema = DeploymentsOrNin$outboundSchema;
+  /** @deprecated use `DeploymentsOrNin$Outbound` instead. */
+  export type Outbound = DeploymentsOrNin$Outbound;
+}
+
+export function deploymentsOrNinToJSON(
+  deploymentsOrNin: DeploymentsOrNin,
+): string {
+  return JSON.stringify(
+    DeploymentsOrNin$outboundSchema.parse(deploymentsOrNin),
+  );
+}
+
+export function deploymentsOrNinFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentsOrNin, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentsOrNin$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentsOrNin' from JSON`,
+  );
+}
+
+/** @internal */
+export const OrIn$inboundSchema: z.ZodType<OrIn, z.ZodTypeDef, unknown> = z
+  .union([z.string(), z.number(), z.boolean()]);
+
+/** @internal */
+export type OrIn$Outbound = string | number | boolean;
+
+/** @internal */
+export const OrIn$outboundSchema: z.ZodType<OrIn$Outbound, z.ZodTypeDef, OrIn> =
+  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 DeploymentsOrIn$inboundSchema: z.ZodType<
+  DeploymentsOrIn,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  in: z.array(z.union([z.string(), z.number(), z.boolean()])),
+});
+
+/** @internal */
+export type DeploymentsOrIn$Outbound = {
+  in: Array<string | number | boolean>;
+};
+
+/** @internal */
+export const DeploymentsOrIn$outboundSchema: z.ZodType<
+  DeploymentsOrIn$Outbound,
+  z.ZodTypeDef,
+  DeploymentsOrIn
+> = 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 DeploymentsOrIn$ {
+  /** @deprecated use `DeploymentsOrIn$inboundSchema` instead. */
+  export const inboundSchema = DeploymentsOrIn$inboundSchema;
+  /** @deprecated use `DeploymentsOrIn$outboundSchema` instead. */
+  export const outboundSchema = DeploymentsOrIn$outboundSchema;
+  /** @deprecated use `DeploymentsOrIn$Outbound` instead. */
+  export type Outbound = DeploymentsOrIn$Outbound;
+}
+
+export function deploymentsOrInToJSON(
+  deploymentsOrIn: DeploymentsOrIn,
+): string {
+  return JSON.stringify(DeploymentsOrIn$outboundSchema.parse(deploymentsOrIn));
+}
+
+export function deploymentsOrInFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentsOrIn, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentsOrIn$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentsOrIn' 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 OrNe$inboundSchema: z.ZodType<OrNe, z.ZodTypeDef, unknown> = z
+  .union([z.string(), z.number(), z.boolean()]);
+
+/** @internal */
+export type OrNe$Outbound = string | number | boolean;
+
+/** @internal */
+export const OrNe$outboundSchema: z.ZodType<OrNe$Outbound, z.ZodTypeDef, OrNe> =
+  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 DeploymentsOrNe$inboundSchema: z.ZodType<
+  DeploymentsOrNe,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  ne: z.union([z.string(), z.number(), z.boolean()]),
+});
+
+/** @internal */
+export type DeploymentsOrNe$Outbound = {
+  ne: string | number | boolean;
+};
+
+/** @internal */
+export const DeploymentsOrNe$outboundSchema: z.ZodType<
+  DeploymentsOrNe$Outbound,
+  z.ZodTypeDef,
+  DeploymentsOrNe
+> = 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 DeploymentsOrNe$ {
+  /** @deprecated use `DeploymentsOrNe$inboundSchema` instead. */
+  export const inboundSchema = DeploymentsOrNe$inboundSchema;
+  /** @deprecated use `DeploymentsOrNe$outboundSchema` instead. */
+  export const outboundSchema = DeploymentsOrNe$outboundSchema;
+  /** @deprecated use `DeploymentsOrNe$Outbound` instead. */
+  export type Outbound = DeploymentsOrNe$Outbound;
+}
+
+export function deploymentsOrNeToJSON(
+  deploymentsOrNe: DeploymentsOrNe,
+): string {
+  return JSON.stringify(DeploymentsOrNe$outboundSchema.parse(deploymentsOrNe));
+}
+
+export function deploymentsOrNeFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentsOrNe, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentsOrNe$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentsOrNe' from JSON`,
+  );
+}
+
+/** @internal */
+export const OrEq$inboundSchema: z.ZodType<OrEq, z.ZodTypeDef, unknown> = z
+  .union([z.string(), z.number(), z.boolean()]);
+
+/** @internal */
+export type OrEq$Outbound = string | number | boolean;
+
+/** @internal */
+export const OrEq$outboundSchema: z.ZodType<OrEq$Outbound, z.ZodTypeDef, OrEq> =
+  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 DeploymentsOrEq$inboundSchema: z.ZodType<
+  DeploymentsOrEq,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  eq: z.union([z.string(), z.number(), z.boolean()]),
+});
+
+/** @internal */
+export type DeploymentsOrEq$Outbound = {
+  eq: string | number | boolean;
+};
+
+/** @internal */
+export const DeploymentsOrEq$outboundSchema: z.ZodType<
+  DeploymentsOrEq$Outbound,
+  z.ZodTypeDef,
+  DeploymentsOrEq
+> = 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 DeploymentsOrEq$ {
+  /** @deprecated use `DeploymentsOrEq$inboundSchema` instead. */
+  export const inboundSchema = DeploymentsOrEq$inboundSchema;
+  /** @deprecated use `DeploymentsOrEq$outboundSchema` instead. */
+  export const outboundSchema = DeploymentsOrEq$outboundSchema;
+  /** @deprecated use `DeploymentsOrEq$Outbound` instead. */
+  export type Outbound = DeploymentsOrEq$Outbound;
+}
+
+export function deploymentsOrEqToJSON(
+  deploymentsOrEq: DeploymentsOrEq,
+): string {
+  return JSON.stringify(DeploymentsOrEq$outboundSchema.parse(deploymentsOrEq));
+}
+
+export function deploymentsOrEqFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentsOrEq, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentsOrEq$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentsOrEq' from JSON`,
+  );
+}
+
+/** @internal */
+export const Or$inboundSchema: z.ZodType<Or, z.ZodTypeDef, unknown> = z.union([
+  z.lazy(() => DeploymentsOrEq$inboundSchema),
+  z.lazy(() => DeploymentsOrNe$inboundSchema),
+  z.lazy(() => Or3$inboundSchema),
+  z.lazy(() => OrGte$inboundSchema),
+  z.lazy(() => OrLt$inboundSchema),
+  z.lazy(() => OrLte$inboundSchema),
+  z.lazy(() => DeploymentsOrIn$inboundSchema),
+  z.lazy(() => DeploymentsOrNin$inboundSchema),
+  z.lazy(() => OrExists$inboundSchema),
+]);
+
+/** @internal */
+export type Or$Outbound =
+  | DeploymentsOrEq$Outbound
+  | DeploymentsOrNe$Outbound
+  | Or3$Outbound
+  | OrGte$Outbound
+  | OrLt$Outbound
+  | OrLte$Outbound
+  | DeploymentsOrIn$Outbound
+  | DeploymentsOrNin$Outbound
+  | OrExists$Outbound;
+
+/** @internal */
+export const Or$outboundSchema: z.ZodType<Or$Outbound, z.ZodTypeDef, Or> = z
+  .union([
+    z.lazy(() => DeploymentsOrEq$outboundSchema),
+    z.lazy(() => DeploymentsOrNe$outboundSchema),
+    z.lazy(() => Or3$outboundSchema),
+    z.lazy(() => OrGte$outboundSchema),
+    z.lazy(() => OrLt$outboundSchema),
+    z.lazy(() => OrLte$outboundSchema),
+    z.lazy(() => DeploymentsOrIn$outboundSchema),
+    z.lazy(() => DeploymentsOrNin$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 KnowledgeFilterOr$inboundSchema: z.ZodType<
+  KnowledgeFilterOr,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  or: z.array(
+    z.record(z.union([
+      z.lazy(() => DeploymentsOrEq$inboundSchema),
+      z.lazy(() =>
+        DeploymentsOrNe$inboundSchema
+      ),
+      z.lazy(() => Or3$inboundSchema),
+      z.lazy(() => OrGte$inboundSchema),
+      z.lazy(() => OrLt$inboundSchema),
+      z.lazy(() => OrLte$inboundSchema),
+      z.lazy(() => DeploymentsOrIn$inboundSchema),
+      z.lazy(() => DeploymentsOrNin$inboundSchema),
+      z.lazy(() => OrExists$inboundSchema),
+    ])),
+  ),
+});
+
+/** @internal */
+export type KnowledgeFilterOr$Outbound = {
+  or: Array<
+    {
+      [k: string]:
+        | DeploymentsOrEq$Outbound
+        | DeploymentsOrNe$Outbound
+        | Or3$Outbound
+        | OrGte$Outbound
+        | OrLt$Outbound
+        | OrLte$Outbound
+        | DeploymentsOrIn$Outbound
+        | DeploymentsOrNin$Outbound
+        | OrExists$Outbound;
+    }
+  >;
+};
+
+/** @internal */
+export const KnowledgeFilterOr$outboundSchema: z.ZodType<
+  KnowledgeFilterOr$Outbound,
+  z.ZodTypeDef,
+  KnowledgeFilterOr
+> = z.object({
+  or: z.array(
+    z.record(z.union([
+      z.lazy(() => DeploymentsOrEq$outboundSchema),
+      z.lazy(() =>
+        DeploymentsOrNe$outboundSchema
+      ),
+      z.lazy(() => Or3$outboundSchema),
+      z.lazy(() => OrGte$outboundSchema),
+      z.lazy(() => OrLt$outboundSchema),
+      z.lazy(() => OrLte$outboundSchema),
+      z.lazy(() => DeploymentsOrIn$outboundSchema),
+      z.lazy(() => DeploymentsOrNin$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 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 AndNin$inboundSchema: z.ZodType<AndNin, z.ZodTypeDef, unknown> = z
+  .union([z.string(), z.number(), z.boolean()]);
+
+/** @internal */
+export type AndNin$Outbound = string | number | boolean;
+
+/** @internal */
+export const AndNin$outboundSchema: z.ZodType<
+  AndNin$Outbound,
+  z.ZodTypeDef,
+  AndNin
+> = 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 DeploymentsAndNin$inboundSchema: z.ZodType<
+  DeploymentsAndNin,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  nin: z.array(z.union([z.string(), z.number(), z.boolean()])),
+});
+
+/** @internal */
+export type DeploymentsAndNin$Outbound = {
+  nin: Array<string | number | boolean>;
+};
+
+/** @internal */
+export const DeploymentsAndNin$outboundSchema: z.ZodType<
+  DeploymentsAndNin$Outbound,
+  z.ZodTypeDef,
+  DeploymentsAndNin
+> = 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 DeploymentsAndNin$ {
+  /** @deprecated use `DeploymentsAndNin$inboundSchema` instead. */
+  export const inboundSchema = DeploymentsAndNin$inboundSchema;
+  /** @deprecated use `DeploymentsAndNin$outboundSchema` instead. */
+  export const outboundSchema = DeploymentsAndNin$outboundSchema;
+  /** @deprecated use `DeploymentsAndNin$Outbound` instead. */
+  export type Outbound = DeploymentsAndNin$Outbound;
+}
+
+export function deploymentsAndNinToJSON(
+  deploymentsAndNin: DeploymentsAndNin,
+): string {
+  return JSON.stringify(
+    DeploymentsAndNin$outboundSchema.parse(deploymentsAndNin),
+  );
+}
+
+export function deploymentsAndNinFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentsAndNin, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentsAndNin$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentsAndNin' from JSON`,
+  );
+}
+
+/** @internal */
+export const AndIn$inboundSchema: z.ZodType<AndIn, z.ZodTypeDef, unknown> = z
+  .union([z.string(), z.number(), z.boolean()]);
+
+/** @internal */
+export type AndIn$Outbound = string | number | boolean;
+
+/** @internal */
+export const AndIn$outboundSchema: z.ZodType<
+  AndIn$Outbound,
+  z.ZodTypeDef,
+  AndIn
+> = 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 DeploymentsAndIn$inboundSchema: z.ZodType<
+  DeploymentsAndIn,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  in: z.array(z.union([z.string(), z.number(), z.boolean()])),
+});
+
+/** @internal */
+export type DeploymentsAndIn$Outbound = {
+  in: Array<string | number | boolean>;
+};
+
+/** @internal */
+export const DeploymentsAndIn$outboundSchema: z.ZodType<
+  DeploymentsAndIn$Outbound,
+  z.ZodTypeDef,
+  DeploymentsAndIn
+> = 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 DeploymentsAndIn$ {
+  /** @deprecated use `DeploymentsAndIn$inboundSchema` instead. */
+  export const inboundSchema = DeploymentsAndIn$inboundSchema;
+  /** @deprecated use `DeploymentsAndIn$outboundSchema` instead. */
+  export const outboundSchema = DeploymentsAndIn$outboundSchema;
+  /** @deprecated use `DeploymentsAndIn$Outbound` instead. */
+  export type Outbound = DeploymentsAndIn$Outbound;
+}
+
+export function deploymentsAndInToJSON(
+  deploymentsAndIn: DeploymentsAndIn,
+): string {
+  return JSON.stringify(
+    DeploymentsAndIn$outboundSchema.parse(deploymentsAndIn),
+  );
+}
+
+export function deploymentsAndInFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentsAndIn, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentsAndIn$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentsAndIn' 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 AndNe$inboundSchema: z.ZodType<AndNe, z.ZodTypeDef, unknown> = z
+  .union([z.string(), z.number(), z.boolean()]);
+
+/** @internal */
+export type AndNe$Outbound = string | number | boolean;
+
+/** @internal */
+export const AndNe$outboundSchema: z.ZodType<
+  AndNe$Outbound,
+  z.ZodTypeDef,
+  AndNe
+> = 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 DeploymentsAndNe$inboundSchema: z.ZodType<
+  DeploymentsAndNe,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  ne: z.union([z.string(), z.number(), z.boolean()]),
+});
+
+/** @internal */
+export type DeploymentsAndNe$Outbound = {
+  ne: string | number | boolean;
+};
+
+/** @internal */
+export const DeploymentsAndNe$outboundSchema: z.ZodType<
+  DeploymentsAndNe$Outbound,
+  z.ZodTypeDef,
+  DeploymentsAndNe
+> = 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 DeploymentsAndNe$ {
+  /** @deprecated use `DeploymentsAndNe$inboundSchema` instead. */
+  export const inboundSchema = DeploymentsAndNe$inboundSchema;
+  /** @deprecated use `DeploymentsAndNe$outboundSchema` instead. */
+  export const outboundSchema = DeploymentsAndNe$outboundSchema;
+  /** @deprecated use `DeploymentsAndNe$Outbound` instead. */
+  export type Outbound = DeploymentsAndNe$Outbound;
+}
+
+export function deploymentsAndNeToJSON(
+  deploymentsAndNe: DeploymentsAndNe,
+): string {
+  return JSON.stringify(
+    DeploymentsAndNe$outboundSchema.parse(deploymentsAndNe),
+  );
+}
+
+export function deploymentsAndNeFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentsAndNe, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentsAndNe$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentsAndNe' from JSON`,
+  );
+}
+
+/** @internal */
+export const AndEq$inboundSchema: z.ZodType<AndEq, z.ZodTypeDef, unknown> = z
+  .union([z.string(), z.number(), z.boolean()]);
+
+/** @internal */
+export type AndEq$Outbound = string | number | boolean;
+
+/** @internal */
+export const AndEq$outboundSchema: z.ZodType<
+  AndEq$Outbound,
+  z.ZodTypeDef,
+  AndEq
+> = 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 DeploymentsAndEq$inboundSchema: z.ZodType<
+  DeploymentsAndEq,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  eq: z.union([z.string(), z.number(), z.boolean()]),
+});
+
+/** @internal */
+export type DeploymentsAndEq$Outbound = {
+  eq: string | number | boolean;
+};
+
+/** @internal */
+export const DeploymentsAndEq$outboundSchema: z.ZodType<
+  DeploymentsAndEq$Outbound,
+  z.ZodTypeDef,
+  DeploymentsAndEq
+> = 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 DeploymentsAndEq$ {
+  /** @deprecated use `DeploymentsAndEq$inboundSchema` instead. */
+  export const inboundSchema = DeploymentsAndEq$inboundSchema;
+  /** @deprecated use `DeploymentsAndEq$outboundSchema` instead. */
+  export const outboundSchema = DeploymentsAndEq$outboundSchema;
+  /** @deprecated use `DeploymentsAndEq$Outbound` instead. */
+  export type Outbound = DeploymentsAndEq$Outbound;
+}
+
+export function deploymentsAndEqToJSON(
+  deploymentsAndEq: DeploymentsAndEq,
+): string {
+  return JSON.stringify(
+    DeploymentsAndEq$outboundSchema.parse(deploymentsAndEq),
+  );
+}
+
+export function deploymentsAndEqFromJSON(
+  jsonString: string,
+): SafeParseResult<DeploymentsAndEq, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeploymentsAndEq$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeploymentsAndEq' from JSON`,
+  );
+}
+
+/** @internal */
+export const And$inboundSchema: z.ZodType<And, z.ZodTypeDef, unknown> = z.union(
+  [
+    z.lazy(() => DeploymentsAndEq$inboundSchema),
+    z.lazy(() => DeploymentsAndNe$inboundSchema),
+    z.lazy(() => And3$inboundSchema),
+    z.lazy(() => AndGte$inboundSchema),
+    z.lazy(() => AndLt$inboundSchema),
+    z.lazy(() => AndLte$inboundSchema),
+    z.lazy(() => DeploymentsAndIn$inboundSchema),
+    z.lazy(() => DeploymentsAndNin$inboundSchema),
+    z.lazy(() => AndExists$inboundSchema),
+  ],
+);
+
+/** @internal */
+export type And$Outbound =
+  | DeploymentsAndEq$Outbound
+  | DeploymentsAndNe$Outbound
+  | And3$Outbound
+  | AndGte$Outbound
+  | AndLt$Outbound
+  | AndLte$Outbound
+  | DeploymentsAndIn$Outbound
+  | DeploymentsAndNin$Outbound
+  | AndExists$Outbound;
+
+/** @internal */
+export const And$outboundSchema: z.ZodType<And$Outbound, z.ZodTypeDef, And> = z
+  .union([
+    z.lazy(() => DeploymentsAndEq$outboundSchema),
+    z.lazy(() => DeploymentsAndNe$outboundSchema),
+    z.lazy(() => And3$outboundSchema),
+    z.lazy(() => AndGte$outboundSchema),
+    z.lazy(() => AndLt$outboundSchema),
+    z.lazy(() => AndLte$outboundSchema),
+    z.lazy(() => DeploymentsAndIn$outboundSchema),
+    z.lazy(() => DeploymentsAndNin$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 KnowledgeFilterAnd$inboundSchema: z.ZodType<
+  KnowledgeFilterAnd,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  and: z.array(
+    z.record(z.union([
+      z.lazy(() => DeploymentsAndEq$inboundSchema),
+      z.lazy(() =>
+        DeploymentsAndNe$inboundSchema
+      ),
+      z.lazy(() => And3$inboundSchema),
+      z.lazy(() => AndGte$inboundSchema),
+      z.lazy(() => AndLt$inboundSchema),
+      z.lazy(() => AndLte$inboundSchema),
+      z.lazy(() => DeploymentsAndIn$inboundSchema),
+      z.lazy(() => DeploymentsAndNin$inboundSchema),
+      z.lazy(() => AndExists$inboundSchema),
+    ])),
+  ),
+});
+
+/** @internal */
+export type KnowledgeFilterAnd$Outbound = {
+  and: Array<
+    {
+      [k: string]:
+        | DeploymentsAndEq$Outbound
+        | DeploymentsAndNe$Outbound
+        | And3$Outbound
+        | AndGte$Outbound
+        | AndLt$Outbound
+        | AndLte$Outbound
+        | DeploymentsAndIn$Outbound
+        | DeploymentsAndNin$Outbound
+        | AndExists$Outbound;
+    }
+  >;
+};
+
+/** @internal */
+export const KnowledgeFilterAnd$outboundSchema: z.ZodType<
+  KnowledgeFilterAnd$Outbound,
+  z.ZodTypeDef,
+  KnowledgeFilterAnd
+> = z.object({
+  and: z.array(
+    z.record(z.union([
+      z.lazy(() => DeploymentsAndEq$outboundSchema),
+      z.lazy(() =>
+        DeploymentsAndNe$outboundSchema
+      ),
+      z.lazy(() => And3$outboundSchema),
+      z.lazy(() => AndGte$outboundSchema),
+      z.lazy(() => AndLt$outboundSchema),
+      z.lazy(() => AndLte$outboundSchema),
+      z.lazy(() => DeploymentsAndIn$outboundSchema),
+      z.lazy(() => DeploymentsAndNin$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 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 Nin$inboundSchema: z.ZodType<Nin, z.ZodTypeDef, unknown> = z.union(
+  [z.string(), z.number(), z.boolean()],
+);
+
+/** @internal */
+export type Nin$Outbound = string | number | boolean;
+
+/** @internal */
+export const Nin$outboundSchema: z.ZodType<Nin$Outbound, z.ZodTypeDef, Nin> = 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 OneNin$inboundSchema: z.ZodType<OneNin, z.ZodTypeDef, unknown> = z
+  .object({
+    nin: z.array(z.union([z.string(), z.number(), z.boolean()])),
+  });
+
+/** @internal */
+export type OneNin$Outbound = {
+  nin: Array<string | number | boolean>;
+};
+
+/** @internal */
+export const OneNin$outboundSchema: z.ZodType<
+  OneNin$Outbound,
+  z.ZodTypeDef,
+  OneNin
+> = 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 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 In$inboundSchema: z.ZodType<In, z.ZodTypeDef, unknown> = z.union([
+  z.string(),
+  z.number(),
+  z.boolean(),
+]);
+
+/** @internal */
+export type In$Outbound = string | number | boolean;
+
+/** @internal */
+export const In$outboundSchema: z.ZodType<In$Outbound, z.ZodTypeDef, In> = 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 OneIn$inboundSchema: z.ZodType<OneIn, z.ZodTypeDef, unknown> = z
+  .object({
+    in: z.array(z.union([z.string(), z.number(), z.boolean()])),
+  });
+
+/** @internal */
+export type OneIn$Outbound = {
+  in: Array<string | number | boolean>;
+};
+
+/** @internal */
+export const OneIn$outboundSchema: z.ZodType<
+  OneIn$Outbound,
+  z.ZodTypeDef,
+  OneIn
+> = 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 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 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 Three$inboundSchema: z.ZodType<Three, z.ZodTypeDef, unknown> = z
+  .object({
+    gt: z.number(),
+  });
+
+/** @internal */
+export type Three$Outbound = {
+  gt: number;
+};
+
+/** @internal */
+export const Three$outboundSchema: z.ZodType<
+  Three$Outbound,
+  z.ZodTypeDef,
+  Three
+> = 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 Three$ {
+  /** @deprecated use `Three$inboundSchema` instead. */
+  export const inboundSchema = Three$inboundSchema;
+  /** @deprecated use `Three$outboundSchema` instead. */
+  export const outboundSchema = Three$outboundSchema;
+  /** @deprecated use `Three$Outbound` instead. */
+  export type Outbound = Three$Outbound;
+}
+
+export function threeToJSON(three: Three): string {
+  return JSON.stringify(Three$outboundSchema.parse(three));
+}
+
+export function threeFromJSON(
+  jsonString: string,
+): SafeParseResult<Three, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Three$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Three' from JSON`,
+  );
+}
+
+/** @internal */
+export const Ne$inboundSchema: z.ZodType<Ne, z.ZodTypeDef, unknown> = z.union([
+  z.string(),
+  z.number(),
+  z.boolean(),
+]);
+
+/** @internal */
+export type Ne$Outbound = string | number | boolean;
+
+/** @internal */
+export const Ne$outboundSchema: z.ZodType<Ne$Outbound, z.ZodTypeDef, 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 OneNe$inboundSchema: z.ZodType<OneNe, z.ZodTypeDef, unknown> = z
+  .object({
+    ne: z.union([z.string(), z.number(), z.boolean()]),
+  });
+
+/** @internal */
+export type OneNe$Outbound = {
+  ne: string | number | boolean;
+};
+
+/** @internal */
+export const OneNe$outboundSchema: z.ZodType<
+  OneNe$Outbound,
+  z.ZodTypeDef,
+  OneNe
+> = 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 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 Eq$inboundSchema: z.ZodType<Eq, z.ZodTypeDef, unknown> = z.union([
+  z.string(),
+  z.number(),
+  z.boolean(),
+]);
+
+/** @internal */
+export type Eq$Outbound = string | number | boolean;
+
+/** @internal */
+export const Eq$outboundSchema: z.ZodType<Eq$Outbound, z.ZodTypeDef, 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 OneEq$inboundSchema: z.ZodType<OneEq, z.ZodTypeDef, unknown> = z
+  .object({
+    eq: z.union([z.string(), z.number(), z.boolean()]),
+  });
+
+/** @internal */
+export type OneEq$Outbound = {
+  eq: string | number | boolean;
+};
+
+/** @internal */
+export const OneEq$outboundSchema: z.ZodType<
+  OneEq$Outbound,
+  z.ZodTypeDef,
+  OneEq
+> = 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 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 One$inboundSchema: z.ZodType<One, z.ZodTypeDef, unknown> = z.union(
+  [
+    z.lazy(() => OneEq$inboundSchema),
+    z.lazy(() => OneNe$inboundSchema),
+    z.lazy(() => Three$inboundSchema),
+    z.lazy(() => Gte$inboundSchema),
+    z.lazy(() => Lt$inboundSchema),
+    z.lazy(() => Lte$inboundSchema),
+    z.lazy(() => OneIn$inboundSchema),
+    z.lazy(() => OneNin$inboundSchema),
+    z.lazy(() => Exists$inboundSchema),
+  ],
+);
+
+/** @internal */
+export type One$Outbound =
+  | OneEq$Outbound
+  | OneNe$Outbound
+  | Three$Outbound
+  | Gte$Outbound
+  | Lt$Outbound
+  | Lte$Outbound
+  | OneIn$Outbound
+  | OneNin$Outbound
+  | Exists$Outbound;
+
+/** @internal */
+export const One$outboundSchema: z.ZodType<One$Outbound, z.ZodTypeDef, One> = z
+  .union([
+    z.lazy(() => OneEq$outboundSchema),
+    z.lazy(() => OneNe$outboundSchema),
+    z.lazy(() => Three$outboundSchema),
+    z.lazy(() => Gte$outboundSchema),
+    z.lazy(() => Lt$outboundSchema),
+    z.lazy(() => Lte$outboundSchema),
+    z.lazy(() => OneIn$outboundSchema),
+    z.lazy(() => OneNin$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 One$ {
+  /** @deprecated use `One$inboundSchema` instead. */
+  export const inboundSchema = One$inboundSchema;
+  /** @deprecated use `One$outboundSchema` instead. */
+  export const outboundSchema = One$outboundSchema;
+  /** @deprecated use `One$Outbound` instead. */
+  export type Outbound = One$Outbound;
+}
+
+export function oneToJSON(one: One): string {
+  return JSON.stringify(One$outboundSchema.parse(one));
+}
+
+export function oneFromJSON(
+  jsonString: string,
+): SafeParseResult<One, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => One$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'One' from JSON`,
+  );
+}
+
+/** @internal */
+export const KnowledgeFilter$inboundSchema: z.ZodType<
+  KnowledgeFilter,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => KnowledgeFilterAnd$inboundSchema),
+  z.lazy(() => KnowledgeFilterOr$inboundSchema),
+  z.record(z.union([
+    z.lazy(() => OneEq$inboundSchema),
+    z.lazy(() => OneNe$inboundSchema),
+    z.lazy(() => Three$inboundSchema),
+    z.lazy(() => Gte$inboundSchema),
+    z.lazy(() => Lt$inboundSchema),
+    z.lazy(() => Lte$inboundSchema),
+    z.lazy(() => OneIn$inboundSchema),
+    z.lazy(() => OneNin$inboundSchema),
+    z.lazy(() => Exists$inboundSchema),
+  ])),
+]);
+
+/** @internal */
+export type KnowledgeFilter$Outbound =
+  | KnowledgeFilterAnd$Outbound
+  | KnowledgeFilterOr$Outbound
+  | {
+    [k: string]:
+      | OneEq$Outbound
+      | OneNe$Outbound
+      | Three$Outbound
+      | Gte$Outbound
+      | Lt$Outbound
+      | Lte$Outbound
+      | OneIn$Outbound
+      | OneNin$Outbound
+      | Exists$Outbound;
+  };
+
+/** @internal */
+export const KnowledgeFilter$outboundSchema: z.ZodType<
+  KnowledgeFilter$Outbound,
+  z.ZodTypeDef,
+  KnowledgeFilter
+> = z.union([
+  z.lazy(() => KnowledgeFilterAnd$outboundSchema),
+  z.lazy(() => KnowledgeFilterOr$outboundSchema),
+  z.record(z.union([
+    z.lazy(() => OneEq$outboundSchema),
+    z.lazy(() => OneNe$outboundSchema),
+    z.lazy(() => Three$outboundSchema),
+    z.lazy(() => Gte$outboundSchema),
+    z.lazy(() => Lt$outboundSchema),
+    z.lazy(() => Lte$outboundSchema),
+    z.lazy(() => OneIn$outboundSchema),
+    z.lazy(() => OneNin$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 Deployments$inboundSchema: z.ZodType<
+  Deployments,
+  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(() => KnowledgeFilterAnd$inboundSchema),
+    z.lazy(() => KnowledgeFilterOr$inboundSchema),
+    z.record(z.union([
+      z.lazy(() => OneEq$inboundSchema),
+      z.lazy(() => OneNe$inboundSchema),
+      z.lazy(() => Three$inboundSchema),
+      z.lazy(() => Gte$inboundSchema),
+      z.lazy(() => Lt$inboundSchema),
+      z.lazy(() => Lte$inboundSchema),
+      z.lazy(() => OneIn$inboundSchema),
+      z.lazy(() => OneNin$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 Deployments$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;
@@ -4582,6 +7185,22 @@ export type Deployments$Outbound = {
   documents?: Array<Documents$Outbound> | undefined;
   invoke_options?: InvokeOptions$Outbound | undefined;
   thread?: Thread$Outbound | undefined;
+  knowledge_filter?:
+    | KnowledgeFilterAnd$Outbound
+    | KnowledgeFilterOr$Outbound
+    | {
+      [k: string]:
+        | OneEq$Outbound
+        | OneNe$Outbound
+        | Three$Outbound
+        | Gte$Outbound
+        | Lt$Outbound
+        | Lte$Outbound
+        | OneIn$Outbound
+        | OneNin$Outbound
+        | Exists$Outbound;
+    }
+    | undefined;
 };
 
 /** @internal */
@@ -4617,12 +7236,28 @@ export const Deployments$outboundSchema: z.ZodType<
   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(() => KnowledgeFilterAnd$outboundSchema),
+    z.lazy(() => KnowledgeFilterOr$outboundSchema),
+    z.record(z.union([
+      z.lazy(() => OneEq$outboundSchema),
+      z.lazy(() => OneNe$outboundSchema),
+      z.lazy(() => Three$outboundSchema),
+      z.lazy(() => Gte$outboundSchema),
+      z.lazy(() => Lt$outboundSchema),
+      z.lazy(() => Lte$outboundSchema),
+      z.lazy(() => OneIn$outboundSchema),
+      z.lazy(() => OneNin$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",
   });
 });