@narrative.io/data-collaboration-sdk-ts 2.95.0-beta.0 → 2.95.1

package/build/collaboration-policy/types/collaboration-policy.d.ts

@@ -0,0 +1,1370 @@
+import * as z from "zod/v4";
+type LogicalNode<T> = {
+    anyOf: Array<T | LogicalNode<T>>;
+} | {
+    allOf: Array<T | LogicalNode<T>>;
+};
+declare const CollaborationPolicy: z.ZodObject<{
+    name: z.core.$ZodBranded<z.ZodString, "CollaborationPolicyId", "out">;
+    description: z.ZodOptional<z.ZodString>;
+    display_name: z.ZodString;
+    policy: z.ZodObject<{
+        metadata: z.ZodObject<{
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            refresh_schedule: z.ZodOptional<z.ZodObject<{
+                max: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strip>;
+        definition: z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodString, "CollaborationPolicyId", "out">;
+            structure: z.ZodType<{
+                field: {
+                    type: "attribute";
+                    attribute_name: string;
+                    additional_required_properties?: ({
+                        dot: string;
+                    } | {
+                        pointer: string;
+                    })[] | undefined;
+                };
+                filters?: ({
+                    op: "or" | "and";
+                    stage: "generation";
+                    required: boolean;
+                    args: (string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    })[];
+                    name?: string | undefined;
+                } | {
+                    op: "not";
+                    stage: "generation";
+                    required: boolean;
+                    args: (string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    })[];
+                    name?: string | undefined;
+                } | {
+                    op: "is_null" | "is_not_null";
+                    stage: "generation";
+                    required: boolean;
+                    left: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    name?: string | undefined;
+                } | {
+                    op: "in" | "not in";
+                    stage: "generation";
+                    required: boolean;
+                    left: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    right: (string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    })[];
+                    name?: string | undefined;
+                } | {
+                    op: ">" | "<" | ">=" | "<=" | "=" | "<>" | "like" | "not like";
+                    stage: "generation";
+                    required: boolean;
+                    left: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    right: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    name?: string | undefined;
+                } | {
+                    op: "between";
+                    stage: "generation";
+                    required: boolean;
+                    operand: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    lower: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    upper: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    name?: string | undefined;
+                })[] | undefined;
+            } | LogicalNode<{
+                field: {
+                    type: "attribute";
+                    attribute_name: string;
+                    additional_required_properties?: ({
+                        dot: string;
+                    } | {
+                        pointer: string;
+                    })[] | undefined;
+                };
+                filters?: ({
+                    op: "or" | "and";
+                    stage: "generation";
+                    required: boolean;
+                    args: (string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    })[];
+                    name?: string | undefined;
+                } | {
+                    op: "not";
+                    stage: "generation";
+                    required: boolean;
+                    args: (string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    })[];
+                    name?: string | undefined;
+                } | {
+                    op: "is_null" | "is_not_null";
+                    stage: "generation";
+                    required: boolean;
+                    left: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    name?: string | undefined;
+                } | {
+                    op: "in" | "not in";
+                    stage: "generation";
+                    required: boolean;
+                    left: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    right: (string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    })[];
+                    name?: string | undefined;
+                } | {
+                    op: ">" | "<" | ">=" | "<=" | "=" | "<>" | "like" | "not like";
+                    stage: "generation";
+                    required: boolean;
+                    left: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    right: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    name?: string | undefined;
+                } | {
+                    op: "between";
+                    stage: "generation";
+                    required: boolean;
+                    operand: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    lower: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    upper: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    name?: string | undefined;
+                })[] | undefined;
+            }>, unknown, z.core.$ZodTypeInternals<{
+                field: {
+                    type: "attribute";
+                    attribute_name: string;
+                    additional_required_properties?: ({
+                        dot: string;
+                    } | {
+                        pointer: string;
+                    })[] | undefined;
+                };
+                filters?: ({
+                    op: "or" | "and";
+                    stage: "generation";
+                    required: boolean;
+                    args: (string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    })[];
+                    name?: string | undefined;
+                } | {
+                    op: "not";
+                    stage: "generation";
+                    required: boolean;
+                    args: (string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    })[];
+                    name?: string | undefined;
+                } | {
+                    op: "is_null" | "is_not_null";
+                    stage: "generation";
+                    required: boolean;
+                    left: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    name?: string | undefined;
+                } | {
+                    op: "in" | "not in";
+                    stage: "generation";
+                    required: boolean;
+                    left: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    right: (string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    })[];
+                    name?: string | undefined;
+                } | {
+                    op: ">" | "<" | ">=" | "<=" | "=" | "<>" | "like" | "not like";
+                    stage: "generation";
+                    required: boolean;
+                    left: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    right: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    name?: string | undefined;
+                } | {
+                    op: "between";
+                    stage: "generation";
+                    required: boolean;
+                    operand: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    lower: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    upper: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    name?: string | undefined;
+                })[] | undefined;
+            } | LogicalNode<{
+                field: {
+                    type: "attribute";
+                    attribute_name: string;
+                    additional_required_properties?: ({
+                        dot: string;
+                    } | {
+                        pointer: string;
+                    })[] | undefined;
+                };
+                filters?: ({
+                    op: "or" | "and";
+                    stage: "generation";
+                    required: boolean;
+                    args: (string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    })[];
+                    name?: string | undefined;
+                } | {
+                    op: "not";
+                    stage: "generation";
+                    required: boolean;
+                    args: (string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    })[];
+                    name?: string | undefined;
+                } | {
+                    op: "is_null" | "is_not_null";
+                    stage: "generation";
+                    required: boolean;
+                    left: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    name?: string | undefined;
+                } | {
+                    op: "in" | "not in";
+                    stage: "generation";
+                    required: boolean;
+                    left: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    right: (string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    })[];
+                    name?: string | undefined;
+                } | {
+                    op: ">" | "<" | ">=" | "<=" | "=" | "<>" | "like" | "not like";
+                    stage: "generation";
+                    required: boolean;
+                    left: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    right: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    name?: string | undefined;
+                } | {
+                    op: "between";
+                    stage: "generation";
+                    required: boolean;
+                    operand: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    lower: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    upper: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    name?: string | undefined;
+                })[] | undefined;
+            }>, unknown>>;
+            filters: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                op: z.ZodEnum<{
+                    or: "or";
+                    and: "and";
+                }>;
+                stage: z.ZodDefault<z.ZodLiteral<"generation">>;
+                name: z.ZodOptional<z.ZodString>;
+                required: z.ZodDefault<z.ZodBoolean>;
+                args: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{
+                    type: z.ZodLiteral<"attribute">;
+                    path: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                        dot: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        pointer: z.ZodString;
+                    }, z.core.$strict>]>>;
+                    attribute_name: z.ZodString;
+                }, z.core.$strict>]>>;
+            }, z.core.$strict>, z.ZodObject<{
+                op: z.ZodLiteral<"not">;
+                stage: z.ZodDefault<z.ZodLiteral<"generation">>;
+                name: z.ZodOptional<z.ZodString>;
+                required: z.ZodDefault<z.ZodBoolean>;
+                args: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{
+                    type: z.ZodLiteral<"attribute">;
+                    path: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                        dot: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        pointer: z.ZodString;
+                    }, z.core.$strict>]>>;
+                    attribute_name: z.ZodString;
+                }, z.core.$strict>]>>;
+            }, z.core.$strict>, z.ZodObject<{
+                op: z.ZodEnum<{
+                    is_null: "is_null";
+                    is_not_null: "is_not_null";
+                }>;
+                stage: z.ZodDefault<z.ZodLiteral<"generation">>;
+                name: z.ZodOptional<z.ZodString>;
+                required: z.ZodDefault<z.ZodBoolean>;
+                left: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{
+                    type: z.ZodLiteral<"attribute">;
+                    path: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                        dot: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        pointer: z.ZodString;
+                    }, z.core.$strict>]>>;
+                    attribute_name: z.ZodString;
+                }, z.core.$strict>]>;
+            }, z.core.$strict>, z.ZodObject<{
+                op: z.ZodEnum<{
+                    in: "in";
+                    "not in": "not in";
+                }>;
+                stage: z.ZodDefault<z.ZodLiteral<"generation">>;
+                name: z.ZodOptional<z.ZodString>;
+                required: z.ZodDefault<z.ZodBoolean>;
+                left: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{
+                    type: z.ZodLiteral<"attribute">;
+                    path: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                        dot: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        pointer: z.ZodString;
+                    }, z.core.$strict>]>>;
+                    attribute_name: z.ZodString;
+                }, z.core.$strict>]>;
+                right: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{
+                    type: z.ZodLiteral<"attribute">;
+                    path: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                        dot: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        pointer: z.ZodString;
+                    }, z.core.$strict>]>>;
+                    attribute_name: z.ZodString;
+                }, z.core.$strict>]>>;
+            }, z.core.$strict>, z.ZodObject<{
+                op: z.ZodEnum<{
+                    ">": ">";
+                    "<": "<";
+                    ">=": ">=";
+                    "<=": "<=";
+                    "=": "=";
+                    "<>": "<>";
+                    like: "like";
+                    "not like": "not like";
+                }>;
+                stage: z.ZodDefault<z.ZodLiteral<"generation">>;
+                name: z.ZodOptional<z.ZodString>;
+                required: z.ZodDefault<z.ZodBoolean>;
+                left: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{
+                    type: z.ZodLiteral<"attribute">;
+                    path: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                        dot: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        pointer: z.ZodString;
+                    }, z.core.$strict>]>>;
+                    attribute_name: z.ZodString;
+                }, z.core.$strict>]>;
+                right: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{
+                    type: z.ZodLiteral<"attribute">;
+                    path: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                        dot: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        pointer: z.ZodString;
+                    }, z.core.$strict>]>>;
+                    attribute_name: z.ZodString;
+                }, z.core.$strict>]>;
+            }, z.core.$strict>, z.ZodObject<{
+                op: z.ZodLiteral<"between">;
+                stage: z.ZodDefault<z.ZodLiteral<"generation">>;
+                name: z.ZodOptional<z.ZodString>;
+                required: z.ZodDefault<z.ZodBoolean>;
+                operand: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{
+                    type: z.ZodLiteral<"attribute">;
+                    path: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                        dot: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        pointer: z.ZodString;
+                    }, z.core.$strict>]>>;
+                    attribute_name: z.ZodString;
+                }, z.core.$strict>]>;
+                lower: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{
+                    type: z.ZodLiteral<"attribute">;
+                    path: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                        dot: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        pointer: z.ZodString;
+                    }, z.core.$strict>]>>;
+                    attribute_name: z.ZodString;
+                }, z.core.$strict>]>;
+                upper: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{
+                    type: z.ZodLiteral<"attribute">;
+                    path: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                        dot: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        pointer: z.ZodString;
+                    }, z.core.$strict>]>>;
+                    attribute_name: z.ZodString;
+                }, z.core.$strict>]>;
+            }, z.core.$strict>]>>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type CollaborationPolicyType = z.infer<typeof CollaborationPolicy>;
+export type CollaborationPolicyInput = z.input<typeof CollaborationPolicy>;
+export { CollaborationPolicy };
+type JsonSchemaOptions = Parameters<typeof z.toJSONSchema>[1];
+export declare function buildCollaborationPolicyJsonSchema(options?: JsonSchemaOptions): z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+    name: z.core.$ZodBranded<z.ZodString, "CollaborationPolicyId", "out">;
+    description: z.ZodOptional<z.ZodString>;
+    display_name: z.ZodString;
+    policy: z.ZodObject<{
+        metadata: z.ZodObject<{
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            refresh_schedule: z.ZodOptional<z.ZodObject<{
+                max: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strip>;
+        definition: z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodString, "CollaborationPolicyId", "out">;
+            structure: z.ZodType<{
+                field: {
+                    type: "attribute";
+                    attribute_name: string;
+                    additional_required_properties?: ({
+                        dot: string;
+                    } | {
+                        pointer: string;
+                    })[] | undefined;
+                };
+                filters?: ({
+                    op: "or" | "and";
+                    stage: "generation";
+                    required: boolean;
+                    args: (string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    })[];
+                    name?: string | undefined;
+                } | {
+                    op: "not";
+                    stage: "generation";
+                    required: boolean;
+                    args: (string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    })[];
+                    name?: string | undefined;
+                } | {
+                    op: "is_null" | "is_not_null";
+                    stage: "generation";
+                    required: boolean;
+                    left: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    name?: string | undefined;
+                } | {
+                    op: "in" | "not in";
+                    stage: "generation";
+                    required: boolean;
+                    left: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    right: (string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    })[];
+                    name?: string | undefined;
+                } | {
+                    op: ">" | "<" | ">=" | "<=" | "=" | "<>" | "like" | "not like";
+                    stage: "generation";
+                    required: boolean;
+                    left: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    right: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    name?: string | undefined;
+                } | {
+                    op: "between";
+                    stage: "generation";
+                    required: boolean;
+                    operand: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    lower: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    upper: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    name?: string | undefined;
+                })[] | undefined;
+            } | LogicalNode<{
+                field: {
+                    type: "attribute";
+                    attribute_name: string;
+                    additional_required_properties?: ({
+                        dot: string;
+                    } | {
+                        pointer: string;
+                    })[] | undefined;
+                };
+                filters?: ({
+                    op: "or" | "and";
+                    stage: "generation";
+                    required: boolean;
+                    args: (string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    })[];
+                    name?: string | undefined;
+                } | {
+                    op: "not";
+                    stage: "generation";
+                    required: boolean;
+                    args: (string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    })[];
+                    name?: string | undefined;
+                } | {
+                    op: "is_null" | "is_not_null";
+                    stage: "generation";
+                    required: boolean;
+                    left: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    name?: string | undefined;
+                } | {
+                    op: "in" | "not in";
+                    stage: "generation";
+                    required: boolean;
+                    left: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    right: (string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    })[];
+                    name?: string | undefined;
+                } | {
+                    op: ">" | "<" | ">=" | "<=" | "=" | "<>" | "like" | "not like";
+                    stage: "generation";
+                    required: boolean;
+                    left: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    right: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    name?: string | undefined;
+                } | {
+                    op: "between";
+                    stage: "generation";
+                    required: boolean;
+                    operand: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    lower: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    upper: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    name?: string | undefined;
+                })[] | undefined;
+            }>, unknown, z.core.$ZodTypeInternals<{
+                field: {
+                    type: "attribute";
+                    attribute_name: string;
+                    additional_required_properties?: ({
+                        dot: string;
+                    } | {
+                        pointer: string;
+                    })[] | undefined;
+                };
+                filters?: ({
+                    op: "or" | "and";
+                    stage: "generation";
+                    required: boolean;
+                    args: (string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    })[];
+                    name?: string | undefined;
+                } | {
+                    op: "not";
+                    stage: "generation";
+                    required: boolean;
+                    args: (string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    })[];
+                    name?: string | undefined;
+                } | {
+                    op: "is_null" | "is_not_null";
+                    stage: "generation";
+                    required: boolean;
+                    left: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    name?: string | undefined;
+                } | {
+                    op: "in" | "not in";
+                    stage: "generation";
+                    required: boolean;
+                    left: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    right: (string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    })[];
+                    name?: string | undefined;
+                } | {
+                    op: ">" | "<" | ">=" | "<=" | "=" | "<>" | "like" | "not like";
+                    stage: "generation";
+                    required: boolean;
+                    left: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    right: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    name?: string | undefined;
+                } | {
+                    op: "between";
+                    stage: "generation";
+                    required: boolean;
+                    operand: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    lower: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    upper: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    name?: string | undefined;
+                })[] | undefined;
+            } | LogicalNode<{
+                field: {
+                    type: "attribute";
+                    attribute_name: string;
+                    additional_required_properties?: ({
+                        dot: string;
+                    } | {
+                        pointer: string;
+                    })[] | undefined;
+                };
+                filters?: ({
+                    op: "or" | "and";
+                    stage: "generation";
+                    required: boolean;
+                    args: (string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    })[];
+                    name?: string | undefined;
+                } | {
+                    op: "not";
+                    stage: "generation";
+                    required: boolean;
+                    args: (string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    })[];
+                    name?: string | undefined;
+                } | {
+                    op: "is_null" | "is_not_null";
+                    stage: "generation";
+                    required: boolean;
+                    left: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    name?: string | undefined;
+                } | {
+                    op: "in" | "not in";
+                    stage: "generation";
+                    required: boolean;
+                    left: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    right: (string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    })[];
+                    name?: string | undefined;
+                } | {
+                    op: ">" | "<" | ">=" | "<=" | "=" | "<>" | "like" | "not like";
+                    stage: "generation";
+                    required: boolean;
+                    left: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    right: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    name?: string | undefined;
+                } | {
+                    op: "between";
+                    stage: "generation";
+                    required: boolean;
+                    operand: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    lower: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    upper: string | number | boolean | {
+                        type: "attribute";
+                        attribute_name: string;
+                        path?: {
+                            dot: string;
+                        } | {
+                            pointer: string;
+                        } | undefined;
+                    };
+                    name?: string | undefined;
+                })[] | undefined;
+            }>, unknown>>;
+            filters: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                op: z.ZodEnum<{
+                    or: "or";
+                    and: "and";
+                }>;
+                stage: z.ZodDefault<z.ZodLiteral<"generation">>;
+                name: z.ZodOptional<z.ZodString>;
+                required: z.ZodDefault<z.ZodBoolean>;
+                args: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{
+                    type: z.ZodLiteral<"attribute">;
+                    path: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                        dot: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        pointer: z.ZodString;
+                    }, z.core.$strict>]>>;
+                    attribute_name: z.ZodString;
+                }, z.core.$strict>]>>;
+            }, z.core.$strict>, z.ZodObject<{
+                op: z.ZodLiteral<"not">;
+                stage: z.ZodDefault<z.ZodLiteral<"generation">>;
+                name: z.ZodOptional<z.ZodString>;
+                required: z.ZodDefault<z.ZodBoolean>;
+                args: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{
+                    type: z.ZodLiteral<"attribute">;
+                    path: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                        dot: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        pointer: z.ZodString;
+                    }, z.core.$strict>]>>;
+                    attribute_name: z.ZodString;
+                }, z.core.$strict>]>>;
+            }, z.core.$strict>, z.ZodObject<{
+                op: z.ZodEnum<{
+                    is_null: "is_null";
+                    is_not_null: "is_not_null";
+                }>;
+                stage: z.ZodDefault<z.ZodLiteral<"generation">>;
+                name: z.ZodOptional<z.ZodString>;
+                required: z.ZodDefault<z.ZodBoolean>;
+                left: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{
+                    type: z.ZodLiteral<"attribute">;
+                    path: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                        dot: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        pointer: z.ZodString;
+                    }, z.core.$strict>]>>;
+                    attribute_name: z.ZodString;
+                }, z.core.$strict>]>;
+            }, z.core.$strict>, z.ZodObject<{
+                op: z.ZodEnum<{
+                    in: "in";
+                    "not in": "not in";
+                }>;
+                stage: z.ZodDefault<z.ZodLiteral<"generation">>;
+                name: z.ZodOptional<z.ZodString>;
+                required: z.ZodDefault<z.ZodBoolean>;
+                left: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{
+                    type: z.ZodLiteral<"attribute">;
+                    path: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                        dot: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        pointer: z.ZodString;
+                    }, z.core.$strict>]>>;
+                    attribute_name: z.ZodString;
+                }, z.core.$strict>]>;
+                right: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{
+                    type: z.ZodLiteral<"attribute">;
+                    path: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                        dot: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        pointer: z.ZodString;
+                    }, z.core.$strict>]>>;
+                    attribute_name: z.ZodString;
+                }, z.core.$strict>]>>;
+            }, z.core.$strict>, z.ZodObject<{
+                op: z.ZodEnum<{
+                    ">": ">";
+                    "<": "<";
+                    ">=": ">=";
+                    "<=": "<=";
+                    "=": "=";
+                    "<>": "<>";
+                    like: "like";
+                    "not like": "not like";
+                }>;
+                stage: z.ZodDefault<z.ZodLiteral<"generation">>;
+                name: z.ZodOptional<z.ZodString>;
+                required: z.ZodDefault<z.ZodBoolean>;
+                left: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{
+                    type: z.ZodLiteral<"attribute">;
+                    path: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                        dot: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        pointer: z.ZodString;
+                    }, z.core.$strict>]>>;
+                    attribute_name: z.ZodString;
+                }, z.core.$strict>]>;
+                right: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{
+                    type: z.ZodLiteral<"attribute">;
+                    path: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                        dot: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        pointer: z.ZodString;
+                    }, z.core.$strict>]>>;
+                    attribute_name: z.ZodString;
+                }, z.core.$strict>]>;
+            }, z.core.$strict>, z.ZodObject<{
+                op: z.ZodLiteral<"between">;
+                stage: z.ZodDefault<z.ZodLiteral<"generation">>;
+                name: z.ZodOptional<z.ZodString>;
+                required: z.ZodDefault<z.ZodBoolean>;
+                operand: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{
+                    type: z.ZodLiteral<"attribute">;
+                    path: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                        dot: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        pointer: z.ZodString;
+                    }, z.core.$strict>]>>;
+                    attribute_name: z.ZodString;
+                }, z.core.$strict>]>;
+                lower: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{
+                    type: z.ZodLiteral<"attribute">;
+                    path: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                        dot: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        pointer: z.ZodString;
+                    }, z.core.$strict>]>>;
+                    attribute_name: z.ZodString;
+                }, z.core.$strict>]>;
+                upper: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{
+                    type: z.ZodLiteral<"attribute">;
+                    path: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                        dot: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        pointer: z.ZodString;
+                    }, z.core.$strict>]>>;
+                    attribute_name: z.ZodString;
+                }, z.core.$strict>]>;
+            }, z.core.$strict>]>>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>>;