npm - @rocicorp/zero - Versions diffs - 1.10.0-canary.2 → 1.10.0-canary.21 - Mend

@rocicorp/zero 1.10.0-canary.2 → 1.10.0-canary.21

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (384) hide show

package/out/zero-cache/src/services/change-source/pg/schema/ddl.d.ts CHANGED Viewed

@@ -45,70 +45,284 @@ export declare const ddlStartEventSchema: v.ObjectType<Omit<Omit<{
     type: v.Type<"ddlStart">;
     schema: v.Optional<{
         indexes: {
-            isReplicaIdentity?: boolean | undefined;
-            isPrimaryKey?: boolean | undefined;
-            isImmediate?: boolean | undefined;
-            name: string;
-            columns: Record<string, "ASC" | "DESC">;
-            schema: string;
-            tableName: string;
-            unique: boolean;
+            readonly predicate?: {
+                readonly type: "and" | "or";
+                readonly conditions: readonly (/*elided*/ any | {
+                    readonly type: "not";
+                    readonly condition: /*elided*/ any | /*elided*/ any | {
+                        readonly type: "null-test";
+                        readonly column: string;
+                        readonly op: "IS NULL" | "IS NOT NULL";
+                    } | {
+                        readonly type: "comparison";
+                        readonly column: string;
+                        readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                        readonly value: {
+                            readonly type: "boolean";
+                            readonly value: boolean;
+                        } | {
+                            readonly type: "integer";
+                            readonly value: string;
+                        } | {
+                            readonly type: "string";
+                            readonly value: string;
+                        };
+                    };
+                } | {
+                    readonly type: "null-test";
+                    readonly column: string;
+                    readonly op: "IS NULL" | "IS NOT NULL";
+                } | {
+                    readonly type: "comparison";
+                    readonly column: string;
+                    readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                    readonly value: {
+                        readonly type: "boolean";
+                        readonly value: boolean;
+                    } | {
+                        readonly type: "integer";
+                        readonly value: string;
+                    } | {
+                        readonly type: "string";
+                        readonly value: string;
+                    };
+                })[];
+            } | {
+                readonly type: "not";
+                readonly condition: {
+                    readonly type: "and" | "or";
+                    readonly conditions: readonly (/*elided*/ any | /*elided*/ any | {
+                        readonly type: "null-test";
+                        readonly column: string;
+                        readonly op: "IS NULL" | "IS NOT NULL";
+                    } | {
+                        readonly type: "comparison";
+                        readonly column: string;
+                        readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                        readonly value: {
+                            readonly type: "boolean";
+                            readonly value: boolean;
+                        } | {
+                            readonly type: "integer";
+                            readonly value: string;
+                        } | {
+                            readonly type: "string";
+                            readonly value: string;
+                        };
+                    })[];
+                } | /*elided*/ any | {
+                    readonly type: "null-test";
+                    readonly column: string;
+                    readonly op: "IS NULL" | "IS NOT NULL";
+                } | {
+                    readonly type: "comparison";
+                    readonly column: string;
+                    readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                    readonly value: {
+                        readonly type: "boolean";
+                        readonly value: boolean;
+                    } | {
+                        readonly type: "integer";
+                        readonly value: string;
+                    } | {
+                        readonly type: "string";
+                        readonly value: string;
+                    };
+                };
+            } | {
+                readonly type: "null-test";
+                readonly column: string;
+                readonly op: "IS NULL" | "IS NOT NULL";
+            } | {
+                readonly type: "comparison";
+                readonly column: string;
+                readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                readonly value: {
+                    readonly type: "boolean";
+                    readonly value: boolean;
+                } | {
+                    readonly type: "integer";
+                    readonly value: string;
+                } | {
+                    readonly type: "string";
+                    readonly value: string;
+                };
+            } | undefined;
+            readonly isReplicaIdentity?: boolean | undefined;
+            readonly isPrimaryKey?: boolean | undefined;
+            readonly isImmediate?: boolean | undefined;
+            readonly name: string;
+            readonly columns: {
+                readonly [x: string]: "ASC" | "DESC";
+            };
+            readonly schema: string;
+            readonly tableName: string;
+            readonly unique: boolean;
         }[];
         tables: {
             replicaIdentityColumns: string[];
+            columns: {
+                [k: string]: {
+                    pgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | undefined;
+                    elemPgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | null | undefined;
+                    characterMaximumLength?: number | null | undefined;
+                    notNull?: boolean | null | undefined;
+                    dflt?: string | null | undefined;
+                    pos: number;
+                    dataType: string;
+                    typeOID: number;
+                };
+            };
             primaryKey?: string[] | undefined;
             schemaOID?: number | undefined;
             replicaIdentity?: "n" | "d" | "f" | "i" | undefined;
             name: string;
             schema: string;
-            oid: number;
-            columns: Record<string, {
-                pgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | undefined;
-                elemPgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | null | undefined;
-                characterMaximumLength?: number | null | undefined;
-                notNull?: boolean | null | undefined;
-                dflt?: string | null | undefined;
-                pos: number;
-                dataType: string;
-                typeOID: number;
-            }>;
             publications: Record<string, {
                 rowFilter: string | null;
             }>;
+            oid: number;
         }[];
     }>;
     previousSchema: v.Optional<{
         indexes: {
-            isReplicaIdentity?: boolean | undefined;
-            isPrimaryKey?: boolean | undefined;
-            isImmediate?: boolean | undefined;
-            name: string;
-            columns: Record<string, "ASC" | "DESC">;
-            schema: string;
-            tableName: string;
-            unique: boolean;
+            readonly predicate?: {
+                readonly type: "and" | "or";
+                readonly conditions: readonly (/*elided*/ any | {
+                    readonly type: "not";
+                    readonly condition: /*elided*/ any | /*elided*/ any | {
+                        readonly type: "null-test";
+                        readonly column: string;
+                        readonly op: "IS NULL" | "IS NOT NULL";
+                    } | {
+                        readonly type: "comparison";
+                        readonly column: string;
+                        readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                        readonly value: {
+                            readonly type: "boolean";
+                            readonly value: boolean;
+                        } | {
+                            readonly type: "integer";
+                            readonly value: string;
+                        } | {
+                            readonly type: "string";
+                            readonly value: string;
+                        };
+                    };
+                } | {
+                    readonly type: "null-test";
+                    readonly column: string;
+                    readonly op: "IS NULL" | "IS NOT NULL";
+                } | {
+                    readonly type: "comparison";
+                    readonly column: string;
+                    readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                    readonly value: {
+                        readonly type: "boolean";
+                        readonly value: boolean;
+                    } | {
+                        readonly type: "integer";
+                        readonly value: string;
+                    } | {
+                        readonly type: "string";
+                        readonly value: string;
+                    };
+                })[];
+            } | {
+                readonly type: "not";
+                readonly condition: {
+                    readonly type: "and" | "or";
+                    readonly conditions: readonly (/*elided*/ any | /*elided*/ any | {
+                        readonly type: "null-test";
+                        readonly column: string;
+                        readonly op: "IS NULL" | "IS NOT NULL";
+                    } | {
+                        readonly type: "comparison";
+                        readonly column: string;
+                        readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                        readonly value: {
+                            readonly type: "boolean";
+                            readonly value: boolean;
+                        } | {
+                            readonly type: "integer";
+                            readonly value: string;
+                        } | {
+                            readonly type: "string";
+                            readonly value: string;
+                        };
+                    })[];
+                } | /*elided*/ any | {
+                    readonly type: "null-test";
+                    readonly column: string;
+                    readonly op: "IS NULL" | "IS NOT NULL";
+                } | {
+                    readonly type: "comparison";
+                    readonly column: string;
+                    readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                    readonly value: {
+                        readonly type: "boolean";
+                        readonly value: boolean;
+                    } | {
+                        readonly type: "integer";
+                        readonly value: string;
+                    } | {
+                        readonly type: "string";
+                        readonly value: string;
+                    };
+                };
+            } | {
+                readonly type: "null-test";
+                readonly column: string;
+                readonly op: "IS NULL" | "IS NOT NULL";
+            } | {
+                readonly type: "comparison";
+                readonly column: string;
+                readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                readonly value: {
+                    readonly type: "boolean";
+                    readonly value: boolean;
+                } | {
+                    readonly type: "integer";
+                    readonly value: string;
+                } | {
+                    readonly type: "string";
+                    readonly value: string;
+                };
+            } | undefined;
+            readonly isReplicaIdentity?: boolean | undefined;
+            readonly isPrimaryKey?: boolean | undefined;
+            readonly isImmediate?: boolean | undefined;
+            readonly name: string;
+            readonly columns: {
+                readonly [x: string]: "ASC" | "DESC";
+            };
+            readonly schema: string;
+            readonly tableName: string;
+            readonly unique: boolean;
         }[];
         tables: {
             replicaIdentityColumns: string[];
+            columns: {
+                [k: string]: {
+                    pgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | undefined;
+                    elemPgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | null | undefined;
+                    characterMaximumLength?: number | null | undefined;
+                    notNull?: boolean | null | undefined;
+                    dflt?: string | null | undefined;
+                    pos: number;
+                    dataType: string;
+                    typeOID: number;
+                };
+            };
             primaryKey?: string[] | undefined;
             schemaOID?: number | undefined;
             replicaIdentity?: "n" | "d" | "f" | "i" | undefined;
             name: string;
             schema: string;
-            oid: number;
-            columns: Record<string, {
-                pgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | undefined;
-                elemPgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | null | undefined;
-                characterMaximumLength?: number | null | undefined;
-                notNull?: boolean | null | undefined;
-                dflt?: string | null | undefined;
-                pos: number;
-                dataType: string;
-                typeOID: number;
-            }>;
             publications: Record<string, {
                 rowFilter: string | null;
             }>;
+            oid: number;
         }[];
     } | null>;
     event: v.Type<{
@@ -135,70 +349,284 @@ export declare const ddlUpdateEventSchema: v.ObjectType<Omit<Omit<{
     type: v.Type<"ddlUpdate">;
     schema: v.Type<{
         indexes: {
-            isReplicaIdentity?: boolean | undefined;
-            isPrimaryKey?: boolean | undefined;
-            isImmediate?: boolean | undefined;
-            name: string;
-            columns: Record<string, "ASC" | "DESC">;
-            schema: string;
-            tableName: string;
-            unique: boolean;
+            readonly predicate?: {
+                readonly type: "and" | "or";
+                readonly conditions: readonly (/*elided*/ any | {
+                    readonly type: "not";
+                    readonly condition: /*elided*/ any | /*elided*/ any | {
+                        readonly type: "null-test";
+                        readonly column: string;
+                        readonly op: "IS NULL" | "IS NOT NULL";
+                    } | {
+                        readonly type: "comparison";
+                        readonly column: string;
+                        readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                        readonly value: {
+                            readonly type: "boolean";
+                            readonly value: boolean;
+                        } | {
+                            readonly type: "integer";
+                            readonly value: string;
+                        } | {
+                            readonly type: "string";
+                            readonly value: string;
+                        };
+                    };
+                } | {
+                    readonly type: "null-test";
+                    readonly column: string;
+                    readonly op: "IS NULL" | "IS NOT NULL";
+                } | {
+                    readonly type: "comparison";
+                    readonly column: string;
+                    readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                    readonly value: {
+                        readonly type: "boolean";
+                        readonly value: boolean;
+                    } | {
+                        readonly type: "integer";
+                        readonly value: string;
+                    } | {
+                        readonly type: "string";
+                        readonly value: string;
+                    };
+                })[];
+            } | {
+                readonly type: "not";
+                readonly condition: {
+                    readonly type: "and" | "or";
+                    readonly conditions: readonly (/*elided*/ any | /*elided*/ any | {
+                        readonly type: "null-test";
+                        readonly column: string;
+                        readonly op: "IS NULL" | "IS NOT NULL";
+                    } | {
+                        readonly type: "comparison";
+                        readonly column: string;
+                        readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                        readonly value: {
+                            readonly type: "boolean";
+                            readonly value: boolean;
+                        } | {
+                            readonly type: "integer";
+                            readonly value: string;
+                        } | {
+                            readonly type: "string";
+                            readonly value: string;
+                        };
+                    })[];
+                } | /*elided*/ any | {
+                    readonly type: "null-test";
+                    readonly column: string;
+                    readonly op: "IS NULL" | "IS NOT NULL";
+                } | {
+                    readonly type: "comparison";
+                    readonly column: string;
+                    readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                    readonly value: {
+                        readonly type: "boolean";
+                        readonly value: boolean;
+                    } | {
+                        readonly type: "integer";
+                        readonly value: string;
+                    } | {
+                        readonly type: "string";
+                        readonly value: string;
+                    };
+                };
+            } | {
+                readonly type: "null-test";
+                readonly column: string;
+                readonly op: "IS NULL" | "IS NOT NULL";
+            } | {
+                readonly type: "comparison";
+                readonly column: string;
+                readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                readonly value: {
+                    readonly type: "boolean";
+                    readonly value: boolean;
+                } | {
+                    readonly type: "integer";
+                    readonly value: string;
+                } | {
+                    readonly type: "string";
+                    readonly value: string;
+                };
+            } | undefined;
+            readonly isReplicaIdentity?: boolean | undefined;
+            readonly isPrimaryKey?: boolean | undefined;
+            readonly isImmediate?: boolean | undefined;
+            readonly name: string;
+            readonly columns: {
+                readonly [x: string]: "ASC" | "DESC";
+            };
+            readonly schema: string;
+            readonly tableName: string;
+            readonly unique: boolean;
         }[];
         tables: {
             replicaIdentityColumns: string[];
+            columns: {
+                [k: string]: {
+                    pgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | undefined;
+                    elemPgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | null | undefined;
+                    characterMaximumLength?: number | null | undefined;
+                    notNull?: boolean | null | undefined;
+                    dflt?: string | null | undefined;
+                    pos: number;
+                    dataType: string;
+                    typeOID: number;
+                };
+            };
             primaryKey?: string[] | undefined;
             schemaOID?: number | undefined;
             replicaIdentity?: "n" | "d" | "f" | "i" | undefined;
             name: string;
             schema: string;
-            oid: number;
-            columns: Record<string, {
-                pgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | undefined;
-                elemPgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | null | undefined;
-                characterMaximumLength?: number | null | undefined;
-                notNull?: boolean | null | undefined;
-                dflt?: string | null | undefined;
-                pos: number;
-                dataType: string;
-                typeOID: number;
-            }>;
             publications: Record<string, {
                 rowFilter: string | null;
             }>;
+            oid: number;
         }[];
     }>;
     previousSchema: v.Optional<{
         indexes: {
-            isReplicaIdentity?: boolean | undefined;
-            isPrimaryKey?: boolean | undefined;
-            isImmediate?: boolean | undefined;
-            name: string;
-            columns: Record<string, "ASC" | "DESC">;
-            schema: string;
-            tableName: string;
-            unique: boolean;
+            readonly predicate?: {
+                readonly type: "and" | "or";
+                readonly conditions: readonly (/*elided*/ any | {
+                    readonly type: "not";
+                    readonly condition: /*elided*/ any | /*elided*/ any | {
+                        readonly type: "null-test";
+                        readonly column: string;
+                        readonly op: "IS NULL" | "IS NOT NULL";
+                    } | {
+                        readonly type: "comparison";
+                        readonly column: string;
+                        readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                        readonly value: {
+                            readonly type: "boolean";
+                            readonly value: boolean;
+                        } | {
+                            readonly type: "integer";
+                            readonly value: string;
+                        } | {
+                            readonly type: "string";
+                            readonly value: string;
+                        };
+                    };
+                } | {
+                    readonly type: "null-test";
+                    readonly column: string;
+                    readonly op: "IS NULL" | "IS NOT NULL";
+                } | {
+                    readonly type: "comparison";
+                    readonly column: string;
+                    readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                    readonly value: {
+                        readonly type: "boolean";
+                        readonly value: boolean;
+                    } | {
+                        readonly type: "integer";
+                        readonly value: string;
+                    } | {
+                        readonly type: "string";
+                        readonly value: string;
+                    };
+                })[];
+            } | {
+                readonly type: "not";
+                readonly condition: {
+                    readonly type: "and" | "or";
+                    readonly conditions: readonly (/*elided*/ any | /*elided*/ any | {
+                        readonly type: "null-test";
+                        readonly column: string;
+                        readonly op: "IS NULL" | "IS NOT NULL";
+                    } | {
+                        readonly type: "comparison";
+                        readonly column: string;
+                        readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                        readonly value: {
+                            readonly type: "boolean";
+                            readonly value: boolean;
+                        } | {
+                            readonly type: "integer";
+                            readonly value: string;
+                        } | {
+                            readonly type: "string";
+                            readonly value: string;
+                        };
+                    })[];
+                } | /*elided*/ any | {
+                    readonly type: "null-test";
+                    readonly column: string;
+                    readonly op: "IS NULL" | "IS NOT NULL";
+                } | {
+                    readonly type: "comparison";
+                    readonly column: string;
+                    readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                    readonly value: {
+                        readonly type: "boolean";
+                        readonly value: boolean;
+                    } | {
+                        readonly type: "integer";
+                        readonly value: string;
+                    } | {
+                        readonly type: "string";
+                        readonly value: string;
+                    };
+                };
+            } | {
+                readonly type: "null-test";
+                readonly column: string;
+                readonly op: "IS NULL" | "IS NOT NULL";
+            } | {
+                readonly type: "comparison";
+                readonly column: string;
+                readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                readonly value: {
+                    readonly type: "boolean";
+                    readonly value: boolean;
+                } | {
+                    readonly type: "integer";
+                    readonly value: string;
+                } | {
+                    readonly type: "string";
+                    readonly value: string;
+                };
+            } | undefined;
+            readonly isReplicaIdentity?: boolean | undefined;
+            readonly isPrimaryKey?: boolean | undefined;
+            readonly isImmediate?: boolean | undefined;
+            readonly name: string;
+            readonly columns: {
+                readonly [x: string]: "ASC" | "DESC";
+            };
+            readonly schema: string;
+            readonly tableName: string;
+            readonly unique: boolean;
         }[];
         tables: {
             replicaIdentityColumns: string[];
+            columns: {
+                [k: string]: {
+                    pgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | undefined;
+                    elemPgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | null | undefined;
+                    characterMaximumLength?: number | null | undefined;
+                    notNull?: boolean | null | undefined;
+                    dflt?: string | null | undefined;
+                    pos: number;
+                    dataType: string;
+                    typeOID: number;
+                };
+            };
             primaryKey?: string[] | undefined;
             schemaOID?: number | undefined;
             replicaIdentity?: "n" | "d" | "f" | "i" | undefined;
             name: string;
             schema: string;
-            oid: number;
-            columns: Record<string, {
-                pgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | undefined;
-                elemPgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | null | undefined;
-                characterMaximumLength?: number | null | undefined;
-                notNull?: boolean | null | undefined;
-                dflt?: string | null | undefined;
-                pos: number;
-                dataType: string;
-                typeOID: number;
-            }>;
             publications: Record<string, {
                 rowFilter: string | null;
             }>;
+            oid: number;
         }[];
     }>;
 }, undefined>;
@@ -239,70 +667,284 @@ export declare const schemaSnapshotEventSchema: v.ObjectType<Omit<Omit<{
     type: v.Type<"schemaSnapshot">;
     schema: v.Type<{
         indexes: {
-            isReplicaIdentity?: boolean | undefined;
-            isPrimaryKey?: boolean | undefined;
-            isImmediate?: boolean | undefined;
-            name: string;
-            columns: Record<string, "ASC" | "DESC">;
-            schema: string;
-            tableName: string;
-            unique: boolean;
+            readonly predicate?: {
+                readonly type: "and" | "or";
+                readonly conditions: readonly (/*elided*/ any | {
+                    readonly type: "not";
+                    readonly condition: /*elided*/ any | /*elided*/ any | {
+                        readonly type: "null-test";
+                        readonly column: string;
+                        readonly op: "IS NULL" | "IS NOT NULL";
+                    } | {
+                        readonly type: "comparison";
+                        readonly column: string;
+                        readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                        readonly value: {
+                            readonly type: "boolean";
+                            readonly value: boolean;
+                        } | {
+                            readonly type: "integer";
+                            readonly value: string;
+                        } | {
+                            readonly type: "string";
+                            readonly value: string;
+                        };
+                    };
+                } | {
+                    readonly type: "null-test";
+                    readonly column: string;
+                    readonly op: "IS NULL" | "IS NOT NULL";
+                } | {
+                    readonly type: "comparison";
+                    readonly column: string;
+                    readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                    readonly value: {
+                        readonly type: "boolean";
+                        readonly value: boolean;
+                    } | {
+                        readonly type: "integer";
+                        readonly value: string;
+                    } | {
+                        readonly type: "string";
+                        readonly value: string;
+                    };
+                })[];
+            } | {
+                readonly type: "not";
+                readonly condition: {
+                    readonly type: "and" | "or";
+                    readonly conditions: readonly (/*elided*/ any | /*elided*/ any | {
+                        readonly type: "null-test";
+                        readonly column: string;
+                        readonly op: "IS NULL" | "IS NOT NULL";
+                    } | {
+                        readonly type: "comparison";
+                        readonly column: string;
+                        readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                        readonly value: {
+                            readonly type: "boolean";
+                            readonly value: boolean;
+                        } | {
+                            readonly type: "integer";
+                            readonly value: string;
+                        } | {
+                            readonly type: "string";
+                            readonly value: string;
+                        };
+                    })[];
+                } | /*elided*/ any | {
+                    readonly type: "null-test";
+                    readonly column: string;
+                    readonly op: "IS NULL" | "IS NOT NULL";
+                } | {
+                    readonly type: "comparison";
+                    readonly column: string;
+                    readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                    readonly value: {
+                        readonly type: "boolean";
+                        readonly value: boolean;
+                    } | {
+                        readonly type: "integer";
+                        readonly value: string;
+                    } | {
+                        readonly type: "string";
+                        readonly value: string;
+                    };
+                };
+            } | {
+                readonly type: "null-test";
+                readonly column: string;
+                readonly op: "IS NULL" | "IS NOT NULL";
+            } | {
+                readonly type: "comparison";
+                readonly column: string;
+                readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                readonly value: {
+                    readonly type: "boolean";
+                    readonly value: boolean;
+                } | {
+                    readonly type: "integer";
+                    readonly value: string;
+                } | {
+                    readonly type: "string";
+                    readonly value: string;
+                };
+            } | undefined;
+            readonly isReplicaIdentity?: boolean | undefined;
+            readonly isPrimaryKey?: boolean | undefined;
+            readonly isImmediate?: boolean | undefined;
+            readonly name: string;
+            readonly columns: {
+                readonly [x: string]: "ASC" | "DESC";
+            };
+            readonly schema: string;
+            readonly tableName: string;
+            readonly unique: boolean;
         }[];
         tables: {
             replicaIdentityColumns: string[];
+            columns: {
+                [k: string]: {
+                    pgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | undefined;
+                    elemPgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | null | undefined;
+                    characterMaximumLength?: number | null | undefined;
+                    notNull?: boolean | null | undefined;
+                    dflt?: string | null | undefined;
+                    pos: number;
+                    dataType: string;
+                    typeOID: number;
+                };
+            };
             primaryKey?: string[] | undefined;
             schemaOID?: number | undefined;
             replicaIdentity?: "n" | "d" | "f" | "i" | undefined;
             name: string;
             schema: string;
-            oid: number;
-            columns: Record<string, {
-                pgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | undefined;
-                elemPgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | null | undefined;
-                characterMaximumLength?: number | null | undefined;
-                notNull?: boolean | null | undefined;
-                dflt?: string | null | undefined;
-                pos: number;
-                dataType: string;
-                typeOID: number;
-            }>;
             publications: Record<string, {
                 rowFilter: string | null;
             }>;
+            oid: number;
         }[];
     }>;
     previousSchema: v.Optional<{
         indexes: {
-            isReplicaIdentity?: boolean | undefined;
-            isPrimaryKey?: boolean | undefined;
-            isImmediate?: boolean | undefined;
-            name: string;
-            columns: Record<string, "ASC" | "DESC">;
-            schema: string;
-            tableName: string;
-            unique: boolean;
+            readonly predicate?: {
+                readonly type: "and" | "or";
+                readonly conditions: readonly (/*elided*/ any | {
+                    readonly type: "not";
+                    readonly condition: /*elided*/ any | /*elided*/ any | {
+                        readonly type: "null-test";
+                        readonly column: string;
+                        readonly op: "IS NULL" | "IS NOT NULL";
+                    } | {
+                        readonly type: "comparison";
+                        readonly column: string;
+                        readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                        readonly value: {
+                            readonly type: "boolean";
+                            readonly value: boolean;
+                        } | {
+                            readonly type: "integer";
+                            readonly value: string;
+                        } | {
+                            readonly type: "string";
+                            readonly value: string;
+                        };
+                    };
+                } | {
+                    readonly type: "null-test";
+                    readonly column: string;
+                    readonly op: "IS NULL" | "IS NOT NULL";
+                } | {
+                    readonly type: "comparison";
+                    readonly column: string;
+                    readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                    readonly value: {
+                        readonly type: "boolean";
+                        readonly value: boolean;
+                    } | {
+                        readonly type: "integer";
+                        readonly value: string;
+                    } | {
+                        readonly type: "string";
+                        readonly value: string;
+                    };
+                })[];
+            } | {
+                readonly type: "not";
+                readonly condition: {
+                    readonly type: "and" | "or";
+                    readonly conditions: readonly (/*elided*/ any | /*elided*/ any | {
+                        readonly type: "null-test";
+                        readonly column: string;
+                        readonly op: "IS NULL" | "IS NOT NULL";
+                    } | {
+                        readonly type: "comparison";
+                        readonly column: string;
+                        readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                        readonly value: {
+                            readonly type: "boolean";
+                            readonly value: boolean;
+                        } | {
+                            readonly type: "integer";
+                            readonly value: string;
+                        } | {
+                            readonly type: "string";
+                            readonly value: string;
+                        };
+                    })[];
+                } | /*elided*/ any | {
+                    readonly type: "null-test";
+                    readonly column: string;
+                    readonly op: "IS NULL" | "IS NOT NULL";
+                } | {
+                    readonly type: "comparison";
+                    readonly column: string;
+                    readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                    readonly value: {
+                        readonly type: "boolean";
+                        readonly value: boolean;
+                    } | {
+                        readonly type: "integer";
+                        readonly value: string;
+                    } | {
+                        readonly type: "string";
+                        readonly value: string;
+                    };
+                };
+            } | {
+                readonly type: "null-test";
+                readonly column: string;
+                readonly op: "IS NULL" | "IS NOT NULL";
+            } | {
+                readonly type: "comparison";
+                readonly column: string;
+                readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                readonly value: {
+                    readonly type: "boolean";
+                    readonly value: boolean;
+                } | {
+                    readonly type: "integer";
+                    readonly value: string;
+                } | {
+                    readonly type: "string";
+                    readonly value: string;
+                };
+            } | undefined;
+            readonly isReplicaIdentity?: boolean | undefined;
+            readonly isPrimaryKey?: boolean | undefined;
+            readonly isImmediate?: boolean | undefined;
+            readonly name: string;
+            readonly columns: {
+                readonly [x: string]: "ASC" | "DESC";
+            };
+            readonly schema: string;
+            readonly tableName: string;
+            readonly unique: boolean;
         }[];
         tables: {
             replicaIdentityColumns: string[];
+            columns: {
+                [k: string]: {
+                    pgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | undefined;
+                    elemPgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | null | undefined;
+                    characterMaximumLength?: number | null | undefined;
+                    notNull?: boolean | null | undefined;
+                    dflt?: string | null | undefined;
+                    pos: number;
+                    dataType: string;
+                    typeOID: number;
+                };
+            };
             primaryKey?: string[] | undefined;
             schemaOID?: number | undefined;
             replicaIdentity?: "n" | "d" | "f" | "i" | undefined;
             name: string;
             schema: string;
-            oid: number;
-            columns: Record<string, {
-                pgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | undefined;
-                elemPgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | null | undefined;
-                characterMaximumLength?: number | null | undefined;
-                notNull?: boolean | null | undefined;
-                dflt?: string | null | undefined;
-                pos: number;
-                dataType: string;
-                typeOID: number;
-            }>;
             publications: Record<string, {
                 rowFilter: string | null;
             }>;
+            oid: number;
         }[];
     }>;
 }, undefined>;
@@ -321,70 +963,284 @@ export declare const replicationEventSchema: v.UnionType<[v.ObjectType<Omit<Omit
     type: v.Type<"ddlStart">;
     schema: v.Optional<{
         indexes: {
-            isReplicaIdentity?: boolean | undefined;
-            isPrimaryKey?: boolean | undefined;
-            isImmediate?: boolean | undefined;
-            name: string;
-            columns: Record<string, "ASC" | "DESC">;
-            schema: string;
-            tableName: string;
-            unique: boolean;
+            readonly predicate?: {
+                readonly type: "and" | "or";
+                readonly conditions: readonly (/*elided*/ any | {
+                    readonly type: "not";
+                    readonly condition: /*elided*/ any | /*elided*/ any | {
+                        readonly type: "null-test";
+                        readonly column: string;
+                        readonly op: "IS NULL" | "IS NOT NULL";
+                    } | {
+                        readonly type: "comparison";
+                        readonly column: string;
+                        readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                        readonly value: {
+                            readonly type: "boolean";
+                            readonly value: boolean;
+                        } | {
+                            readonly type: "integer";
+                            readonly value: string;
+                        } | {
+                            readonly type: "string";
+                            readonly value: string;
+                        };
+                    };
+                } | {
+                    readonly type: "null-test";
+                    readonly column: string;
+                    readonly op: "IS NULL" | "IS NOT NULL";
+                } | {
+                    readonly type: "comparison";
+                    readonly column: string;
+                    readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                    readonly value: {
+                        readonly type: "boolean";
+                        readonly value: boolean;
+                    } | {
+                        readonly type: "integer";
+                        readonly value: string;
+                    } | {
+                        readonly type: "string";
+                        readonly value: string;
+                    };
+                })[];
+            } | {
+                readonly type: "not";
+                readonly condition: {
+                    readonly type: "and" | "or";
+                    readonly conditions: readonly (/*elided*/ any | /*elided*/ any | {
+                        readonly type: "null-test";
+                        readonly column: string;
+                        readonly op: "IS NULL" | "IS NOT NULL";
+                    } | {
+                        readonly type: "comparison";
+                        readonly column: string;
+                        readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                        readonly value: {
+                            readonly type: "boolean";
+                            readonly value: boolean;
+                        } | {
+                            readonly type: "integer";
+                            readonly value: string;
+                        } | {
+                            readonly type: "string";
+                            readonly value: string;
+                        };
+                    })[];
+                } | /*elided*/ any | {
+                    readonly type: "null-test";
+                    readonly column: string;
+                    readonly op: "IS NULL" | "IS NOT NULL";
+                } | {
+                    readonly type: "comparison";
+                    readonly column: string;
+                    readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                    readonly value: {
+                        readonly type: "boolean";
+                        readonly value: boolean;
+                    } | {
+                        readonly type: "integer";
+                        readonly value: string;
+                    } | {
+                        readonly type: "string";
+                        readonly value: string;
+                    };
+                };
+            } | {
+                readonly type: "null-test";
+                readonly column: string;
+                readonly op: "IS NULL" | "IS NOT NULL";
+            } | {
+                readonly type: "comparison";
+                readonly column: string;
+                readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                readonly value: {
+                    readonly type: "boolean";
+                    readonly value: boolean;
+                } | {
+                    readonly type: "integer";
+                    readonly value: string;
+                } | {
+                    readonly type: "string";
+                    readonly value: string;
+                };
+            } | undefined;
+            readonly isReplicaIdentity?: boolean | undefined;
+            readonly isPrimaryKey?: boolean | undefined;
+            readonly isImmediate?: boolean | undefined;
+            readonly name: string;
+            readonly columns: {
+                readonly [x: string]: "ASC" | "DESC";
+            };
+            readonly schema: string;
+            readonly tableName: string;
+            readonly unique: boolean;
         }[];
         tables: {
             replicaIdentityColumns: string[];
+            columns: {
+                [k: string]: {
+                    pgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | undefined;
+                    elemPgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | null | undefined;
+                    characterMaximumLength?: number | null | undefined;
+                    notNull?: boolean | null | undefined;
+                    dflt?: string | null | undefined;
+                    pos: number;
+                    dataType: string;
+                    typeOID: number;
+                };
+            };
             primaryKey?: string[] | undefined;
             schemaOID?: number | undefined;
             replicaIdentity?: "n" | "d" | "f" | "i" | undefined;
             name: string;
             schema: string;
-            oid: number;
-            columns: Record<string, {
-                pgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | undefined;
-                elemPgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | null | undefined;
-                characterMaximumLength?: number | null | undefined;
-                notNull?: boolean | null | undefined;
-                dflt?: string | null | undefined;
-                pos: number;
-                dataType: string;
-                typeOID: number;
-            }>;
             publications: Record<string, {
                 rowFilter: string | null;
             }>;
+            oid: number;
         }[];
     }>;
     previousSchema: v.Optional<{
         indexes: {
-            isReplicaIdentity?: boolean | undefined;
-            isPrimaryKey?: boolean | undefined;
-            isImmediate?: boolean | undefined;
-            name: string;
-            columns: Record<string, "ASC" | "DESC">;
-            schema: string;
-            tableName: string;
-            unique: boolean;
+            readonly predicate?: {
+                readonly type: "and" | "or";
+                readonly conditions: readonly (/*elided*/ any | {
+                    readonly type: "not";
+                    readonly condition: /*elided*/ any | /*elided*/ any | {
+                        readonly type: "null-test";
+                        readonly column: string;
+                        readonly op: "IS NULL" | "IS NOT NULL";
+                    } | {
+                        readonly type: "comparison";
+                        readonly column: string;
+                        readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                        readonly value: {
+                            readonly type: "boolean";
+                            readonly value: boolean;
+                        } | {
+                            readonly type: "integer";
+                            readonly value: string;
+                        } | {
+                            readonly type: "string";
+                            readonly value: string;
+                        };
+                    };
+                } | {
+                    readonly type: "null-test";
+                    readonly column: string;
+                    readonly op: "IS NULL" | "IS NOT NULL";
+                } | {
+                    readonly type: "comparison";
+                    readonly column: string;
+                    readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                    readonly value: {
+                        readonly type: "boolean";
+                        readonly value: boolean;
+                    } | {
+                        readonly type: "integer";
+                        readonly value: string;
+                    } | {
+                        readonly type: "string";
+                        readonly value: string;
+                    };
+                })[];
+            } | {
+                readonly type: "not";
+                readonly condition: {
+                    readonly type: "and" | "or";
+                    readonly conditions: readonly (/*elided*/ any | /*elided*/ any | {
+                        readonly type: "null-test";
+                        readonly column: string;
+                        readonly op: "IS NULL" | "IS NOT NULL";
+                    } | {
+                        readonly type: "comparison";
+                        readonly column: string;
+                        readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                        readonly value: {
+                            readonly type: "boolean";
+                            readonly value: boolean;
+                        } | {
+                            readonly type: "integer";
+                            readonly value: string;
+                        } | {
+                            readonly type: "string";
+                            readonly value: string;
+                        };
+                    })[];
+                } | /*elided*/ any | {
+                    readonly type: "null-test";
+                    readonly column: string;
+                    readonly op: "IS NULL" | "IS NOT NULL";
+                } | {
+                    readonly type: "comparison";
+                    readonly column: string;
+                    readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                    readonly value: {
+                        readonly type: "boolean";
+                        readonly value: boolean;
+                    } | {
+                        readonly type: "integer";
+                        readonly value: string;
+                    } | {
+                        readonly type: "string";
+                        readonly value: string;
+                    };
+                };
+            } | {
+                readonly type: "null-test";
+                readonly column: string;
+                readonly op: "IS NULL" | "IS NOT NULL";
+            } | {
+                readonly type: "comparison";
+                readonly column: string;
+                readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                readonly value: {
+                    readonly type: "boolean";
+                    readonly value: boolean;
+                } | {
+                    readonly type: "integer";
+                    readonly value: string;
+                } | {
+                    readonly type: "string";
+                    readonly value: string;
+                };
+            } | undefined;
+            readonly isReplicaIdentity?: boolean | undefined;
+            readonly isPrimaryKey?: boolean | undefined;
+            readonly isImmediate?: boolean | undefined;
+            readonly name: string;
+            readonly columns: {
+                readonly [x: string]: "ASC" | "DESC";
+            };
+            readonly schema: string;
+            readonly tableName: string;
+            readonly unique: boolean;
         }[];
         tables: {
             replicaIdentityColumns: string[];
+            columns: {
+                [k: string]: {
+                    pgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | undefined;
+                    elemPgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | null | undefined;
+                    characterMaximumLength?: number | null | undefined;
+                    notNull?: boolean | null | undefined;
+                    dflt?: string | null | undefined;
+                    pos: number;
+                    dataType: string;
+                    typeOID: number;
+                };
+            };
             primaryKey?: string[] | undefined;
             schemaOID?: number | undefined;
             replicaIdentity?: "n" | "d" | "f" | "i" | undefined;
             name: string;
             schema: string;
-            oid: number;
-            columns: Record<string, {
-                pgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | undefined;
-                elemPgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | null | undefined;
-                characterMaximumLength?: number | null | undefined;
-                notNull?: boolean | null | undefined;
-                dflt?: string | null | undefined;
-                pos: number;
-                dataType: string;
-                typeOID: number;
-            }>;
             publications: Record<string, {
                 rowFilter: string | null;
             }>;
+            oid: number;
         }[];
     } | null>;
     event: v.Type<{
@@ -404,70 +1260,284 @@ export declare const replicationEventSchema: v.UnionType<[v.ObjectType<Omit<Omit
     type: v.Type<"ddlUpdate">;
     schema: v.Type<{
         indexes: {
-            isReplicaIdentity?: boolean | undefined;
-            isPrimaryKey?: boolean | undefined;
-            isImmediate?: boolean | undefined;
-            name: string;
-            columns: Record<string, "ASC" | "DESC">;
-            schema: string;
-            tableName: string;
-            unique: boolean;
+            readonly predicate?: {
+                readonly type: "and" | "or";
+                readonly conditions: readonly (/*elided*/ any | {
+                    readonly type: "not";
+                    readonly condition: /*elided*/ any | /*elided*/ any | {
+                        readonly type: "null-test";
+                        readonly column: string;
+                        readonly op: "IS NULL" | "IS NOT NULL";
+                    } | {
+                        readonly type: "comparison";
+                        readonly column: string;
+                        readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                        readonly value: {
+                            readonly type: "boolean";
+                            readonly value: boolean;
+                        } | {
+                            readonly type: "integer";
+                            readonly value: string;
+                        } | {
+                            readonly type: "string";
+                            readonly value: string;
+                        };
+                    };
+                } | {
+                    readonly type: "null-test";
+                    readonly column: string;
+                    readonly op: "IS NULL" | "IS NOT NULL";
+                } | {
+                    readonly type: "comparison";
+                    readonly column: string;
+                    readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                    readonly value: {
+                        readonly type: "boolean";
+                        readonly value: boolean;
+                    } | {
+                        readonly type: "integer";
+                        readonly value: string;
+                    } | {
+                        readonly type: "string";
+                        readonly value: string;
+                    };
+                })[];
+            } | {
+                readonly type: "not";
+                readonly condition: {
+                    readonly type: "and" | "or";
+                    readonly conditions: readonly (/*elided*/ any | /*elided*/ any | {
+                        readonly type: "null-test";
+                        readonly column: string;
+                        readonly op: "IS NULL" | "IS NOT NULL";
+                    } | {
+                        readonly type: "comparison";
+                        readonly column: string;
+                        readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                        readonly value: {
+                            readonly type: "boolean";
+                            readonly value: boolean;
+                        } | {
+                            readonly type: "integer";
+                            readonly value: string;
+                        } | {
+                            readonly type: "string";
+                            readonly value: string;
+                        };
+                    })[];
+                } | /*elided*/ any | {
+                    readonly type: "null-test";
+                    readonly column: string;
+                    readonly op: "IS NULL" | "IS NOT NULL";
+                } | {
+                    readonly type: "comparison";
+                    readonly column: string;
+                    readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                    readonly value: {
+                        readonly type: "boolean";
+                        readonly value: boolean;
+                    } | {
+                        readonly type: "integer";
+                        readonly value: string;
+                    } | {
+                        readonly type: "string";
+                        readonly value: string;
+                    };
+                };
+            } | {
+                readonly type: "null-test";
+                readonly column: string;
+                readonly op: "IS NULL" | "IS NOT NULL";
+            } | {
+                readonly type: "comparison";
+                readonly column: string;
+                readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                readonly value: {
+                    readonly type: "boolean";
+                    readonly value: boolean;
+                } | {
+                    readonly type: "integer";
+                    readonly value: string;
+                } | {
+                    readonly type: "string";
+                    readonly value: string;
+                };
+            } | undefined;
+            readonly isReplicaIdentity?: boolean | undefined;
+            readonly isPrimaryKey?: boolean | undefined;
+            readonly isImmediate?: boolean | undefined;
+            readonly name: string;
+            readonly columns: {
+                readonly [x: string]: "ASC" | "DESC";
+            };
+            readonly schema: string;
+            readonly tableName: string;
+            readonly unique: boolean;
         }[];
         tables: {
             replicaIdentityColumns: string[];
+            columns: {
+                [k: string]: {
+                    pgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | undefined;
+                    elemPgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | null | undefined;
+                    characterMaximumLength?: number | null | undefined;
+                    notNull?: boolean | null | undefined;
+                    dflt?: string | null | undefined;
+                    pos: number;
+                    dataType: string;
+                    typeOID: number;
+                };
+            };
             primaryKey?: string[] | undefined;
             schemaOID?: number | undefined;
             replicaIdentity?: "n" | "d" | "f" | "i" | undefined;
             name: string;
             schema: string;
-            oid: number;
-            columns: Record<string, {
-                pgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | undefined;
-                elemPgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | null | undefined;
-                characterMaximumLength?: number | null | undefined;
-                notNull?: boolean | null | undefined;
-                dflt?: string | null | undefined;
-                pos: number;
-                dataType: string;
-                typeOID: number;
-            }>;
             publications: Record<string, {
                 rowFilter: string | null;
             }>;
+            oid: number;
         }[];
     }>;
     previousSchema: v.Optional<{
         indexes: {
-            isReplicaIdentity?: boolean | undefined;
-            isPrimaryKey?: boolean | undefined;
-            isImmediate?: boolean | undefined;
-            name: string;
-            columns: Record<string, "ASC" | "DESC">;
-            schema: string;
-            tableName: string;
-            unique: boolean;
+            readonly predicate?: {
+                readonly type: "and" | "or";
+                readonly conditions: readonly (/*elided*/ any | {
+                    readonly type: "not";
+                    readonly condition: /*elided*/ any | /*elided*/ any | {
+                        readonly type: "null-test";
+                        readonly column: string;
+                        readonly op: "IS NULL" | "IS NOT NULL";
+                    } | {
+                        readonly type: "comparison";
+                        readonly column: string;
+                        readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                        readonly value: {
+                            readonly type: "boolean";
+                            readonly value: boolean;
+                        } | {
+                            readonly type: "integer";
+                            readonly value: string;
+                        } | {
+                            readonly type: "string";
+                            readonly value: string;
+                        };
+                    };
+                } | {
+                    readonly type: "null-test";
+                    readonly column: string;
+                    readonly op: "IS NULL" | "IS NOT NULL";
+                } | {
+                    readonly type: "comparison";
+                    readonly column: string;
+                    readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                    readonly value: {
+                        readonly type: "boolean";
+                        readonly value: boolean;
+                    } | {
+                        readonly type: "integer";
+                        readonly value: string;
+                    } | {
+                        readonly type: "string";
+                        readonly value: string;
+                    };
+                })[];
+            } | {
+                readonly type: "not";
+                readonly condition: {
+                    readonly type: "and" | "or";
+                    readonly conditions: readonly (/*elided*/ any | /*elided*/ any | {
+                        readonly type: "null-test";
+                        readonly column: string;
+                        readonly op: "IS NULL" | "IS NOT NULL";
+                    } | {
+                        readonly type: "comparison";
+                        readonly column: string;
+                        readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                        readonly value: {
+                            readonly type: "boolean";
+                            readonly value: boolean;
+                        } | {
+                            readonly type: "integer";
+                            readonly value: string;
+                        } | {
+                            readonly type: "string";
+                            readonly value: string;
+                        };
+                    })[];
+                } | /*elided*/ any | {
+                    readonly type: "null-test";
+                    readonly column: string;
+                    readonly op: "IS NULL" | "IS NOT NULL";
+                } | {
+                    readonly type: "comparison";
+                    readonly column: string;
+                    readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                    readonly value: {
+                        readonly type: "boolean";
+                        readonly value: boolean;
+                    } | {
+                        readonly type: "integer";
+                        readonly value: string;
+                    } | {
+                        readonly type: "string";
+                        readonly value: string;
+                    };
+                };
+            } | {
+                readonly type: "null-test";
+                readonly column: string;
+                readonly op: "IS NULL" | "IS NOT NULL";
+            } | {
+                readonly type: "comparison";
+                readonly column: string;
+                readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                readonly value: {
+                    readonly type: "boolean";
+                    readonly value: boolean;
+                } | {
+                    readonly type: "integer";
+                    readonly value: string;
+                } | {
+                    readonly type: "string";
+                    readonly value: string;
+                };
+            } | undefined;
+            readonly isReplicaIdentity?: boolean | undefined;
+            readonly isPrimaryKey?: boolean | undefined;
+            readonly isImmediate?: boolean | undefined;
+            readonly name: string;
+            readonly columns: {
+                readonly [x: string]: "ASC" | "DESC";
+            };
+            readonly schema: string;
+            readonly tableName: string;
+            readonly unique: boolean;
         }[];
         tables: {
             replicaIdentityColumns: string[];
+            columns: {
+                [k: string]: {
+                    pgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | undefined;
+                    elemPgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | null | undefined;
+                    characterMaximumLength?: number | null | undefined;
+                    notNull?: boolean | null | undefined;
+                    dflt?: string | null | undefined;
+                    pos: number;
+                    dataType: string;
+                    typeOID: number;
+                };
+            };
             primaryKey?: string[] | undefined;
             schemaOID?: number | undefined;
             replicaIdentity?: "n" | "d" | "f" | "i" | undefined;
             name: string;
             schema: string;
-            oid: number;
-            columns: Record<string, {
-                pgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | undefined;
-                elemPgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | null | undefined;
-                characterMaximumLength?: number | null | undefined;
-                notNull?: boolean | null | undefined;
-                dflt?: string | null | undefined;
-                pos: number;
-                dataType: string;
-                typeOID: number;
-            }>;
             publications: Record<string, {
                 rowFilter: string | null;
             }>;
+            oid: number;
         }[];
     }>;
 }, undefined>, v.ObjectType<Omit<Omit<{
@@ -484,70 +1554,284 @@ export declare const replicationEventSchema: v.UnionType<[v.ObjectType<Omit<Omit
     type: v.Type<"schemaSnapshot">;
     schema: v.Type<{
         indexes: {
-            isReplicaIdentity?: boolean | undefined;
-            isPrimaryKey?: boolean | undefined;
-            isImmediate?: boolean | undefined;
-            name: string;
-            columns: Record<string, "ASC" | "DESC">;
-            schema: string;
-            tableName: string;
-            unique: boolean;
+            readonly predicate?: {
+                readonly type: "and" | "or";
+                readonly conditions: readonly (/*elided*/ any | {
+                    readonly type: "not";
+                    readonly condition: /*elided*/ any | /*elided*/ any | {
+                        readonly type: "null-test";
+                        readonly column: string;
+                        readonly op: "IS NULL" | "IS NOT NULL";
+                    } | {
+                        readonly type: "comparison";
+                        readonly column: string;
+                        readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                        readonly value: {
+                            readonly type: "boolean";
+                            readonly value: boolean;
+                        } | {
+                            readonly type: "integer";
+                            readonly value: string;
+                        } | {
+                            readonly type: "string";
+                            readonly value: string;
+                        };
+                    };
+                } | {
+                    readonly type: "null-test";
+                    readonly column: string;
+                    readonly op: "IS NULL" | "IS NOT NULL";
+                } | {
+                    readonly type: "comparison";
+                    readonly column: string;
+                    readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                    readonly value: {
+                        readonly type: "boolean";
+                        readonly value: boolean;
+                    } | {
+                        readonly type: "integer";
+                        readonly value: string;
+                    } | {
+                        readonly type: "string";
+                        readonly value: string;
+                    };
+                })[];
+            } | {
+                readonly type: "not";
+                readonly condition: {
+                    readonly type: "and" | "or";
+                    readonly conditions: readonly (/*elided*/ any | /*elided*/ any | {
+                        readonly type: "null-test";
+                        readonly column: string;
+                        readonly op: "IS NULL" | "IS NOT NULL";
+                    } | {
+                        readonly type: "comparison";
+                        readonly column: string;
+                        readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                        readonly value: {
+                            readonly type: "boolean";
+                            readonly value: boolean;
+                        } | {
+                            readonly type: "integer";
+                            readonly value: string;
+                        } | {
+                            readonly type: "string";
+                            readonly value: string;
+                        };
+                    })[];
+                } | /*elided*/ any | {
+                    readonly type: "null-test";
+                    readonly column: string;
+                    readonly op: "IS NULL" | "IS NOT NULL";
+                } | {
+                    readonly type: "comparison";
+                    readonly column: string;
+                    readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                    readonly value: {
+                        readonly type: "boolean";
+                        readonly value: boolean;
+                    } | {
+                        readonly type: "integer";
+                        readonly value: string;
+                    } | {
+                        readonly type: "string";
+                        readonly value: string;
+                    };
+                };
+            } | {
+                readonly type: "null-test";
+                readonly column: string;
+                readonly op: "IS NULL" | "IS NOT NULL";
+            } | {
+                readonly type: "comparison";
+                readonly column: string;
+                readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                readonly value: {
+                    readonly type: "boolean";
+                    readonly value: boolean;
+                } | {
+                    readonly type: "integer";
+                    readonly value: string;
+                } | {
+                    readonly type: "string";
+                    readonly value: string;
+                };
+            } | undefined;
+            readonly isReplicaIdentity?: boolean | undefined;
+            readonly isPrimaryKey?: boolean | undefined;
+            readonly isImmediate?: boolean | undefined;
+            readonly name: string;
+            readonly columns: {
+                readonly [x: string]: "ASC" | "DESC";
+            };
+            readonly schema: string;
+            readonly tableName: string;
+            readonly unique: boolean;
         }[];
         tables: {
             replicaIdentityColumns: string[];
+            columns: {
+                [k: string]: {
+                    pgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | undefined;
+                    elemPgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | null | undefined;
+                    characterMaximumLength?: number | null | undefined;
+                    notNull?: boolean | null | undefined;
+                    dflt?: string | null | undefined;
+                    pos: number;
+                    dataType: string;
+                    typeOID: number;
+                };
+            };
             primaryKey?: string[] | undefined;
             schemaOID?: number | undefined;
             replicaIdentity?: "n" | "d" | "f" | "i" | undefined;
             name: string;
             schema: string;
-            oid: number;
-            columns: Record<string, {
-                pgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | undefined;
-                elemPgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | null | undefined;
-                characterMaximumLength?: number | null | undefined;
-                notNull?: boolean | null | undefined;
-                dflt?: string | null | undefined;
-                pos: number;
-                dataType: string;
-                typeOID: number;
-            }>;
             publications: Record<string, {
                 rowFilter: string | null;
             }>;
+            oid: number;
         }[];
     }>;
     previousSchema: v.Optional<{
         indexes: {
-            isReplicaIdentity?: boolean | undefined;
-            isPrimaryKey?: boolean | undefined;
-            isImmediate?: boolean | undefined;
-            name: string;
-            columns: Record<string, "ASC" | "DESC">;
-            schema: string;
-            tableName: string;
-            unique: boolean;
+            readonly predicate?: {
+                readonly type: "and" | "or";
+                readonly conditions: readonly (/*elided*/ any | {
+                    readonly type: "not";
+                    readonly condition: /*elided*/ any | /*elided*/ any | {
+                        readonly type: "null-test";
+                        readonly column: string;
+                        readonly op: "IS NULL" | "IS NOT NULL";
+                    } | {
+                        readonly type: "comparison";
+                        readonly column: string;
+                        readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                        readonly value: {
+                            readonly type: "boolean";
+                            readonly value: boolean;
+                        } | {
+                            readonly type: "integer";
+                            readonly value: string;
+                        } | {
+                            readonly type: "string";
+                            readonly value: string;
+                        };
+                    };
+                } | {
+                    readonly type: "null-test";
+                    readonly column: string;
+                    readonly op: "IS NULL" | "IS NOT NULL";
+                } | {
+                    readonly type: "comparison";
+                    readonly column: string;
+                    readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                    readonly value: {
+                        readonly type: "boolean";
+                        readonly value: boolean;
+                    } | {
+                        readonly type: "integer";
+                        readonly value: string;
+                    } | {
+                        readonly type: "string";
+                        readonly value: string;
+                    };
+                })[];
+            } | {
+                readonly type: "not";
+                readonly condition: {
+                    readonly type: "and" | "or";
+                    readonly conditions: readonly (/*elided*/ any | /*elided*/ any | {
+                        readonly type: "null-test";
+                        readonly column: string;
+                        readonly op: "IS NULL" | "IS NOT NULL";
+                    } | {
+                        readonly type: "comparison";
+                        readonly column: string;
+                        readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                        readonly value: {
+                            readonly type: "boolean";
+                            readonly value: boolean;
+                        } | {
+                            readonly type: "integer";
+                            readonly value: string;
+                        } | {
+                            readonly type: "string";
+                            readonly value: string;
+                        };
+                    })[];
+                } | /*elided*/ any | {
+                    readonly type: "null-test";
+                    readonly column: string;
+                    readonly op: "IS NULL" | "IS NOT NULL";
+                } | {
+                    readonly type: "comparison";
+                    readonly column: string;
+                    readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                    readonly value: {
+                        readonly type: "boolean";
+                        readonly value: boolean;
+                    } | {
+                        readonly type: "integer";
+                        readonly value: string;
+                    } | {
+                        readonly type: "string";
+                        readonly value: string;
+                    };
+                };
+            } | {
+                readonly type: "null-test";
+                readonly column: string;
+                readonly op: "IS NULL" | "IS NOT NULL";
+            } | {
+                readonly type: "comparison";
+                readonly column: string;
+                readonly op: "=" | "<>" | "<" | "<=" | ">" | ">=";
+                readonly value: {
+                    readonly type: "boolean";
+                    readonly value: boolean;
+                } | {
+                    readonly type: "integer";
+                    readonly value: string;
+                } | {
+                    readonly type: "string";
+                    readonly value: string;
+                };
+            } | undefined;
+            readonly isReplicaIdentity?: boolean | undefined;
+            readonly isPrimaryKey?: boolean | undefined;
+            readonly isImmediate?: boolean | undefined;
+            readonly name: string;
+            readonly columns: {
+                readonly [x: string]: "ASC" | "DESC";
+            };
+            readonly schema: string;
+            readonly tableName: string;
+            readonly unique: boolean;
         }[];
         tables: {
             replicaIdentityColumns: string[];
+            columns: {
+                [k: string]: {
+                    pgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | undefined;
+                    elemPgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | null | undefined;
+                    characterMaximumLength?: number | null | undefined;
+                    notNull?: boolean | null | undefined;
+                    dflt?: string | null | undefined;
+                    pos: number;
+                    dataType: string;
+                    typeOID: number;
+                };
+            };
             primaryKey?: string[] | undefined;
             schemaOID?: number | undefined;
             replicaIdentity?: "n" | "d" | "f" | "i" | undefined;
             name: string;
             schema: string;
-            oid: number;
-            columns: Record<string, {
-                pgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | undefined;
-                elemPgTypeClass?: "e" | "d" | "b" | "c" | "p" | "r" | "m" | null | undefined;
-                characterMaximumLength?: number | null | undefined;
-                notNull?: boolean | null | undefined;
-                dflt?: string | null | undefined;
-                pos: number;
-                dataType: string;
-                typeOID: number;
-            }>;
             publications: Record<string, {
                 rowFilter: string | null;
             }>;
+            oid: number;
         }[];
     }>;
 }, undefined>]>;
@@ -569,7 +1853,7 @@ export type ReplicationEvent = v.Infer<typeof replicationEventSchema>;
  * Instead, we opt for the simplicity and isolation of having each shard
  * completely own (and maintain) the entirety of its trigger/function stack.
  */
-export declare function createEventFunctionStatements(shard: ShardConfig): string;
+export declare function createEventFunctionStatements(shard: ShardConfig, includePartialIndexes?: boolean): string;
 export declare const TAGS: readonly ["CREATE TABLE", "ALTER TABLE", "CREATE INDEX", "DROP TABLE", "DROP INDEX", "ALTER PUBLICATION", "ALTER SCHEMA"];
 export declare function createEventTriggerStatements(shard: ShardConfig): string;
 export declare function dropEventTriggerStatements(appID: string, shardID: string | number): string;